Build agentic systems from first principles — LangChain 1.x primitives, the StateGraph, tools and RAG, persistence and human-in-the-loop, up to a multi-agent bookshop support system. Run-verified on langchain 1.3 / langgraph 1.2.
Start here with no assumptions: what an LLM can't do on its own, what an agent adds, and why LangGraph models an agent as a graph of steps you can see and change. Build a working agent in a dozen lines, then meet the LangChain/LangGraph stack it runs on.
A chat model takes a list of messages and returns one message — not text in, text out. Why roles matter, the four message types, a conversation as a growing list, invoke/stream/batch and async, token accounting, structured output, and init_chat_model.
Prompt templates, the Runnable interface every LangChain piece implements, and LCEL — the | operator that composes prompt, model, and parser into one chain that streams, batches, retries, and falls back for free. Plus where LCEL stops and LangGraph begins.
A tool is a Python function a model can decide to call. The @tool decorator and why the docstring is load-bearing, bind_tools and the tool_calls a model emits, parallel calls, the request-run-return loop that is ReAct, error handling, and ToolNode — which only runs inside a graph.
Models don't know your private or current data. Retrieval fixes it — the two phases, documents and splitting, embeddings and vector stores, scored search and metadata filtering, the retriever as a Runnable, a full grounded RAG chain, and where retrieval becomes a graph node.
The mental model that makes everything after it click: state as a typed schema (TypedDict or Pydantic), nodes as functions returning partial updates, edges as wiring, and reducers — the rule that decides whether a channel overwrites, merges, or runs your own custom merge.
Conditional edges that pick the next node from state, the cycle that turns a graph into an agent, the recursion limit that stops a runaway (and its surprising default), and Command — the return value that updates state and routes in one move. Then we rebuild create_agent from scratch.
A graph is stateless by default — each invoke starts fresh. A checkpointer plus a thread_id changes that: state is saved after every step, so a conversation remembers across calls, threads stay isolated, you can inspect, edit, and rewind history, and a crash resumes mid-graph. Plus how to keep a growing conversation from overflowing the context window.
Some actions are too consequential to let an agent take alone. interrupt() pauses a graph mid-run, surfaces a payload, and waits; Command(resume=...) continues it. Approve, edit, or reject — plus interrupt_before and the middleware that adds a gate to a prebuilt agent. All built on checkpointing.
A graph that only returns at the end feels broken for anything slow. The stream modes surface progress live — values for the accumulating state, updates for per-node deltas, messages for token-by-token model output — how to combine and filter them, and the async form a real UI needs.
Now that you can build the loop by hand, the prebuilt agent stops being magic. create_agent's real customization surface — system prompt, structured output, checkpointer, interrupts, and the middleware system with its hook points and a custom example — and the honest test for when to use it versus hand-building.
One agent is a graph; several agents is a graph of agents. Why you'd split into specialists, the three multi-agent topologies — supervisor, network, hierarchical — the Command primitive and handoff tools that transfer control, and a working bookshop triage system.
The Send API for running many workers at once and merging their results, subgraphs that compose a whole graph as a single node, and the reducer-channel gotcha where a subgraph double-counts state at the boundary — with the fix, built into a parallel on-call diagnostic system.
The supervisor and network systems you hand-built, packaged into a few lines by langgraph-supervisor and langgraph-swarm — the same Command handoffs underneath. What they generate, how to inspect and extend them, when they're worth it, and the version caveat on these fast-moving add-on packages.
Everything in the series, in one working system: a supervisor that triages customers to specialists, an orders agent that runs real SQL against the warehouse, a recommendations agent backed by retrieval, and a refund path gated behind a human — persistent, streamable, and run end to end.
A multi-agent run is opaque until you instrument it. LangSmith tracing for the whole graph, per-node cost from usage metadata, evaluation with datasets and judges, and the technique that needs no live model — testing a graph's control flow with fakes, including a scripted tool loop.
What it takes to run a graph in production: durable execution that survives a crash, node-level retries with backoff, error handlers and timeouts, and the two ways to serve a graph — behind your own web framework, or on the LangGraph server. The series finale.