LangGraph (Python)

Low-level orchestration for stateful, long-running LLM agents. LangGraph models your agent as a graph of nodes and edges with explicit state, durable checkpoints, and first-class human-in-the-loop.

Install

pip install langgraph langchain-anthropic

Version

v1.2.6 · June 2026 · Python 3.10 – 3.14

Best for

Cycles, conditional routing, multi-agent coordination, HITL workflows.

Where to start

New to LangGraph? Follow the Zero → Hero path below in order (~3–4 hours). Already building? Use Jump to a topic to land on the chapter you need.

Zero → Hero

A chaptered tutorial that takes you from a first graph to a production-ready agent. Each chapter has its own page with Next → pagination.

1 · Setup & core concepts Install, state, nodes, edges, compilation · 15 min

2 · Your first agent Linear chat, conditional routing, looping, streaming · 20 min

3 · Multi-agent systems Supervisor, parallel workers, handoff · 25 min

4 · Tools ToolNode, custom executors, conditional tool use · 20 min

5 · Memory & persistence Checkpointers, Store, cross-thread memory · 25 min

6 · Streaming & debugging All 7 stream modes, typed StreamPart v2, GraphOutput, token streaming, custom events · 30 min

7 · Human-in-the-loop Interrupts, multi-stage approval, interactive debug · 25 min

8 · Middleware langchain.agents.middleware — PII, summarization, retries, HITL, cost limits · 20 min

9 · Advanced patterns ReAct, Tree-of-Thoughts, reflection, structured output, caching, Functional API · 25 min

10 · Production & troubleshooting RetryPolicy, TimeoutPolicy, CachePolicy, Durability, IsLastStep, Topic channels, Docker, CLI · 30 min

Looking for a reference?

The Zero → Hero chapters are task-oriented tutorials. If you already know the shape of LangGraph and want exact signatures, feature tables, and breaking-change history for a single primitive, jump to the Reference section near the bottom of this page — one page per API (StateGraph, Checkpointers, Store, Functional API, Command/Send, streaming modes). Each is verified line-by-line against the installed langgraph==1.2.6 source.

Jump to a topic

Need one specific concept? Land directly on the chapter that owns it.

State graph

Conditional routing

Supervisor pattern

Parallel workers

ToolNode

Checkpointers

Store (long-term memory)

Type-safe v2 API

Interrupts (HITL)

Middleware (create_agent)

ReAct pattern

Functional API

Command / Send

IsLastStep / RemainingSteps

Runtime / ToolRuntime injection

Stream modes (v1 / v2)

StateGraph API

Checkpointers matrix

Store (long-term memory)

Prebuilt Nodes

Channels

RemoteGraph

v3 streaming (stream_events)

GraphRunStream / AsyncGraphRunStream

ChatModelStream (per-LLM streaming)

SubgraphRunStream (subgraph navigation)

Class deep-dives Vol. 1

Class deep-dives Vol. 2

Class deep-dives Vol. 3

Class deep-dives Vol. 4

Class deep-dives Vol. 5

Class deep-dives Vol. 6

Class deep-dives Vol. 7

Class deep-dives Vol. 8

Class deep-dives Vol. 9

Class deep-dives Vol. 10

Class deep-dives Vol. 11

Class deep-dives Vol. 12

Class deep-dives Vol. 13

Class deep-dives Vol. 14

Class deep-dives Vol. 15

Class deep-dives Vol. 16

Class deep-dives Vol. 17

Reference

Every page below is introspected against the installed langgraph==1.2.5 / langgraph-checkpoint==4.1.1 / langgraph-checkpoint-sqlite==3.0.3 / langgraph-checkpoint-postgres==3.0.5 source. If a signature disagrees with an older blog post or docs page, the source wins.

StateGraph API reference Constructor, add_node (all 4 overloads), add_edge, add_conditional_edges, add_sequence, compile, Runtime, RetryPolicy, CachePolicy, TimeoutPolicy, RunControl, ExecutionInfo.

Checkpointers reference Feature matrix for InMemorySaver, Sqlite, AsyncSqlite, Postgres, AsyncPostgres, ShallowPostgres — plus durability modes and connection strings.

Store (long-term memory) reference BaseStore, InMemoryStore, namespaces, IndexConfig (vector search), TTLConfig, InjectedStore for tools.

Functional API reference @entrypoint, @task, entrypoint.final, previous, injecting Runtime, feature matrix vs StateGraph.

Command / Send reference Command(update, goto, resume, graph), Send for fan-out, interrupt + resume, Command.PARENT, Overwrite.

Streaming modes reference All eight stream_mode values (including tools + ToolCallTransformer), v1 vs v2 typing, StreamPart discriminated union, GraphOutput, subgraphs=True.

Prebuilt nodes reference ToolNode (all constructor params, wrap_tool_call, handle_tool_errors), InjectedState, InjectedStore, ToolRuntime, ToolCallRequest, tools_condition, ToolCallTransformer, ToolCallStream.

Channels reference LastValue, BinaryOperatorAggregate, Topic, EphemeralValue, NamedBarrierValue, AnyValue — concurrent-write semantics, Annotated[] shorthands, fan-in patterns.

Managed values reference IsLastStep and RemainingSteps — read-only state fields injected by the Pregel executor for recursion-limit detection and graceful truncation.

Runtime, ToolRuntime & Managed Values reference Runtime context injection, ToolRuntime for tools, ExecutionInfo, IsLastStep, RemainingSteps — accessing execution metadata and injecting immutable context into nodes and tools.

RemoteGraph reference Call a LangGraph Platform deployment as a local graph — same invoke/stream/get_state surface, interrupt/resume, and subgraph node wiring.

Class deep-dives Vol. 1 Source-verified deep dives into 10 core types — StateGraph, CompiledStateGraph, InMemorySaver, ToolNode, create_react_agent, Command, Send, @task/@entrypoint, BinaryOperatorAggregate/Topic, InMemoryStore — each with multiple runnable examples.

