LangGraph is the flowchart. The gate is what you sell.

State, nodes, edges, then the one feature that makes an insurer say yes: a pause button before anything reaches a customer.

Recall check (from Lesson 1): you were told LangGraph does not do data validation, it is the flowchart around the pipeline. Hold that claim in mind, this lesson either confirms it or it doesn't. Verified against current docs 2026-07-27.

The one idea: A LangGraph StateGraph is three things: a state (a dict that flows through), nodes (plain functions that read and update that state), and edges (which node runs next, sometimes decided by a condition). Nothing here reads a policy document or checks a citation. That work still happens inside your node functions, in plain Python.

The skeleton

from typing import TypedDict, Annotated
from operator import add
from langgraph.graph import StateGraph, START, END

class AgentState(TypedDict):
    question: str
    policy_id: str
    retrieved: list          # chunks from Lesson 3
    draft_answer: str
    approved: bool

def retrieve_node(state: AgentState):
    docs = vector_store.similarity_search(state["question"], k=3)
    return {"retrieved": docs}

def draft_node(state: AgentState):
    context = "\n\n".join(d.page_content for d in state["retrieved"])
    answer = model.invoke(f"Answer using only this context:\n{context}\n\nQuestion: {state['question']}")
    return {"draft_answer": answer.content}

builder = StateGraph(AgentState)
builder.add_node("retrieve", retrieve_node)
builder.add_node("draft", draft_node)
builder.add_edge(START, "retrieve")
builder.add_edge("retrieve", "draft")
builder.add_edge("draft", END)

Read that skeleton against the claim above: retrieve_node and draft_node are ordinary functions. LangGraph's only job is deciding retrieve runs, then draft runs. That is the whole flowchart, for now.

The approval gate: interrupt()

Add one more node between draft and END. It pauses the entire graph and waits for a human, then resumes exactly where it left off.

from langgraph.types import interrupt, Command
from langgraph.checkpoint.memory import InMemorySaver

def approval_node(state: AgentState):
    decision = interrupt({
        "question": state["question"],
        "draft_answer": state["draft_answer"],
        "sources": [d.metadata["source"] for d in state["retrieved"]],
        "message": "Approve this answer before it reaches the customer?",
    })
    return {"approved": decision.get("action") == "approve"}

builder.add_node("approval", approval_node)
builder.add_edge("draft", "approval")
builder.add_edge("approval", END)

checkpointer = InMemorySaver()   # demo only; use SqliteSaver or Postgres in production
graph = builder.compile(checkpointer=checkpointer)

interrupt() stops the graph mid-run and hands the payload above to whatever human interface you build (a Slack message, a dashboard, an approval queue). Nothing continues until someone calls it back with a decision:

config = {"configurable": {"thread_id": "claim-4471"}}
graph.invoke({"question": "...", "policy_id": "S-240-113"}, config)
# ... graph pauses at approval_node, waiting ...

# a human reviews the draft_answer and sources, then:
graph.invoke(Command(resume={"action": "approve"}), config)

The checkpointer is what makes the pause survive: it saves state to disk (or memory, for the demo) so the graph can sit paused for minutes or days and resume with full context. Without a checkpointer, interrupt() has nothing to resume from.

Where validation actually lives

Go back to the recall check. LangGraph decided when to pause and who gets asked. It never touched whether the draft answer is correct, whether a cited clause is real, or whether the policy ID matches. That is still going to be a plain Python check, written by you, running inside a node, same as retrieve_node above. Lesson 5 writes that check. The claim from Lesson 1 holds: LangGraph orchestrates, code validates.

Conditional edges (the branch you'll actually want)

Most real flows aren't a straight line. Route differently depending on state, for example skip the approval gate on low-stakes questions and require it only for anything mentioning a claim payout:

def needs_approval(state: AgentState) -> str:
    if "claim" in state["question"].lower() or "payout" in state["question"].lower():
        return "approval"
    return END

builder.add_conditional_edges("draft", needs_approval, ["approval", END])

This one line is the enterprise pitch in code form: the client decides what "sensitive" means, you wire the condition.

Prove it stuck

What does interrupt() actually check before pausing the graph?

Why does interrupt() require a checkpointer to be useful?

Where does citation validation live in a LangGraph flow?

Read this next (primary source)

★ LangGraph's human-in-the-loop / interrupts guide. ~15 min. The full send-email-approval example there is the same pattern used above, just a different node.

Ask your teacher. Try: "show me the full interrupt payload for a real claim question", "how would this connect to a Slack approval message?", or "what's the difference between InMemorySaver and a production checkpointer?"

← Lesson 3: Embed, store, retrieve Next → Lesson 5: Capstone + the pitch