samples/langgraph_1 — awesome-ai-stack

Example

LangGraph — minimal tool-using agent

A real, runnable mini-project. Download it and run with Docker.

View samples/langgraph_1 on GitHub ↗

June 28, 2026

LangGraph — minimal tool-using agent

A ~50-line LangGraph ReAct agent: it calls an LLM with two tools (multiply, is_prime) and runs the reasoning loop until it can answer. The model is routed through LiteLLM, so the same code works with Anthropic Claude, OpenAI, or Google AI Studio (Gemini) — just change MODEL in .env.

Configure

cd samples/langgraph_1
cp .env.sample .env
# edit .env: set MODEL and the matching provider key

MODEL picks the provider:

Provider	`MODEL` example	Key in `.env`
Anthropic Claude	`claude-opus-4-8`	`ANTHROPIC_API_KEY`
OpenAI	`gpt-4o`	`OPENAI_API_KEY`
Google AI Studio	`gemini/gemini-2.5-flash`	`GEMINI_API_KEY`
Ollama (local)	`ollama_chat/qwen3.5:9b`	`OLLAMA_API_BASE`

.env is gitignored — only .env.sample is committed.

Ollama (local models): first pull the model on the host — ollama pull qwen3.5:9b (or ollama run qwen3.5:9b). Then set MODEL=ollama_chat/qwen3.5:9b and point OLLAMA_API_BASE at the server — no API key needed. In a devcontainer with DooD the container reaches the host's Ollama at http://host.docker.internal:11434; running locally use http://localhost:11434. Tool-calling needs Ollama's chat endpoint, so use the ollama_chat/ prefix shown above (not ollama/) — with ollama/ the model returns empty output and no tool calls. The local model must also support tools (gemma, for one, does not).

Run with Docker

cd samples/langgraph_1
docker build -t aas-langgraph .
docker run --rm --env-file .env aas-langgraph \
  "What is 24 * 7, and is the result prime?"

Run with Docker (in a devcontainer with DooD)

In a dev container that talks to the host Docker daemon (Docker-outside-of-Docker), the foreground docker run above often prints nothing and exits 0 — but the run itself succeeds. The agent runs to completion and Docker captures all of its output; only the live attached stream drops it over the VM boundary. You can confirm this: docker logs on the same container shows the full output, the container exits 0, and it is not an OOM. Run detached and follow the logs instead:

cd samples/langgraph_1
docker build -t aas-langgraph .
docker logs -f "$(docker run -d --env-file .env aas-langgraph \
  "What is 24 * 7, and is the result prime?")"

Run locally

cd samples/langgraph_1
pip install -r requirements.txt
python app.py "What is 24 * 7, and is the result prime?"

python-dotenv loads .env automatically. Get keys from Anthropic, OpenAI, or Google AI Studio.

Example run

Output varies by model and run — LLMs are non-deterministic, so the exact wording (and an agent's steps) differ each time. Below is one run with claude-opus-4-8.

24 * 7 = **168**, and it is **not prime**. (168 is even and has many factors, such as 2, 3, 4, 6, 7, 8, etc.)

.env.sample

# Copy this file to `.env` and fill in the key for the provider you want.
#   cp .env.sample .env
#
# One codebase, many providers — LiteLLM routes the request based on MODEL.

# Pick the model. Examples:
#   claude-opus-4-8              Anthropic Claude   -> needs ANTHROPIC_API_KEY
#   gpt-4o                       OpenAI             -> needs OPENAI_API_KEY
#   gemini/gemini-2.5-flash      Google AI Studio   -> needs GEMINI_API_KEY
#   ollama_chat/qwen3.5:9b       Ollama (local)     -> needs OLLAMA_API_BASE, no key
MODEL=claude-opus-4-8

# Set only the key for the provider you chose; leave the rest blank.
ANTHROPIC_API_KEY=
OPENAI_API_KEY=
GEMINI_API_KEY=

# Ollama only — where the Ollama server runs (pull the model first, e.g.
# `ollama pull qwen3.5:9b`). Other providers ignore this line.
#   Local, no Docker:           http://localhost:11434
#   Docker / DooD on the host:  http://host.docker.internal:11434
OLLAMA_API_BASE=http://host.docker.internal:11434

app.py

"""Minimal LangGraph agent: a tool-using ReAct loop powered by any LiteLLM model.

The agent is given two small tools and decides—via LangGraph's prebuilt ReAct
graph—when to call them while answering the question. The model is routed through
LiteLLM, so the same code works with Anthropic Claude, OpenAI, or Google AI
Studio (Gemini); pick one via the MODEL env var (see .env.sample).

Run:
    docker build -t aas-langgraph .
    docker run --rm --env-file .env aas-langgraph \
        "What is 24 * 7, and is the result prime?"
"""

import os
import sys

import litellm
from dotenv import load_dotenv
from langchain.agents import create_agent
from langchain_litellm import ChatLiteLLM
from langchain_core.tools import tool

# Load .env when running locally; in Docker the keys come from --env-file.
load_dotenv()

# Drop params a given provider doesn't support (e.g. some Claude models reject
# temperature != 1), so the same code runs across OpenAI / Claude / Gemini.
litellm.drop_params = True


@tool
def multiply(a: int, b: int) -> int:
    """Multiply two integers."""
    return a * b


@tool
def is_prime(n: int) -> bool:
    """Return True if n is a prime number."""
    if n < 2:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True


def message_text(content) -> str:
    """Flatten an assistant message's content to plain text.

    Cloud models return a string; a local thinking model (via Ollama) returns a
    list of blocks like [{type: thinking}, {type: text}], so keep only the text.
    """
    if isinstance(content, list):
        return "".join(
            part.get("text", "")
            for part in content
            if isinstance(part, dict) and part.get("type") == "text"
        )
    return content


def main() -> None:
    question = " ".join(sys.argv[1:]) or "What is 24 * 7, and is the result prime?"

    # MODEL chooses the provider (claude-opus-4-8 / gpt-4o / gemini/gemini-2.5-flash).
    model = ChatLiteLLM(model=os.environ.get("MODEL", "claude-opus-4-8"), temperature=0)
    agent = create_agent(model, tools=[multiply, is_prime])

    result = agent.invoke({"messages": [{"role": "user", "content": question}]})
    print(message_text(result["messages"][-1].content))


if __name__ == "__main__":
    main()

Dockerfile

# Minimal image for the LangGraph sample agent.
FROM python:3.13-slim

# Stream stdout/stderr unbuffered so the agent's output appears live (and isn't
# lost if the container is killed mid-run, e.g. under low memory).
ENV PYTHONUNBUFFERED=1

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY app.py .

# Provide your config at run time (.env is NOT baked into the image):
#   docker run --rm --env-file .env aas-langgraph "<question>"
ENTRYPOINT ["python", "app.py"]