LangGraph

A LangGraph program is a StateGraph: a typed state schema, nodes (plain functions) that return partial state updates, and edges, fixed or conditional, that pick the next node. Each state key has a reducer that decides how updates are merged. The runtime follows a Pregel-style model of discrete super-steps, so nodes on parallel branches execute in the same step. A decorator-based Functional API exposes the same runtime for code that uses ordinary control flow.

There is no built-in agent-role abstraction. Multi-agent systems are assembled by composing graphs: a compiled graph can run as a node of a parent graph, and LangChain's multi-agent guides (subagents, handoffs, routers) are built on this runtime. The developer owns the topology.

Persistence has two layers. Checkpointers save a thread's state after each step, keyed by thread_id; this is what makes resumption, replay and forking possible. Stores keep application data across threads for long-term memory. In-memory implementations are meant for development, and the docs recommend database-backed ones in production.

Any node can call interrupt(value). The run pauses, the checkpointer saves state, and the value is returned to the caller. The caller resumes by invoking the graph again on the same thread_id with Command(resume=...), and that value becomes the return value of interrupt(). The docs show approve or reject gates, review-and-edit of LLM output or tool calls, and input validation loops. A checkpointer and a thread ID are required. On resume the interrupted node starts again from its first line, so side effects placed before the interrupt should be idempotent. Earlier checkpoints can also be replayed or forked with edited state.

pip install -U langgraph

from typing import TypedDict
from langgraph.graph import StateGraph, START, END
from langgraph.checkpoint.memory import InMemorySaver
from langgraph.types import interrupt, Command

class State(TypedDict):
    draft: str
    approved: bool

def write(state: State):
    return {"draft": "Refund order 123"}
def review(state: State):
    return {"approved": interrupt({"please_check": state["draft"]})}

g = StateGraph(State).add_node(write).add_node(review)
g = g.add_edge(START, "write").add_edge("write", "review").add_edge("review", END)
graph = g.compile(checkpointer=InMemorySaver())
cfg = {"configurable": {"thread_id": "t1"}}
graph.invoke({"draft": "", "approved": False}, cfg)  # stops inside review
print(graph.invoke(Command(resume=True), cfg))  # resumes; approved=True

• The package requires Python 3.10 or newer (requires-python in libs/langgraph/pyproject.toml).
• Model providers are separate packages; the official quickstart uses an Anthropic model and expects ANTHROPIC_API_KEY.
• interrupt() only works when the graph is compiled with a checkpointer and invoked with a thread_id in the config.
• On resume the interrupted node re-runs from the top; keep side effects after the interrupt() call or make them idempotent.
• LangGraph v1 deprecated the prebuilt create_react_agent; new code should use LangChain's create_agent.

Yes, on the serving side. Agent Server, which runs LangGraph graphs locally via langgraph dev or in LangSmith deployments, exposes agents as MCP tools at /mcp over Streamable HTTP.

The library is MIT-licensed. LangChain Inc. sells LangSmith plans, and the pricing page lists deployment access starting with the paid Plus plan.

This repository is the Python library and needs Python 3.10 or newer. JavaScript and TypeScript users have a separate LangGraph.js project.

LangChain supplies model and tool integrations plus a prebuilt create_agent loop that runs on LangGraph. LangGraph is the lower-level runtime for custom graphs with checkpoints and interrupts.