Building with LangGraph

LangGraph became the production favorite in 2026 for good reasons — explicit state, checkpointing, first-class MCP. Build a real agent end-to-end and learn why.

55 min · Reviewed 2026

Why LangGraph won the enterprise seat

LangGraph models agents as explicit state machines. Every node mutates typed state. Every edge is conditional. Every run is checkpointed. This maps directly to what enterprises need: audit trails, pausable workflows, rollback, human approval gates. By early 2026, LangGraph surpassed CrewAI in GitHub stars for exactly these reasons.

The core objects

StateGraph — the graph itself. Nodes, edges, state type.
State — a TypedDict describing everything the graph carries.
Checkpointer — persists state between node runs (memory, SQLite, Postgres).
Command — controls flow; can jump to a node, update state, interrupt.
Interrupt — pauses the graph pending human input.

A real agent: researcher that cites sources

from langgraph.graph import StateGraph, END
from langgraph.checkpoint.memory import MemorySaver
from langchain_anthropic import ChatAnthropic
from langchain_mcp_adapters.client import MultiServerMCPClient
from typing import TypedDict, Annotated
import operator

class State(TypedDict):
    question: str
    plan: list[str]
    findings: Annotated[list[dict], operator.add]
    draft: str
    verdict: str

model = ChatAnthropic(model="claude-opus-4-7", temperature=0)

async def plan_node(state: State):
    resp = await model.ainvoke(
        f"Break this research question into 3-5 sub-questions:\n{state['question']}"
    )
    return {"plan": resp.content.split("\n")}

async def research_node(state: State):
    mcp = MultiServerMCPClient({
        "brave": {"command": "npx", "args": ["-y", "@mcp/brave-search"]},
    })
    tools = await mcp.get_tools()
    agent = create_react_agent(model, tools)
    findings = []
    for sub in state["plan"]:
        r = await agent.ainvoke({"messages": [("user", sub)]})
        findings.append({"sub": sub, "answer": r["messages"][-1].content})
    return {"findings": findings}

async def synthesize_node(state: State):
    context = "\n\n".join(f.get("answer", "") for f in state["findings"])
    resp = await model.ainvoke(
        f"Write a cited answer to: {state['question']}\n\nNotes:\n{context}"
    )
    return {"draft": resp.content}

async def verify_node(state: State):
    resp = await model.ainvoke(
        f"Rate this answer's faithfulness to the notes (pass/fail + reason):\n"
        f"Q: {state['question']}\nA: {state['draft']}"
    )
    return {"verdict": resp.content}

graph = StateGraph(State)
graph.add_node("plan", plan_node)
graph.add_node("research", research_node)
graph.add_node("synthesize", synthesize_node)
graph.add_node("verify", verify_node)
graph.set_entry_point("plan")
graph.add_edge("plan", "research")
graph.add_edge("research", "synthesize")
graph.add_edge("synthesize", "verify")
graph.add_edge("verify", END)

app = graph.compile(checkpointer=MemorySaver())A working LangGraph research agent using Claude + MCP (Brave search). ~50 lines of actual logic.

Human-in-the-loop with interrupt

from langgraph.types import interrupt, Command

async def approve_node(state: State):
    response = interrupt({
        "draft": state["draft"],
        "ask": "Approve to publish? Edit below if needed.",
    })
    return {"draft": response["edited_draft"]}

# In the client:
config = {"configurable": {"thread_id": "run-42"}}
async for event in app.astream({"question": "..."}, config):
    ...  # stream until interrupt

# Inspect state, get human input, then resume:
await app.ainvoke(
    Command(resume={"edited_draft": "<human's edits>"}),
    config
)interrupt() pauses the graph. The checkpointer stores state. Resume with Command(resume=...).

Streaming modes

Mode	Emits	Use for
values	Full state after each node.	Audit UIs, full snapshots.
updates	Partial state diffs.	Efficient live feeds.
messages	LLM tokens as they stream.	ChatGPT-style UIs.
debug	Internal events.	Debugging, tracing.

Production checkpointers

MemorySaver — in-process only. Great for tests and demos.
SqliteSaver — single-machine durability. Good for dev.
PostgresSaver — production multi-replica. Versioned state.
Redis-based community savers — low-latency distributed.

Next, we look at Claude Code — a commercial agent platform that ships with its own idioms for tools, subagents, and MCP.

End-of-lesson check

15 questions · take it digitally for instant feedback at tendril.neural-forge.io/learn/quiz/end-agentic-langgraph-building-creators