Class deep-dives Vol. 2 Source-verified deep dives into 10 more types — RetryPolicy, CachePolicy/InMemoryCache, TimeoutPolicy, add_messages/MessagesState, tools_condition, ToolCallTransformer/ToolCallStream, StateSnapshot, IsLastStep/RemainingSteps, ToolRuntime, Runtime/RunControl — verified against langgraph==1.2.2.

Class deep-dives Vol. 3 Source-verified deep dives into 10 more types — interrupt/Interrupt, DeltaChannel, EphemeralValue, NamedBarrierValue, RemoveMessage/push_message, Pregel, NodeBuilder, GraphOutput, PregelTask, IndexConfig/TTLConfig — verified against langgraph==1.2.2.

Class deep-dives Vol. 4 Source-verified deep dives into 10 more types — set_node_defaults, add_sequence, input_schema/output_schema, context_schema/Runtime.context, get_stream_writer/StreamWriter, push_ui_message, entrypoint.final, REMOVE_ALL_MESSAGES, error_handler on add_node, error taxonomy — verified against langgraph==1.2.2.

Class deep-dives Vol. 5 Source-verified deep dives into 10 more types — RedisCache, EncryptedSerializer, JsonPlusSerializer, UntrackedValue, AnyValue, EmbeddingsLambda/ensure_embeddings, BaseCheckpointSaver, typed StreamParts, task.clear_cache, HumanInterrupt protocol — verified against langgraph==1.2.2.

Class deep-dives Vol. 6 Source-verified deep dives into 10 more types — GraphRunStream/AsyncGraphRunStream, StreamTransformer, StreamChannel, ValuesTransformer/CustomTransformer/UpdatesTransformer, GraphCallbackHandler, GraphInterruptEvent/GraphResumeEvent, GraphDrained, NodeTimeoutError, delete_ui_message/ui_message_reducer, ProtocolEvent — verified against langgraph==1.2.2.

Class deep-dives Vol. 7 Source-verified deep dives into 10 more types — PregelProtocol/StreamProtocol, BackgroundExecutor/AsyncBackgroundExecutor, AsyncBatchedBaseStore/_dedupe_ops, get_text_at_path/tokenize_path, SerdeEvent/register_serde_event_listener, BaseChannel, call()/SyncAsyncFuture, PregelScratchpad, StateNodeSpec/node Protocols, identifier/get_runnable_for_task — verified against langgraph==1.2.2.

Class deep-dives Vol. 8 Source-verified deep dives into 10 more types — ExecutionInfo/Runtime.heartbeat, ServerInfo/BaseUser, ReplayState, StreamMux, Call (functional API internals), ChannelWrite/ChannelWriteEntry, PregelRunner/FuturesDict, WritesProtocol/PregelTaskWrites, SyncPregelLoop/AsyncPregelLoop, and DuplexStream — verified against langgraph==1.2.4.

Class deep-dives Vol. 9 Source-verified deep dives into 10 classes new or expanded in 1.2.4 — ToolCallRequest.override(), Send+timeout, create_react_agent hooks (pre_model_hook/post_model_hook/version=v2/response_format), RetryPolicy chaining, CachePolicy custom key_func, InMemoryStore raw embedding callables, context_schema+Runtime.context, Command.PARENT cross-subgraph routing, TimeoutPolicy.coerce(), and @entrypoint multi-policy retry — verified against langgraph==1.2.4.

Class deep-dives Vol. 10 Source-verified deep dives into Durability checkpoint modes, NodeError/NodeCancelledError, TaskPayload/TaskResultPayload, CheckpointPayload/CheckpointTask, Item/SearchItem, GetOp/PutOp/SearchOp/ListNamespacesOp/MatchCondition, UIMessage/RemoveUIMessage, GraphOutput v2, StreamPart variants, and PregelExecutableTask/CacheKey — verified against langgraph==1.2.4.

Class deep-dives Vol. 11 Source-verified deep dives into InjectedState, InjectedStore, MessagesState, Overwrite, ToolOutputMixin, CheckpointMetadata, CheckpointTuple, StateUpdate, PersistentDict, and DeltaChannelHistory — verified against langgraph==1.2.4.

Class deep-dives Vol. 12 Source-verified deep dives into RemoteGraph/RemoteException, PostgresSaver/ShallowPostgresSaver, AsyncPostgresSaver, PostgresStore/PoolConfig, AsyncPostgresStore, ANNIndexConfig/HNSWConfig/IVFFlatConfig/PostgresIndexConfig, GraphRunStream/SubgraphRunStream, ToolCallWithContext/ToolInvocationError, LifecyclePayload/LifecycleTransformer, MessagesTransformer/CheckpointsTransformer/TasksTransformer — verified against langgraph==1.2.4.

Class deep-dives Vol. 13 Source-verified deep dives into ToolRuntime, ToolNode wrap_tool_call/awrap_tool_call, create_react_agent v2, TimeoutPolicy, CachePolicy, BinaryOperatorAggregate, Topic, EphemeralValue, NamedBarrierValue, and AnyValue — verified against langgraph==1.2.4.

Class deep-dives Vol. 14 Source-verified deep dives into BranchSpec, LastValue/LastValueAfterFinish, ManagedValue (custom managed values), @task decorator/_TaskFunction, DeltaChannel, node input schema narrowing, _NodeDefaults/set_node_defaults(), InMemoryCache/BaseCache, @entrypoint full parameter guide, and CompiledStateGraph internals — verified against langgraph==1.2.4.

