The core model: state, nodes, edges

A LangGraph application is a StateGraph made of three things.

State is the shared data structure that flows through the graph. You define it as a TypedDict, a dataclass or a Pydantic model. Pydantic adds runtime validation. Every node reads the state and returns updates to it.

Nodes are plain Python functions. A node might call a chat model, run a tool or transform data. It returns a partial state update and doesn't need to know about the rest of the graph.

Edges connect nodes. Normal edges always go from A to B. Conditional edges run a function that picks the next node based on the state. You wire up START and END, call compile(), and run it with invoke().

The detail that's easy to miss is reducers. By default, a node's update overwrites a key. With Annotated[list, operator.add] updates are appended instead. The built-in add_messages reducer appends messages or updates them by id, and supports RemoveMessage. Reducers become essential when nodes run in parallel and write to the same key.

From chain to agent in a few steps

The course builds up in steps that make the design choices visible:

1. Chain: state is a list of messages (MessagesState), with a chat model that has tools bound via bind_tools.
2. Router: the model either answers directly or emits a tool call. A ToolNode plus the prebuilt tools_condition edge handles the routing.
3. Agent (ReAct): add an edge from the tool node back to the model, so it loops until there are no more tool calls.

So an "agent" is a router with a loop, and nothing more mysterious than that. Once you see it this way, you can decide exactly where the loop is allowed and where it isn't.

Memory: short-term and long-term

LangGraph separates two kinds of memory.

Short-term (thread) memory comes from a checkpointer. Compile the graph with MemorySaver (or SqliteSaver for persistence), pass a thread_id in the config, and the state is saved after every step. The next invocation on the same thread continues where the last one stopped. Conversations grow, so the course shows how to keep the context bounded: remove messages, pass only the last N, use trim_messages by token count, or keep a running summary.

Long-term memory works across threads through a Store, such as InMemoryStore, keyed by a namespace tuple plus a key. You decide on a memory schema. It can be a profile, which is one JSON document per user, or a collection, a growing list of items. The final example in the module is an assistant that decides for itself when to update the user's profile, a to-do collection or its own instructions.

When to use what: a checkpointer is almost always worth adding, because it also enables human-in-the-loop and debugging. Long-term memory only makes sense when you actually need personalisation across sessions. It is also a data-protection question, so design what you store deliberately.

Human-in-the-loop

This is where LangGraph clearly beats an opaque loop. Because state is checkpointed, you can pause a graph, inspect it, change it and resume:

• Breakpoints: interrupt_before=["tools"] stops before a node, for example before a tool runs. Resuming with invoke(None, config) continues from the checkpoint.
• Editing state: graph.update_state(config, values, as_node=...) lets a human correct the state, for example to fix a tool argument, before continuing.
• Dynamic breakpoints: a node can raise an interrupt conditionally, for example only when an amount exceeds a threshold.
• Time travel: get_state_history lets you replay from an earlier checkpoint, or fork by updating an old one and running from there.

When to use it: any action with real consequences, such as sending a message, changing a record or spending money, should go through an explicit approval point. In legal or educational contexts, I'd consider this the default rather than an optional extra.

Scaling the graph: parallelism, sub-graphs, map-reduce

Module 4 builds a research assistant. It generates analyst personas (with human feedback on the personas), runs parallel interviews using web and Wikipedia search, writes sections, and combines them into a report. The patterns along the way:

• Fan-out/fan-in parallelism, which needs reducers on shared keys.
• Sub-graphs with their own state, which talk to the parent through overlapping keys.
• Map-reduce with the Send API, which spawns a dynamic number of parallel nodes and then aggregates the results.

When to use them: only when the task really splits into independent pieces. Every extra branch adds coordination and evaluation work. Start with a single agent and tools, and add structure when a trace shows you need it.

Deployment and streaming

The course also covers the operational side. You can stream either state updates or full values, and stream tokens with astream_events. LangGraph Studio is useful for visual debugging. For deployment, a langgraph.json plus a Docker image runs on LangGraph Server, which handles the API, a task queue and Postgres persistence. There are clients through the SDK or RemoteGraph. Two ideas I hadn't considered before: double-texting strategies (reject, enqueue, interrupt or rollback when a user sends a new message mid-run) and assistants, which are versioned configurations of the same graph.

When LangGraph is the right tool

• Use it when you need control over the flow, durable state, approvals or resumable runs. That usually means multi-step agents that act on real systems.
• Skip it for a single prompt-and-answer or a fixed linear pipeline, where plain code is simpler.
• Keep it simple first. A predefined workflow is easier to test than a free agent, and a single agent is easier than several. The graph makes that trade-off explicit, which is exactly why I like it.

Getting started

The course is free. The code is in the public langchain-academy repository as Jupyter notebooks, one folder per module, with a studio folder you can run with langgraph dev. You'll need Python 3.11+ and an API key for a chat model. Tracing through LangSmith is optional but very helpful. Work through the modules in order: each one adds a single concept on top of the last.

Links: Introduction to LangGraph – LangChain Academy · LangGraph documentation · Course notebooks on GitHub