What is the core idea behind "Building with LangGraph"?
1. LangGraph became the production favorite in 2026 for good reasons — explicit state, checkpointing, first-class MCP. Build a real agent end-to-end and learn why.
2. A coding AI deleted important code because it 'thought' it was unused.
3. Letting the AI write the whole story — that's the AI's story, not yours.
4. Good: 'Step 2 of 4 complete — now writing the summary'
Which term best describes a foundational idea in "Building with LangGraph"?
1. checkpointer
2. StateGraph
3. interrupt
4. PostgresSaver
A learner studying Building with LangGraph would need to understand which concept?
1. StateGraph
2. interrupt
3. checkpointer
4. PostgresSaver
Which of these is directly relevant to Building with LangGraph?
1. StateGraph
2. checkpointer
3. PostgresSaver
4. interrupt
Which of the following is a key point about Building with LangGraph?
1. StateGraph — the graph itself. Nodes, edges, state type.
2. State — a TypedDict describing everything the graph carries.
3. Checkpointer — persists state between node runs (memory, SQLite, Postgres).
4. Command — controls flow; can jump to a node, update state, interrupt.
Which of these does NOT belong in a discussion of Building with LangGraph?
1. Checkpointer — persists state between node runs (memory, SQLite, Postgres).
2. StateGraph — the graph itself. Nodes, edges, state type.
3. A coding AI deleted important code because it 'thought' it was unused.
4. State — a TypedDict describing everything the graph carries.
Which statement is accurate regarding Building with LangGraph?
1. SqliteSaver — single-machine durability. Good for dev.
2. PostgresSaver — production multi-replica. Versioned state.
3. MemorySaver — in-process only. Great for tests and demos.
4. Redis-based community savers — low-latency distributed.
Which of these does NOT belong in a discussion of Building with LangGraph?
1. SqliteSaver — single-machine durability. Good for dev.
2. A coding AI deleted important code because it 'thought' it was unused.
3. MemorySaver — in-process only. Great for tests and demos.
4. PostgresSaver — production multi-replica. Versioned state.
What is the key insight about "LangGraph Platform" in the context of Building with LangGraph?
1. LangChain's LangGraph Platform (cloud-hosted) gives you managed checkpointing, observability (LangSmith), and horizontal…
2. A coding AI deleted important code because it 'thought' it was unused.
3. Letting the AI write the whole story — that's the AI's story, not yours.
4. Good: 'Step 2 of 4 complete — now writing the summary'
What is the key insight about "Don't over-graph" in the context of Building with LangGraph?
1. A coding AI deleted important code because it 'thought' it was unused.
2. Every node is another place to read. Start with 3–5 nodes. Collapse linear chains; only split when you need conditional …
3. Letting the AI write the whole story — that's the AI's story, not yours.
4. Good: 'Step 2 of 4 complete — now writing the summary'
What is the key warning about "Scope your agents tightly" in the context of Building with LangGraph?
1. A coding AI deleted important code because it 'thought' it was unused.
2. Letting the AI write the whole story — that's the AI's story, not yours.
3. Always define: goal, tools, permissions, and stop condition before executing.
4. Good: 'Step 2 of 4 complete — now writing the summary'
Which statement accurately describes an aspect of Building with LangGraph?
1. A coding AI deleted important code because it 'thought' it was unused.
2. Letting the AI write the whole story — that's the AI's story, not yours.
3. Good: 'Step 2 of 4 complete — now writing the summary'
4. LangGraph models agents as explicit state machines. Every node mutates typed state. Every edge is conditional. Every run is checkpointed.
What does working with Building with LangGraph typically involve?
1. Next, we look at Claude Code — a commercial agent platform that ships with its own idioms for tools, subagents, and MCP.
2. A coding AI deleted important code because it 'thought' it was unused.
3. Letting the AI write the whole story — that's the AI's story, not yours.
4. Good: 'Step 2 of 4 complete — now writing the summary'
Which best describes the scope of "Building with LangGraph"?
1. It is unrelated to agentic workflows
2. It focuses on LangGraph became the production favorite in 2026 for good reasons — explicit state, checkpointing, f
3. It applies only to the opposite beginner tier
4. It was deprecated in 2024 and no longer relevant
Which section heading best belongs in a lesson about Building with LangGraph?
1. A coding AI deleted important code because it 'thought' it was unused.
2. Letting the AI write the whole story — that's the AI's story, not yours.
3. The core objects
4. Good: 'Step 2 of 4 complete — now writing the summary'