Class deep-dives Vol. 15 Source-verified deep dives into Runtime/ExecutionInfo/RunControl/ServerInfo, BaseStore/Item/SearchItem, store batch ops (GetOp/SearchOp/PutOp/ListNamespacesOp/MatchCondition), IndexConfig/TTLConfig, UIMessage/push_ui_message/delete_ui_message, StreamTransformer/ProtocolEvent, RemoteGraph, error hierarchy (NodeError/NodeTimeoutError/NodeCancelledError/GraphDrained), IsLastStep/RemainingSteps, and HumanResponse — verified against langgraph==1.2.5.

Class deep-dives Vol. 16 Source-verified deep dives into the v3 streaming protocol (beta, langgraph==1.2.5): GraphRunStream, AsyncGraphRunStream, SubgraphRunStream/AsyncSubgraphRunStream, ValuesTransformer, UpdatesTransformer, CustomTransformer, MessagesTransformer/ChatModelStream, SubgraphTransformer, LifecycleTransformer/LifecyclePayload, and StreamChannel.

Class deep-dives Vol. 17 Source-verified deep dives into 10 practical patterns (langgraph==1.2.5): RetryPolicy sequence chaining, TimeoutPolicy+Runtime.heartbeat(), Overwrite (bypass reducers), interrupt() multi-value + selective resume by ID, add_sequence() linear pipelines, update_state()/bulk_update_state()+StateUpdate, get_stream_writer()/StreamWriter, stream_mode='checkpoints'+CheckpointPayload/CheckpointTask, stream_mode='tasks'+TaskPayload/TaskResultPayload, and set_node_defaults() graph-wide policies.

Class deep-dives Vol. 18 Source-verified deep dives into 10 classes with richer examples (langgraph==1.2.5): DebugTransformer+stream_mode='debug' (first full coverage), StateSnapshot history navigation, Command full API (update+goto+Send+PARENT combinations), add_messages advanced patterns (ID dedup/RemoveMessage/REMOVE_ALL_MESSAGES/format), Topic channel accumulate modes, NamedBarrierValue fan-in synchronization, entrypoint+task+previous stateful accumulation, push_message manual emission, EphemeralValue trigger channels+guard modes, and CachePolicy+InMemoryCache combined patterns with custom key_func and cache invalidation.

Class deep-dives Vol. 19 Source-verified deep dives into streaming internals, error taxonomy, HITL protocol & execution model (langgraph==1.2.5): CheckpointsTransformer+TasksTransformer (v3 native stream projections), StreamMessagesHandler+StreamMessagesHandlerV2 (stream_mode='messages' callback internals), _TimedAttemptScope+_AttemptContext+_AttemptEvent (timeout/retry lifecycle observer protocol), ChannelRead imperative state access, ErrorCode enum+extended exception hierarchy (EmptyInputError/TaskNotFound/GraphBubbleUp/ParentCommand), ValidationNode schema validation with migration guide, MessageGraph legacy API migration, BackgroundExecutor+AsyncBackgroundExecutor+Submit protocol, HumanInterrupt full protocol (ActionRequest/HumanInterruptConfig/HumanResponse from langchain.agents.interrupt), and PregelNode+StateNodeSpec node representation internals.

Class deep-dives Vol. 20 Source-verified deep dives into execution engine internals (langgraph==1.2.6): StreamToolCallHandler+ToolCallWriter (stream_mode='tools' lifecycle events and ContextVar writer), ReplayState (time-travel subgraph coordination + _is_first_visit namespace stripping), PregelScratchpad (step/stop counters, LazyAtomicCounter fields, interrupt resume list), LangGraphDeprecationWarning hierarchy (since/expected_removal versioned warnings), create_checkpoint+delta_channels_to_snapshot+empty_checkpoint (checkpoint v4 construction + DeltaChannel snapshot cadence), chain_future+run_coroutine_threadsafe (cross-loop coroutine bridge + lazy/eager task factory), validate_graph+validate_keys (reserved name checks, subscription validation, interrupt node checks), read_channel+read_channels+map_input+map_command (I/O layer mapping inputs and Commands to pending writes), should_interrupt+apply_writes+prepare_next_tasks (core Pregel algorithm: interrupt decision, deterministic write ordering, node scheduling), and LazyAtomicCounter+task_path_str+_uuid5_str/_xxhash_str (task identity utilities).

Class deep-dives Vol. 21 Source-verified deep dives with expanded coverage and 3 runnable examples each (langgraph==1.2.6): BaseChannel lifecycle contract (full ABC interface + custom channel creation pattern), BinaryOperatorAggregate (Annotated reducer internals, Overwrite sentinel dual detection, _operators_equal lambda guard), UntrackedValue (guard=True/False write semantics, checkpoint()→MISSING never persisted, in-memory scratchpad pattern), register_serde_event_listener+SerdeEvent (first dedicated coverage — thread-safe serde observability hooks for audit logging and allowlist building), SerializerProtocol+CipherProtocol+SerializerCompat (custom serializer contracts, maybe_add_typed_methods backwards-compat bridge, bring-your-own cipher pattern), AsyncBatchedBaseStore (background asyncio.Queue coalescing, _check_loop deadlock prevention, weakref drainer lifetime), UIMessage+RemoveUIMessage+ui_message_reducer (full UI streaming — merge=True prop delta, remove-ui ValueError on unknown IDs, state_key=None stream-only pattern), ManagedValue+IsLastStepManager+RemainingStepsManager (custom managed value creation, PregelScratchpad.step/.stop linkage, is_managed_value TypeGuard), get_field_default+get_cached_annotated_keys+get_enhanced_type_hints (TypedDict/Pydantic/dataclass default resolution, Required/NotRequired precedence, WeakKeyDictionary MRO cache, get_update_as_tuples Pydantic model_fields_set filtering), and PregelProtocol+StreamProtocol (graph executor interface — full abstract method inventory, v1/v2 stream overloads, StreamChunk tuple anatomy, StreamProtocol __slots__ design).

