One working agent. One page you can say out loud.

Everything from Lessons 1-4, wired into a script, plus the citation check that was still missing, plus the words for the sales call.

The one idea: A demo that can hallucinate a citation is worse than no demo. The last missing piece is a plain code check: does every clause the LLM claims to cite actually appear in what was retrieved? If not, the answer never reaches "approved."

The full graph

from typing import TypedDict
from langgraph.graph import StateGraph, START, END
from langgraph.types import interrupt, Command
from langgraph.checkpoint.memory import InMemorySaver
from langchain_huggingface import HuggingFaceEmbeddings
from langchain_chroma import Chroma
from langchain_openai import ChatOpenAI

embeddings = HuggingFaceEmbeddings(
    model_name="sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
)
vector_store = Chroma(
    collection_name="samsung_life_demo",
    embedding_function=embeddings,
    persist_directory="./chroma_demo_db",
)
model = ChatOpenAI(model="gpt-4o-mini")

class AgentState(TypedDict):
    question: str
    retrieved: list
    draft_answer: str
    cited_sources: list
    valid: bool
    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(f"[{d.metadata['source']}] {d.page_content}" for d in state["retrieved"])
    prompt = (
        f"Answer using only this context. Cite the source tag for every claim, "
        f"in brackets like [source].\n\nContext:\n{context}\n\nQuestion: {state['question']}"
    )
    answer = model.invoke(prompt)
    return {"draft_answer": answer.content}

def validate_citations_node(state: AgentState):
    """Plain code check. Not the LLM's word for it."""
    import re
    cited = set(re.findall(r"\[([\w\-.]+)\]", state["draft_answer"]))
    retrieved_sources = {d.metadata["source"] for d in state["retrieved"]}
    hallucinated = cited - retrieved_sources
    return {"valid": len(hallucinated) == 0, "cited_sources": list(cited)}

def approval_node(state: AgentState):
    if not state["valid"]:
        # Never reaches a human as "ready to send" -- it's flagged broken, not borderline.
        return {"approved": False}
    decision = interrupt({
        "question": state["question"],
        "draft_answer": state["draft_answer"],
        "sources": state["cited_sources"],
        "message": "Approve this answer before it reaches the customer?",
    })
    return {"approved": decision.get("action") == "approve"}

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

graph = builder.compile(checkpointer=InMemorySaver())

Trace the shape: retrieve → draft → validate_citations → approval → end. Every box is a plain function. LangGraph's only contribution is the order and the pause. That is the whole course, in one script.

Run it

config = {"configurable": {"thread_id": "demo-1"}}
graph.invoke({"question": "Does my policy cover flood damage in a basement unit?"}, config)
# pauses at approval_node with the draft + sources attached

graph.invoke(Command(resume={"action": "approve"}), config)
# resumes, returns the final state

The pitch (say this on the call)

Five talking points, in order, each one earned by a lesson above:

"Here's where it lies, before it does." Show the failure table from Lesson 1. Naming the failure modes before a prospect finds them is the trust move.
"Your documents don't leave your infrastructure." True in this build: local embeddings, local Chroma file, no document text sent to a third party for indexing.
"Nothing reaches a customer without a human okaying it first." Demo the pause live. Show the draft, show the sources, click approve.
"A hallucinated citation gets caught before a human even sees it." Show validate_citations_node catching a bad cite. This is the line that answers "how do we know it won't make things up."
"You decide what counts as sensitive." Point at the conditional edge from Lesson 4, the client's compliance team defines the routing rule, not you.

Scoping without cargo-culting

Three questions decide the shape of a real engagement, don't reach for LangGraph/Chroma/embeddings before answering them:

Is the client's knowledge documents that change quarterly, or live state that changes by the minute? (Lesson 1.) Wrong answer here means RAG is the wrong tool entirely, no amount of good chunking fixes that.
Is there an exact-identifier lookup pattern (policy numbers, claim IDs, SKUs)? If yes, budget for hybrid retrieval (KB Lesson 3), pure embeddings will disappoint on day one.
Does the client's compliance posture require a human gate before customer-facing output? If yes, that is the graph's approval node and the main line item in the quote, not an afterthought.

Prove it stuck

Why does validate_citations_node run as plain code instead of trusting the LLM's own citation?

In approval_node, what happens when valid is False?

First scoping question for a new prospect, before picking any tool?

Read this next (primary source)

★ LangChain's RAG tutorial, Part 2 (the conversational/agent section) for how production teams extend this exact pattern with memory across turns.

Ask your teacher. Try: "help me price this for the insurance prospect", "what would break if two people approve the same interrupt at once?", or "walk me through connecting the approval_node payload to a real Slack message."

← Lesson 4: LangGraph and the approval gate Course complete. Cheat sheet: reference