Lesson 05 — LangGraph Intro

When your agent has a shape, draw the shape. Graphs, nodes, edges, checkpoints.

Agents Module 3 LangGraph StateGraph

Recap of Module 2

• In L04 you used the Claude Agent SDK on a tool-heavy research assistant.
• Tool-call order was unbounded — the LLM decided which tool to call next based on what the previous tool returned.
• Today's lesson is for the opposite shape: a control flow you can draw, with explicit branches, loops, and recoverable failure points.
• Same Python, same Claude calls inside the nodes — just a different orchestration layer on top.

What LangGraph is

You declare:

• Nodes — functions that read/mutate state.
• Edges — which node runs next.
• A starting node — where execution begins.

The runtime walks the graph, persists state at every step, and can resume from any checkpoint.

What LangGraph isn't

• Not a chain library — that's the parent project, LangChain. We don't use LangChain in this course.
• Not bound to any LLM provider — you call whatever model you like from inside node functions. This course calls anthropic directly from nodes.
• Not a prompt library or RAG framework — graph orchestration only.
• Not the right tool when control flow is fully LLM-decided — L04's tool-heavy shape. Use the Claude Agent SDK there.

Three primitives you'll meet today

Hello-world graph in 20 lines

from typing import TypedDict
from langgraph.graph import StateGraph, START, END

class S(TypedDict):
    n: int
    log: list[str]

def add_one(s: S) -> dict:
    return {"n": s["n"] + 1, "log": s["log"] + ["add_one"]}

def double(s: S) -> dict:
    return {"n": s["n"] * 2, "log": s["log"] + ["double"]}

g = StateGraph(S)
g.add_node("add_one", add_one)
g.add_node("double", double)
g.add_edge(START, "add_one")
g.add_edge("add_one", "double")
g.add_edge("double", END)
app = g.compile()
print(app.invoke({"n": 3, "log": []}))
# {'n': 8, 'log': ['add_one', 'double']}

Three nodes (START, add_one, double, END), two edges, one compile. No LLM in the hello world on purpose — get the shape first.

Why a graph, not a chain?

Conditional edges in 8 lines

def route(s: S) -> str:
    return "double" if s["n"] > 10 else "add_one"

g.add_conditional_edges(
    "add_one",
    route,
    {"add_one": "add_one", "double": "double"},
)
g.add_edge("double", END)

After add_one, call route(state); the string it returns is keyed into the mapping to pick the next node. This is how branching, looping, and early-exit are all expressed.

Checkpoints in one line

from langgraph.checkpoint.sqlite import SqliteSaver

memory = SqliteSaver.from_conn_string(":memory:")
app = g.compile(checkpointer=memory)
app.invoke({"n": 3, "log": []}, config={"configurable": {"thread_id": "run-1"}})

Pass a checkpointer to .compile() and a thread_id per run, and every node transition writes the merged state to sqlite.

Crash, restart, resume — state is on disk.

What you can do with checkpoints

• Resume after crash — restart the process, call .invoke({}, config={...}) with the same thread_id, the graph picks up at the last completed node.
• Time-travel — inspect state at any prior checkpoint (app.get_state_history(...)) and re-run from there.
• Pause for human input — add interrupt_before=["approve"] to compile; the graph stops before the named node and waits for an external resume call.

When to pick LangGraph

Cost of switching

• From hand-rolled L02 → LangGraph: ~80 lines → ~50 lines and gain checkpoints; the nodes themselves still call anthropic directly so tool functions port verbatim.
• From Claude SDK → LangGraph: rewrite the orchestration; keep the @tool-decorated functions as plain functions called from nodes.
• From LangGraph → another framework: the graph topology and node bodies are LangGraph-specific. Plan for a rewrite at the assembly layer.

Recap & what's next

• LangGraph = explicit graph control flow for agents.
• Nodes are plain Python functions that return state updates.
• Checkpoints are free with SqliteSaver — resume, time-travel, human-in-the-loop.