Class deep-dives Vol. 22 Source-verified deep dives into v3 streaming internals, custom transformers, encryption & embedding helpers (langgraph==1.2.6): StreamTransformer base contract (custom projection authoring, before_builtins, schedule()), StreamChannel (drainable queue, tee/atee fan-out, lazy-subscribe), StreamMux (central event dispatcher, factory/child pattern), GraphRunStream+AsyncGraphRunStream (v3 caller-driven streaming, interleave(), abort()), SubgraphRunStream+AsyncSubgraphRunStream (subgraph handles, parent-pump delegation), ValuesTransformer+CustomTransformer+UpdatesTransformer (native v3 projections), NamedBarrierValueAfterFinish (finish-gated fan-in), EncryptedSerializer (AES-EAX checkpoint encryption), EmbeddingsLambda+ensure_embeddings (store embedding wrappers), and push_ui_message+delete_ui_message (runtime UI streaming API).

Class deep-dives Vol. 23 Source-verified deep dives into node wrappers, concurrency primitives, remote streaming & migration guide (langgraph==1.2.6): RunnableCallable+RunnableSeq (node function wrappers — sync/async dual dispatch, func_accepts injection, trace/recurse/explode_args flags), _IdleProgressCallbackHandler (idle-timeout heartbeat via every LangChain callback event — how touch() resets the idle clock, run_inline semantics), _GraphCallbackManager+_AsyncGraphCallbackManager (graph lifecycle event dispatch — configure() from config callbacks, on_interrupt/on_resume fan-out to GraphCallbackHandler subclasses), DataclassLike+TypedDictLikeV1+TypedDictLikeV2 (state schema typing protocols — runtime discrimination of TypedDict/dataclass/Pydantic), AsyncQueue+SyncQueue+Semaphore (internal concurrency primitives — wait()-without-consuming non-destructive peek, Pregel coordinator-worker signaling), FunctionNonLocals+NonLocals (AST-based closure inspection — loads-stores captures, @task/@entrypoint outer-scope analysis), Edge+TriggerEdge (graph topology NamedTuples powering draw_mermaid/draw_ascii — custom renderers and topology diffs), _RemoteGraphRunStream+_ChannelProjection+_ProjectionRegistry (remote graph streaming adapter — sync/async lanes, extensions channel projection registry), AgentState+AgentStatePydantic deprecation migration guide (moved to langchain.agents — custom TypedDict migration with add_messages+RemainingSteps+response_format), and _SubgraphRunStreamMixin (subgraph streaming internals — path/graph_name/trigger_call_id metadata, status updated by SubgraphTransformer, parent-pump delegation).

Single-page comprehensive guide All chapters in one long page — best for search and printing.

Recipes RAG, support routing, research agent, doc pipelines, long-term memory conversations.

Diagrams 20+ Mermaid architecture diagrams.

Production guide Deployment, scaling, monitoring, disaster recovery.

Advanced error recovery

Observability

Performance optimization

Streaming server (FastAPI)

What’s new in v1.2.x (June 2026)

• v1.2.6 (June 2026) — Patch release; no new public API surface. Actual 1.2.6 changes include nested subgraph checkpoint namespace fixes and v3 stream abort handling. Class deep-dives Vol. 23 adds first-ever coverage of RunnableCallable+RunnableSeq (node function wrappers), _IdleProgressCallbackHandler (idle-timeout heartbeat mechanics), _GraphCallbackManager+_AsyncGraphCallbackManager (lifecycle event dispatch), DataclassLike+TypedDictLike* (schema protocols), AsyncQueue+SyncQueue+Semaphore (concurrency primitives), FunctionNonLocals+NonLocals (AST closure analysis), Edge+TriggerEdge (graph draw primitives), _RemoteGraphRunStream+_ChannelProjection (remote streaming internals), AgentState migration guide (deprecated in 1.2.6), and _SubgraphRunStreamMixin (subgraph pump delegation). Class deep-dives Vol. 22 covers v3 streaming internals (StreamTransformer, StreamChannel, StreamMux, GraphRunStream/SubgraphRunStream, EncryptedSerializer, EmbeddingsLambda). Class deep-dives Vol. 21 adds expanded coverage (3 runnable examples each) for BaseChannel (custom channel ABC), BinaryOperatorAggregate (Overwrite sentinel mechanics), UntrackedValue (guard semantics + checkpoint=MISSING), register_serde_event_listener+SerdeEvent (first dedicated coverage), SerializerProtocol+CipherProtocol+SerializerCompat, AsyncBatchedBaseStore (_check_loop deadlock prevention), UIMessage+RemoveUIMessage+ui_message_reducer (merge semantics), ManagedValue custom values, get_field_default+get_cached_annotated_keys (_fields internals), and PregelProtocol+StreamProtocol. Class deep-dives Vol. 20 adds source-verified documentation of existing execution engine internals (StreamToolCallHandler, DeltaChannel, PregelScratchpad, LazyAtomicCounter, and more) verified against this release.
• v1.2.5 (June 2026) — Patch release; langgraph==1.2.5 with stability and dependency updates. No new public API surface. All core graph symbols verified with -W error::DeprecationWarning.
• TimeoutPolicy dataclass (langgraph.types) — fine-grained per-node/per-task timeout control with run_timeout (hard cap), idle_timeout (progress-based cap), and refresh_on ("auto" or "heartbeat"). Replaces the single timeout=float kwarg with a richer API.
• Runtime.heartbeat() — call from inside a long-running async node or task to reset an idle timeout. No-op outside an active idle-timed attempt.
• RunControl + cooperative draining — runtime.control, runtime.drain_requested, runtime.drain_reason let external code signal a graph run to exit gracefully without cancelling it abruptly.
• ExecutionInfo extended — new fields checkpoint_ns (subgraph namespace) and task_id (Pregel task ID) for richer per-node observability. patch(**overrides) helper for testing.
• RemainingSteps managed value (langgraph.managed.is_last_step) — companion to IsLastStep; gives the integer count of steps remaining before the recursion limit.
• task.clear_cache() / task.aclear_cache() — invalidate cached results for a specific @task without flushing the whole BaseCache.
• ToolRuntime dataclass (new in v1.2.0, langgraph.prebuilt) — passed to tools at execution time; exposes state, context, config, stream_writer, tool_call_id, store, tools, and execution_info. Allows tools to inspect the current graph state and write to the stream mid-execution.
• ToolCallTransformer stream transformer (new in v1.2.0, langgraph.prebuilt) — a StreamTransformer that projects raw tools-channel protocol events (tool-started, tool-output-delta, tool-finished, tool-error) into per-call ToolCallStream handles. Register via builder.compile(transformers=[ToolCallTransformer]); iterate run.tool_calls while streaming with stream_mode="tools" to receive one ToolCallStream per invocation. See the Streaming modes reference and Prebuilt nodes reference for full examples.
• langgraph-checkpoint 4.1.0 — minor checkpoint interface improvements; backward-compatible with all existing MemorySaver, SqliteSaver, PostgresSaver usage.
• langgraph-prebuilt 1.1.0 — ships ToolRuntime and ToolCallTransformer; all prior prebuilt symbols (create_react_agent, ToolNode, ValidationNode, InjectedState, InjectedStore) unchanged.
• v1.2.1 (May 2026) — Patch release; stability and dependency updates. All core graph symbols (StateGraph, END, START, CompiledStateGraph, MemorySaver, create_react_agent, ToolNode, InMemoryStore, Command, Send, Interrupt, interrupt, entrypoint, task) verified with -W error::DeprecationWarning against installed langgraph==1.2.2 (.routine-envs/check-0522-langgraph); all PASS.
• v1.2.0 (May 12) — All core graph symbols (StateGraph, END, START, CompiledStateGraph, MemorySaver, create_react_agent, ToolNode, InMemoryStore, Command, Send, Interrupt, interrupt, entrypoint, task) verified with -W error::DeprecationWarning against installed langgraph==1.2.0 (.routine-envs/check-0512-py).
• Prior (v1.1.x): Type-safe streaming v2 API (version="v2" on astream()/ainvoke()); Pydantic/dataclass coercion; Python 3.10 – 3.14 support; time-travel fixes.