← Back to interactive lesson

Tendril · Creators · Agentic AI

Building with LangGraph

LangGraph became the production favorite in 2026 for good reasons — explicit state, checkpointing, first-class MCP. Build a real agent end-to-end and learn why.

55 min · Reviewed 2026

Why LangGraph won the enterprise seat

The core objects

StateGraph — the graph itself. Nodes, edges, state type.
State — a TypedDict describing everything the graph carries.
Checkpointer — persists state between node runs (memory, SQLite, Postgres).
Command — controls flow; can jump to a node, update state, interrupt.
Interrupt — pauses the graph pending human input.

A real agent: researcher that cites sources

from langgraph.graph import StateGraph, END
from langgraph.checkpoint.memory import MemorySaver
from langchain_anthropic import ChatAnthropic
from langchain_mcp_adapters.client import MultiServerMCPClient
from typing import TypedDict, Annotated
import operator

class State(TypedDict):
    question: str
    plan: list[str]
    findings: Annotated[list[dict], operator.add]
    draft: str
    verdict: str

model = ChatAnthropic(model="claude-opus-4-7", temperature=0)

async def plan_node(state: State):
    resp = await model.ainvoke(
        f"Break this research question into 3-5 sub-questions:\n{state['question']}"
    )
    return {"plan": resp.content.split("\n")}

async def research_node(state: State):
    mcp = MultiServerMCPClient({
        "brave": {"command": "npx", "args": ["-y", "@mcp/brave-search"]},
    })
    tools = await mcp.get_tools()
    agent = create_react_agent(model, tools)
    findings = []
    for sub in state["plan"]:
        r = await agent.ainvoke({"messages": [("user", sub)]})
        findings.append({"sub": sub, "answer": r["messages"][-1].content})
    return {"findings": findings}

async def synthesize_node(state: State):
    context = "\n\n".join(f.get("answer", "") for f in state["findings"])
    resp = await model.ainvoke(
        f"Write a cited answer to: {state['question']}\n\nNotes:\n{context}"
    )
    return {"draft": resp.content}

async def verify_node(state: State):
    resp = await model.ainvoke(
        f"Rate this answer's faithfulness to the notes (pass/fail + reason):\n"
        f"Q: {state['question']}\nA: {state['draft']}"
    )
    return {"verdict": resp.content}

graph = StateGraph(State)
graph.add_node("plan", plan_node)
graph.add_node("research", research_node)
graph.add_node("synthesize", synthesize_node)
graph.add_node("verify", verify_node)
graph.set_entry_point("plan")
graph.add_edge("plan", "research")
graph.add_edge("research", "synthesize")
graph.add_edge("synthesize", "verify")
graph.add_edge("verify", END)

app = graph.compile(checkpointer=MemorySaver())A working LangGraph research agent using Claude + MCP (Brave search). ~50 lines of actual logic.

Human-in-the-loop with interrupt

from langgraph.types import interrupt, Command

async def approve_node(state: State):
    response = interrupt({
        "draft": state["draft"],
        "ask": "Approve to publish? Edit below if needed.",
    })
    return {"draft": response["edited_draft"]}

# In the client:
config = {"configurable": {"thread_id": "run-42"}}
async for event in app.astream({"question": "..."}, config):
    ...  # stream until interrupt

# Inspect state, get human input, then resume:
await app.ainvoke(
    Command(resume={"edited_draft": "<human's edits>"}),
    config
)interrupt() pauses the graph. The checkpointer stores state. Resume with Command(resume=...).

Streaming modes

Mode	Emits	Use for
values	Full state after each node.	Audit UIs, full snapshots.
updates	Partial state diffs.	Efficient live feeds.
messages	LLM tokens as they stream.	ChatGPT-style UIs.
debug	Internal events.	Debugging, tracing.

Production checkpointers

MemorySaver — in-process only. Great for tests and demos.
SqliteSaver — single-machine durability. Good for dev.
PostgresSaver — production multi-replica. Versioned state.
Redis-based community savers — low-latency distributed.

Next, we look at Claude Code — a commercial agent platform that ships with its own idioms for tools, subagents, and MCP.

End-of-lesson check

15 questions · take it digitally for instant feedback at tendril.neural-forge.io/learn/quiz/end-agentic-langgraph-building-creators

