LangChain

The original LLM-app framework — standard model/tool interfaces, hundreds of integrations, and the create_agent prebuilt that compiles to a LangGraph agent

Website ↗ Repository ↗ Docs ↗

langchain-core==1.5.02026-07-21Python / JSMIT

#framework #agents #integrations #python

142.4k Completely free Open source

Doc version 1.0 · Updated July 3, 2026

Related tools

LangGraph

Multi-Agent Orchestration

Overview

LangChain is the framework the rest of the family plugs into: standard interfaces for chat models, messages, and tools, plus a large catalog of provider and vector-store integrations.
Since 1.0 the package is deliberately slim — the agent runtime lives in LangGraph, observability in LangSmith, and LangChain supplies the glue: create_agent builds a production-ready ReAct agent and returns it as a compiled LangGraph graph.

flowchart TB
  code["your agent code"] --> lc["LangChain — interfaces + create_agent"]
  lc --> lg["LangGraph — loop runtime"]
  lc --> prov[("model / tool integrations")]
  class lc roleFocus
  class lg roleTool
  class prov roleModel

The tutorials in this catalog use exactly that pair — ChatLiteLLM for provider routing and create_agent for the loop.
Whether you even need the glue layer is a fair question: Dropping LangChain wires the same loop with just LiteLLM + LangGraph and compares the tradeoffs.

When to use it

Reach for LangChain when you want a working tool-calling agent in minutes, model-vendor portability through one interface, and the integration catalog — and drop to LangGraph’s graph API when the loop itself needs custom shape.

Example

1.x · create_agent

When to use

create_agent is the standard way to get a tool-calling ReAct agent in one line. The @tool docstring becomes the tool's schema, and the returned agent is a compiled LangGraph graph.

How it flows

The loop calls the model, runs any requested tools, feeds results back, and stops when the model answers without a tool call.

Structure

flowchart LR
  q([invoke]) --> model[model]
  model -->|tool call| tools[tools]
  tools --> model
  model -->|done| out([answer])
  class model roleModel
  class tools roleTool

from langchain.agents import create_agent
from langchain_core.tools import tool

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

agent = create_agent("anthropic:claude-opus-4-8", tools=[multiply])
result = agent.invoke(
    {"messages": [{"role": "user", "content": "What is 6 x 7?"}]}
)
print(result["messages"][-1].content)

The Implementation tab has a runnable build of this pattern (langgraph_1).

When to use

init_chat_model gives you a provider-agnostic chat model from one "provider:model" string — swap Claude for GPT or Gemini without changing the calling code.

from langchain.chat_models import init_chat_model

model = init_chat_model("anthropic:claude-opus-4-8", temperature=0)
reply = model.invoke("In one sentence: what is an agent?")
print(reply.content)

For routing across many providers with one API key style, see LiteLLM.

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.)

Files

.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"]