Verified against installed library

Introspected against langgraph==1.2.5, langgraph-checkpoint==4.1.1, langgraph-prebuilt==1.1.0, langgraph-checkpoint-sqlite==3.0.3, langgraph-checkpoint-postgres==3.0.5 in June 2026.

Known corrections vs older drafts / third-party guides:

• langgraph.llm_hooks and langgraph.cache.cache_node do not exist. The middleware system is langchain.agents.create_agent(middleware=[...]); see Chapter 8.
• create_react_agent in langgraph.prebuilt is deprecated in v1.0 in favor of langchain.agents.create_agent. It still runs, with a warning.
• AgentState / AgentStatePydantic moved from langgraph.prebuilt to langchain.agents.
• SqliteSaver.from_conn_string(...) and PostgresSaver.from_conn_string(...) are context managers (with ... as saver:), not factories that return a saver directly. Some earlier examples omitted the with; see the Checkpointers reference.
• Interrupt.ns, Interrupt.when, Interrupt.resumable were removed in v0.6; only Interrupt.value and Interrupt.id remain.
• checkpoint_during=False on invoke/stream is deprecated — use durability="exit" (or "sync" / "async").
• ShallowPostgresSaver is deprecated as of langgraph-checkpoint-postgres 2.0.20. Use PostgresSaver + durability="exit".

Install, minimal example

from langgraph.graph import StateGraph, START, END
from langgraph.checkpoint.memory import InMemorySaver
from typing_extensions import TypedDict

class State(TypedDict):
    message: str
    response: str

def process(state: State) -> dict:
    return {"response": f"Processed: {state['message']}"}

builder = StateGraph(State)
builder.add_node("process", process)
builder.add_edge(START, "process")
builder.add_edge("process", END)

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

result = graph.invoke(
    {"message": "Hello"},
    config={"configurable": {"thread_id": "user-1"}},
)
print(result)

Ready for the full walk-through? Start Chapter 1 →

---

Revision history