What is the core idea behind "Building with LangGraph"?
1. LangGraph became the production favorite in 2026 for good reasons — explicit state, checkpointing, first-class MCP. Build a real agent end-to-end and learn why.
2. A coding AI deleted important code because it 'thought' it was unused.
3. Letting the AI write the whole story — that's the AI's story, not yours.
4. Good: 'Step 2 of 4 complete — now writing the summary'
Which term best describes a foundational idea in "Building with LangGraph"?
1. checkpointer
2. StateGraph
3. interrupt
4. PostgresSaver
A learner studying Building with LangGraph would need to understand which concept?
1. StateGraph
2. interrupt
3. checkpointer
4. PostgresSaver
Which of these is directly relevant to Building with LangGraph?
1. StateGraph
2. checkpointer
3. PostgresSaver
4. interrupt
Which of the following is a key point about Building with LangGraph?
1. StateGraph — the graph itself. Nodes, edges, state type.
2. State — a TypedDict describing everything the graph carries.
3. Checkpointer — persists state between node runs (memory, SQLite, Postgres).
4. Command — controls flow; can jump to a node, update state, interrupt.
Which of these does NOT belong in a discussion of Building with LangGraph?
1. Checkpointer — persists state between node runs (memory, SQLite, Postgres).
2. StateGraph — the graph itself. Nodes, edges, state type.
3. A coding AI deleted important code because it 'thought' it was unused.
4. State — a TypedDict describing everything the graph carries.
Which statement is accurate regarding Building with LangGraph?
1. SqliteSaver — single-machine durability. Good for dev.
2. PostgresSaver — production multi-replica. Versioned state.
3. MemorySaver — in-process only. Great for tests and demos.
4. Redis-based community savers — low-latency distributed.
Which of these does NOT belong in a discussion of Building with LangGraph?
1. SqliteSaver — single-machine durability. Good for dev.
2. A coding AI deleted important code because it 'thought' it was unused.
3. MemorySaver — in-process only. Great for tests and demos.
4. PostgresSaver — production multi-replica. Versioned state.
What is the key insight about "LangGraph Platform" in the context of Building with LangGraph?
1. LangChain's LangGraph Platform (cloud-hosted) gives you managed checkpointing, observability (LangSmith), and horizontal…
2. A coding AI deleted important code because it 'thought' it was unused.
3. Letting the AI write the whole story — that's the AI's story, not yours.
4. Good: 'Step 2 of 4 complete — now writing the summary'
What is the key insight about "Don't over-graph" in the context of Building with LangGraph?
1. A coding AI deleted important code because it 'thought' it was unused.
2. Every node is another place to read. Start with 3–5 nodes. Collapse linear chains; only split when you need conditional …
3. Letting the AI write the whole story — that's the AI's story, not yours.
4. Good: 'Step 2 of 4 complete — now writing the summary'
What is the key warning about "Scope your agents tightly" in the context of Building with LangGraph?
1. A coding AI deleted important code because it 'thought' it was unused.
2. Letting the AI write the whole story — that's the AI's story, not yours.
3. Always define: goal, tools, permissions, and stop condition before executing.
4. Good: 'Step 2 of 4 complete — now writing the summary'
Which statement accurately describes an aspect of Building with LangGraph?
1. A coding AI deleted important code because it 'thought' it was unused.
2. Letting the AI write the whole story — that's the AI's story, not yours.
3. Good: 'Step 2 of 4 complete — now writing the summary'
4. LangGraph models agents as explicit state machines. Every node mutates typed state. Every edge is conditional. Every run is checkpointed.
What does working with Building with LangGraph typically involve?
1. Next, we look at Claude Code — a commercial agent platform that ships with its own idioms for tools, subagents, and MCP.
2. A coding AI deleted important code because it 'thought' it was unused.
3. Letting the AI write the whole story — that's the AI's story, not yours.
4. Good: 'Step 2 of 4 complete — now writing the summary'
Which best describes the scope of "Building with LangGraph"?
1. It is unrelated to agentic workflows
2. It focuses on LangGraph became the production favorite in 2026 for good reasons — explicit state, checkpointing, f
3. It applies only to the opposite beginner tier
4. It was deprecated in 2024 and no longer relevant
Which section heading best belongs in a lesson about Building with LangGraph?
1. A coding AI deleted important code because it 'thought' it was unused.
2. Letting the AI write the whole story — that's the AI's story, not yours.
3. The core objects
4. Good: 'Step 2 of 4 complete — now writing the summary'

← Back to interactive lesson