COURSE · BLD · B016
LangGraph for Local Agents
Learn langgraph for local agents through RunLocalAI's practical lens: langgraph, state, multi agent and workflows, hardware fit, runtime settings, verification habits and local-vs-cloud tradeoffs.
PREREQUISITES
- B015
Course B016: LangGraph for Local Agents
Why this course exists
LangChain gives you individual tools. LangGraph lets you wire those tools into persistent, interruptible, multi-agent systems that survive restarts and stream their thinking. Most operator-made agentic pipelines today collapse into spaghetti code because there is no formal graph structure—infinite loops with no backpressure, lost context, no way to pause for human confirmation, and no way to replay a failed branch. LangGraph solves this by modeling every agentic workflow as a directed graph with typed state, checkpointed memory, and conditional routing. This course teaches that model from first principles through a delivered production-style multi-agent research team.
What you will know after
- Define StateGraph workflows with typed state schemas that survive process restarts
- Route edges conditionally based on state values, enabling dynamic agent selection
- Build multi-agent supervisor-worker teams with shared persistent memory via checkpointers
- Insert human-in-the-loop interrupt points that pause execution and resume from saved state
- Construct a full multi-agent research team that ingests queries, dispatches workers, and aggregates findings
CHAPTERS
- 01What is LangGraph?LangGraph is not a chain library—it is a graph runtime with typed state, persistent checkpointing, and conditional routing built in. Think in nodes, edges, and state transitions rather than function calls.15 min
- 02StateGraph BasicsThe `Annotated` + `operator.add` pattern is how LangGraph handles list fields without data loss. Skipping it causes silent state overwrites that are hard to debug because they produce no error.15 min
- 03Nodes and EdgesThink of edges as explicit routing rules, not as sequential fall-through. Every non-terminal node must have its outgoing path defined at compile time, or the graph refuses to build.15 min
- 04State ManagementState management in LangGraph is a reducer-based merge model. Understanding `Annotated` + custom reducers gives you full control over how updates from different nodes interact with the existing state.15 min
- 05Tool-Calling Agent in LangGraph`create_react_agent` abstracts the tool-calling loop but locks you into its state schema. Override by inheriting from `MessagesState` to add your own fields while keeping the ReAct loop intact.15 min
- 06Conditional EdgesConditional edges are the primary mechanism for implementing dynamic workflows. The routing function is a pure state-to-string mapper, not a workflow step itself—keep it focused on routing logic only.15 min
- 07Human-in-the-LoopHuman-in-the-loop in LangGraph uses interrupt points backed by a checkpointer. The graph pauses, state survives in the checkpoint store, and `Command(resume=...)` injects human decisions into the resumed execution.15 min
- 08CheckpointingCheckpointing is the foundation for both crash recovery and run branching. Thread IDs isolate runs, and any checkpoint can become the root of a new branch run.20 min
- 09Multi-Agent TeamsMulti-agent teams use a shared typed state with per-agent write keys. The supervisor pattern is a polling dispatch model—each turn, the supervisor decides who goes next and workers report back into shared state.20 min
- 10Supervisor AgentA model-based supervisor replaces hard-coded routing with LLM reasoning over the shared state. The validation fallback is critical—unexpected model outputs should gracefully terminate rather than crash the graph.15 min
- 11Specialized Worker AgentsWorkers are subgraphs, not functions. They read from team state, do domain work, and write results back to team state. Idempotency is essential—multi-agent runs fork and replay, and non-idempotent workers produce non-deterministic results.15 min
- 12Agent CommunicationAll agent communication flows through shared state. Structured fields (`findings`, `generated_code`) beat a raw message history for cross-agent data passing because they are self-documenting and easy to read without parsing conversational text.15 min
- 13SubgraphsSubgraphs are the hierarchical composition primitive. Input/output state mapping decouples internal subgraph state from the parent state, enabling teams of teams without schema proliferation.15 min
- 14Error HandlingLangGraph error handling is state-driven: catch exceptions, write error metadata to state, route to recovery via conditional edges. Bounded retries with escalation prevents infinite loops while giving transient failures a path to recover.15 min
- 15PersistenceCheckpointers are interchangeable backends. `MemorySaver` for development, `SqliteSaver` for single-machine deployment, and `PostgresSaver` for distributed production. Session artifacts that need to survive beyond the current session should be stored separately in a dedicated database.20 min
- 16Streaming Agent OutputThree streaming modes exist for three audiences: `"values"` for debugging the full state, `"updates"` for observing node-level activity, and `"messages"` for end-user token streaming.20 min
- 17LangGraph vs LangChainLangGraph is the execution layer for LangChain components. Use LangChain for component logic and LangGraph for workflow orchestration. They compose: LangChain's LCEL runs inside LangGraph's node functions.15 min
- 18Multi-Agent Research Team ProjectThis final architecture—a supervisor dispatching workers with persistent memory and human approval gates—is the production pattern for local multi-agent systems. Every component in the previous 17 chapters earns its place here.20 min