Date	Version	Changes
2026-06-23	1.2.6	Added Class deep-dives Vol. 23 — 10 source-verified deep dives into previously undocumented class groups: RunnableCallable+RunnableSeq first dedicated coverage (node function wrapper — func_accepts injection detection, sync/async dual dispatch, trace/recurse/explode_args flags, RunnableSeq lightweight pipeline chaining), _IdleProgressCallbackHandler first dedicated coverage (idle-timeout heartbeat mechanics — every on_llm_new_token/on_tool_start/on_chain_start etc. calls scope.touch(), run_inline=True ordering guarantee, weakref scope-lifetime decoupling), _GraphCallbackManager+_AsyncGraphCallbackManager first dedicated coverage (graph lifecycle event dispatch — configure() from config[“callbacks”], on_interrupt/on_resume fan-out to GraphCallbackHandler subclasses only, async twin with is_async=True), DataclassLike+TypedDictLikeV1+TypedDictLikeV2 first dedicated coverage (structural protocols for state schema discrimination — dataclass_fields vs required_keys/optional_keys ClassVar vs instance, how LangGraph detects schema type at runtime), AsyncQueue+SyncQueue+Semaphore first dedicated coverage (internal concurrency primitives — wait()-without-consuming non-destructive peek, SyncQueue built on deque+Semaphore, Pregel coordinator-worker signaling pattern), FunctionNonLocals+NonLocals first dedicated coverage (AST-based closure inspection — loads-stores outer-scope captures, visit_FunctionDef/AsyncFunctionDef/Lambda dispatch, practical @task factory capture analysis), Edge+TriggerEdge first dedicated coverage (graph topology NamedTuples from get_graph().edges — source/target/conditional/data fields, custom Mermaid rendering, topology diff for CI regression detection), _RemoteGraphRunStream+_ChannelProjection+_ProjectionRegistry first dedicated coverage (remote graph streaming adapter — context-manager lifecycle, _ChannelProjection sync/async lane DataDecoder, _ProjectionRegistry typed vs custom channel resolution), AgentState+AgentStatePydantic deprecation migration guide (deprecated in 1.2.6 — moved to langchain.agents, custom TypedDict migration with add_messages+RemainingSteps+response_format structured output, Pydantic model migration pattern), and _SubgraphRunStreamMixin first dedicated coverage (subgraph streaming pump-delegation internals — path/graph_name/trigger_call_id identity fields, status updated in-place by SubgraphTransformer, parent-pump delegation pattern, drilling into projections). Also added Vol. 22 LinkCard to the Jump-to-topic grid.
2026-06-20	1.2.6	Added Class deep-dives Vol. 21 — 10 source-verified deep dives with 3 runnable examples each, expanding coverage of previously brief topics: BaseChannel full lifecycle contract (update/get/checkpoint/from_checkpoint/consume/is_available ABC + custom channel implementation pattern), BinaryOperatorAggregate internals (Annotated reducer mechanics, Overwrite dual-detection via isinstance+OVERWRITE dict sentinel, _operators_equal lambda safety, _strip_extras ABC→concrete normalisation), UntrackedValue deeper dive (guard=True concurrent-write protection, checkpoint()→MISSING never persists a blob, from_checkpoint always returns empty, in-memory scratchpad use cases), register_serde_event_listener+SerdeEvent first dedicated coverage (thread-safe listener list with _listeners_lock, per-listener failure isolation, _MAX_WARNED_TYPES=1000 circuit breaker, use for audit logging and allowlist building), SerializerProtocol+CipherProtocol+SerializerCompat first dedicated coverage (runtime_checkable protocol, dumps_typed tuple type discriminator, SerializerCompat wraps old-style serde with type(obj).name tag, maybe_add_typed_methods backwards compat, custom BYO cipher pattern), AsyncBatchedBaseStore deeper dive (_check_loop decorator raises asyncio.InvalidStateError from same loop, weakref drainer prevents store lifetime coupling, _ensure_task recreates cancelled background task), UIMessage+RemoveUIMessage+ui_message_reducer full reducer semantics (merge=True dict-merge vs replace, remove-ui ValueError on unknown IDs, state_key=None stream-only emission, metadata.merge flag), ManagedValue+IsLastStepManager+RemainingStepsManager deeper dive (get(scratchpad) staticmethod contract, PregelScratchpad.step/.stop arithmetic, custom managed value pattern, is_managed_value TypeGuard), get_field_default+get_cached_annotated_keys+get_enhanced_type_hints first dedicated coverage (Required/NotRequired precedence over total=False, WeakKeyDictionary MRO cache with reversed MRO traversal, Python 3.14 GetSetDescriptorType fallback, get_update_as_tuples model_fields_set filtering), and PregelProtocol+StreamProtocol first dedicated coverage (full abstract method inventory with v1/v2 stream overloads, StreamChunk=(namespace, mode, payload) tuple anatomy, StreamProtocol slots design and modes filtering).
2026-06-18	1.2.5	Added Class deep-dives Vol. 19 — 10 source-verified deep dives into streaming internals, error taxonomy, HITL protocol & execution model: CheckpointsTransformer+TasksTransformer (v3 native stream projections — run.checkpoints and run.tasks attributes, scope filtering, combined audit pattern), StreamMessagesHandler+StreamMessagesHandlerV2 (stream_mode=“messages” callback internals — run_inline=True ordering guarantee, dedup by message ID, TAG_NOSTREAM suppression, parent_ns subgraph forwarding), _TimedAttemptScope+_AttemptContext+_AttemptEvent (timeout/retry lifecycle observer protocol — immutable per-attempt context NamedTuple, lifecycle events start/progress/finish, progress observation via refresh_on=“auto” vs “heartbeat”, guarded write/stream/call lock after timeout), ChannelRead imperative state access (do_read() static method, str vs list channel selection, fresh=True cache bypass, mapper transform), ErrorCode enum+extended exception hierarchy (all 5 ErrorCode values, EmptyInputError, TaskNotFound, GraphBubbleUp/ParentCommand internal signals, NodeInterrupt deprecated alias), ValidationNode schema validation (pydantic/BaseTool/callable schemas, custom format_error, re-prompting loop pattern, migration to ToolNode with handle_tool_errors), MessageGraph legacy API migration (deprecated MessageGraph, StateGraph+add_messages equivalent, MessagesState shorthand), BackgroundExecutor+AsyncBackgroundExecutor+Submit protocol (__cancel_on_exit__/__reraise_on_exit__/__next_tick__ flags, max_concurrency semaphore, GraphBubbleUp suppression timing-dependent: suppressed for tasks that complete before exit snapshot, re-raised for tasks still in-flight at that point), HumanInterrupt full protocol from langchain.agents.interrupt (ActionRequest/HumanInterruptConfig/HumanResponse/accept+ignore+response+edit types, import path migration), PregelNode+StateNodeSpec node representation internals (channels/triggers/writers/bound, error_handler_node wiring, subgraph auto-detection, StateNodeSpec defer flag).
2026-06-17	1.2.5	Added Class deep-dives Vol. 18 — 10 source-verified deep dives with richer examples: DebugTransformer+stream_mode=“debug” (first full coverage — event types, payload inspection, combined mode tracing), StateSnapshot history navigation (next/tasks/interrupts fields, get_state_history iteration, parent_config chain walking, time-travel rewind), Command full API (update+goto combining, Send fan-out in goto, Command.PARENT cross-graph state writes), add_messages advanced patterns (ID-based dedup replace-in-place, RemoveMessage targeting, REMOVE_ALL_MESSAGES clear-and-replace, format=“langchain-openai” coercion), Topic channel accumulate modes (per-step clear vs. persistent log, multi-producer fanout with Send), NamedBarrierValue fan-in synchronization (parallel branch wait, Send-based fanout, reusable across loop iterations), entrypoint+task+previous stateful accumulation (running totals, conversation history, entrypoint.final to decouple return from save), push_message manual emission (streaming during execution, custom state_key, stream-only state_key=None), EphemeralValue trigger channels (guard=True single-producer signals, guard=False last-writer-wins, per-step config override), CachePolicy+InMemoryCache combined patterns (TTL caching on @task, custom key_func normalisation, per-user namespace isolation, task.clear_cache invalidation).
2026-06-16	1.2.5	Added Class deep-dives Vol. 17 — 10 source-verified practical patterns: RetryPolicy sequence chaining (ordered multi-policy matching, callable retry_on), TimeoutPolicy+Runtime.heartbeat() (idle_timeout with explicit heartbeats, combined with RetryPolicy), Overwrite (bypass BinaryOperatorAggregate reducer, summarisation pattern, error constraints), interrupt() multi-value and selective resume by ID (multi-step approval, id-targeted resume mapping), add_sequence() (ETL pipeline, named nodes, vs manual wiring), update_state()/bulk_update_state()/StateUpdate (state injection, multi-step replay, time-travel rewind), get_stream_writer()/StreamWriter (progress events, multi stream_mode, async warning), stream_mode=“checkpoints”+CheckpointPayload/CheckpointTask (audit trails, checkpoint progression, task field inspection), stream_mode=“tasks”+TaskPayload/TaskResultPayload (task lifecycle logging, interrupt detection, combined modes), set_node_defaults() (global retry/timeout/error_handler, per-node override, precedence table). Also added missing index links for Class deep-dives Vol. 13 (ToolRuntime, channels, policies), Vol. 14 (BranchSpec, LastValue, ManagedValue, @task, DeltaChannel, InMemoryCache, @entrypoint, CompiledStateGraph internals), and Vol. 15 (Runtime/ExecutionInfo/RunControl, BaseStore, store batch ops, UIMessage, StreamTransformer, RemoteGraph, error hierarchy, IsLastStep/RemainingSteps, HumanResponse).
2026-06-15	1.2.5	Added Class deep-dives Vol. 16 — 10 source-verified deep dives into the v3 streaming protocol (beta): GraphRunStream/AsyncGraphRunStream (caller-driven pumping, projections, context manager, abort, interleave, output/interrupted/interrupts properties), SubgraphRunStream/AsyncSubgraphRunStream (in-process subgraph navigation handles, path/status/error fields, recursive grandchild traversal), ValuesTransformer (full-state snapshots on run.values, scope filtering), UpdatesTransformer (per-node deltas on run.updates), CustomTransformer (get_stream_writer payloads on run.custom), MessagesTransformer/ChatModelStream (per-LLM-call handles with .text/.reasoning/.tool_calls/.output projections, token streaming), SubgraphTransformer (subgraph discovery via tasks events, direct-children-only scope, mini-mux child creation), LifecycleTransformer/LifecyclePayload (all-depth subgraph lifecycle events, error detection), and StreamChannel (single-consumer drainable queue, tee fan-out, named auto-forwarding). Updated version card to 1.2.5, “What’s new” section, Reference Aside, and Jump-to-topic grid.
2026-06-07	1.2.4	Added Class deep-dives Vol. 12 — 10 source-verified deep dives into RemoteGraph/RemoteException (call deployed graphs as nodes, state management, distributed tracing), PostgresSaver/ShallowPostgresSaver (full vs constant-space persistence, pipeline mode, connection pooling, time-travel), AsyncPostgresSaver (async twin with asyncio.Lock and AsyncConnectionPool), PostgresStore/PoolConfig (TTL expiry, sweeper thread, InjectedStore in tools), AsyncPostgresStore (AsyncBatchedBaseStore coalescing, concurrent aput/aget), ANNIndexConfig/HNSWConfig/IVFFlatConfig/PostgresIndexConfig (pgvector index types, halfvec, distance metrics), GraphRunStream/SubgraphRunStream (v3 streaming projections, token streaming, abort(), interleave()), ToolCallWithContext/ToolInvocationError (tool dispatch internals, custom error handlers, categorised errors), LifecyclePayload/LifecycleTransformer (subgraph lifecycle monitoring, cause tracking, timing traces), and MessagesTransformer/CheckpointsTransformer/TasksTransformer (per-LLM-call streaming handles, checkpoint flush events, task execution tracing). Updated Jump-to-topic grid and Reference section with Vol. 10–12 links.
2026-06-04	1.2.4	Added Class deep-dives Vol. 9 — 10 source-verified deep dives into ToolCallRequest.override() (immutable interceptor mutation), Send+timeout (per-task fan-out timeouts), create_react_agent hooks (pre_model_hook, post_model_hook, version=“v2”, response_format), RetryPolicy chaining (ordered list of policies), CachePolicy custom key_func (per-user namespace isolation), InMemoryStore raw embedding callables (no LangChain dependency), context_schema+Runtime.context (typed run-scoped context in StateGraph and @entrypoint), Command.PARENT (cross-subgraph routing with error escalation), TimeoutPolicy.coerce() (run_timeout vs idle_timeout), and @entrypoint multi-policy retry. Updated reference files to v1.2.4.
2026-06-03	1.2.4	Added Class deep-dives Vol. 8 — 10 source-verified deep dives into ExecutionInfo/Runtime.heartbeat (advanced patterns: idempotency keys, node_attempt timing, patch() for testing), ServerInfo/BaseUser (platform auth and tenant isolation), ReplayState (time-travel subgraph checkpoint tracking), StreamMux (streaming event dispatcher, transformer factories, child muxes), Call (functional API invocation internals), ChannelWrite/ChannelWriteEntry (write subsystem, do_write() imperative writes, mapper transforms), PregelRunner/FuturesDict (concurrent task execution, error routing, early cancellation), WritesProtocol/PregelTaskWrites (write protocol, deterministic sorting via path), SyncPregelLoop/AsyncPregelLoop (execution state machine, status fields, cooperative drain), and DuplexStream (multi-sink fan-out streaming). Updated version card to 1.2.4, version references in Reference section and Aside block, langgraph-checkpoint to 4.1.1.
2026-05-31	1.2.2	Added Class deep-dives Vol. 5 — 10 source-verified deep dives into RedisCache, EncryptedSerializer, JsonPlusSerializer (strict mode), UntrackedValue, AnyValue, EmbeddingsLambda/ensure_embeddings (with path expressions), BaseCheckpointSaver (custom backend), typed StreamParts (ValuesStreamPart, UpdatesStreamPart, MessagesStreamPart, CheckpointStreamPart, TasksStreamPart), task.clear_cache/aclear_cache, and the HumanInterrupt structured HITL protocol with migration guidance to langchain.agents.interrupt. Updated index Jump-to-topic grid and Reference links.
2026-05-30	1.2.2	Added Class deep-dives Vol. 4 — 10 source-verified deep dives into set_node_defaults, add_sequence, input_schema/output_schema, context_schema/Runtime.context, get_stream_writer/StreamWriter, push_ui_message, entrypoint.final, REMOVE_ALL_MESSAGES, error_handler on add_node, and the full error taxonomy (GraphRecursionError, InvalidUpdateError, NodeTimeoutError, EmptyChannelError). Updated index Jump-to-topic grid and Reference links. Enhanced create_react_agent migration guidance in Vol. 1.
2026-05-29	1.2.2	Added Class deep-dives Vol. 3 — 10 source-verified deep dives into interrupt/Interrupt, DeltaChannel, EphemeralValue, NamedBarrierValue, RemoveMessage/push_message, Pregel, NodeBuilder, GraphOutput, PregelTask, IndexConfig/TTLConfig. Updated index Jump-to-topic grid and Reference links.
2026-05-28	1.2.2	Added Class deep-dives Vol. 2 — 10 source-verified deep dives into RetryPolicy, CachePolicy/InMemoryCache, TimeoutPolicy, add_messages/MessagesState, tools_condition, ToolCallTransformer/ToolCallStream, StateSnapshot, IsLastStep/RemainingSteps, ToolRuntime, and Runtime/RunControl (all verified against langgraph==1.2.2). Updated version card and index links.
2026-05-25	1.2.1	Review fixes: corrected durability placement (invoke/stream, not compile); fixed context= top-level param pattern; updated ToolRuntime to add missing tools, execution_info, server_info fields (source-verified); fixed clear_history_node P1 bug (preserve current message before REMOVE_ALL_MESSAGES); added None guards for runtime.state, runtime.store, runtime.context; removed _DirectlyInjectedToolArg private class from docs; fixed version history (RemainingSteps added in 1.2, not 1.0).
2026-05-24	1.2.1	Deep source dive: enhanced chapters 1, 4, 9 with add_sequence, context_schema/Runtime, ToolRuntime, REMOVE_ALL_MESSAGES, push_message, Overwrite, GraphOutput v2, TimeoutPolicy, Send(timeout=). Updated streaming modes ref (all 7 modes + StreamPart v2 typed union). Updated store ref (vector search, filter operators, TTL, batch). New ref page: Runtime, ToolRuntime & Managed Values. Updated recipes to v1.2.1 with 3 new examples. All content verified against langgraph==1.2.2 source.
2026-05-22	1.2.1	Patch release; version card updated 1.2.0 → 1.2.1; v1.2.1 bullet added to “What’s new”. All core symbols (StateGraph, END, START, CompiledStateGraph, MemorySaver, create_react_agent, ToolNode, InMemoryStore, Command, Send, Interrupt, interrupt, entrypoint, task) verified with -W error::DeprecationWarning against installed langgraph==1.2.2 (.routine-envs/check-0522-langgraph); all PASS.
2026-05-12	1.2.0	Minor release; version card and all version references updated 1.1.10 → 1.2.0; langgraph-checkpoint updated 4.0.3 → 4.1.0; langgraph-prebuilt updated to 1.1.0. “What’s new” section updated with ToolRuntime and ToolCallTransformer additions. All core symbols (StateGraph, END, START, CompiledStateGraph, MemorySaver, create_react_agent, ToolNode, InMemoryStore, Command, Send, Interrupt, interrupt, entrypoint, task) verified with -W error::DeprecationWarning against installed langgraph==1.2.0 (.routine-envs/check-0512-py).
2026-04-28	1.1.10	Patch release; version card and reference pages updated 1.1.9 → 1.1.10; langgraph-checkpoint updated 4.0.2 → 4.0.3. All key symbols verified against installed 1.1.10 (.routine-envs/main-py-0428).
2026-04-22	1.1.9	Added six source-verified reference pages: StateGraph, Checkpointers, Store, Functional API, Command / Send, Streaming modes. Corrected stale guidance: create_react_agent deprecated in v1.0; from_conn_string is a context manager; ShallowPostgresSaver deprecated.
2026-04-21	1.1.8	Index redesigned into Zero → Hero chaptered tutorial + Jump-to-topic grid; duplicated sections removed.
2026-04-20	1.1.8	Version pin updated to 1.1.8; frameworks.ts metadata aligned.
April 16, 2026	1.1.6	Python 3.9 dropped; type-safe v2 streaming/invoke API; Pydantic/dataclass coercion; Python 3.14 support; time-travel fixes.
November 2025	1.0.3	Node caching; deferred nodes; pre/post model hooks; cross-thread memory; Python 3.13 support.