langgraph

Defines multi-step agent workflows as directed acyclic graphs (DAGs) using the StateGraph class, where nodes represent typed functions and edges represent control flow. Developers declare state schema as TypedDict, add nodes with callable handlers, and define conditional edges for branching logic. The framework compiles this declarative definition into an executable Pregel-based state machine that manages state transitions, channel updates, and execution ordering without requiring manual orchestration code.

Allows developers to define agent tasks as decorated Python functions using @task and @entrypoint decorators, automatically converting them into graph nodes with type-aware input/output handling. The framework introspects function signatures to infer state channel bindings, parameter types, and return value merging strategies. This functional API provides a lighter-weight alternative to StateGraph for simple workflows while maintaining compatibility with the underlying Pregel execution engine.

Supports distributed agent execution across multiple workers using Kafka for coordination and state synchronization. The framework distributes graph nodes across workers, uses Kafka topics for inter-node communication, and maintains checkpoint consistency across the distributed system. Developers configure Kafka connection details and worker topology, and the framework handles all message routing and state marshaling automatically.

Provides a high-level Assistants API that manages conversation threads, runs, and state persistence automatically. Developers create an Assistant from a compiled graph, then invoke it with user messages; the framework manages thread creation, checkpoint storage, and message history. Each run executes the graph with the current thread state, and results are streamed back to the caller. The API abstracts away checkpoint and state management details, providing a simpler interface for conversational agents.

Provides a factory function create_react_agent() that generates a fully configured ReAct (Reasoning + Acting) agent graph with built-in tool calling, result aggregation, and loop termination logic. The ToolNode component handles tool execution, error handling, and result formatting. Developers pass an LLM and list of tools, and the framework generates a complete agent graph with proper state management, tool invocation, and response formatting without requiring manual graph construction.

Provides a command-line interface (langgraph CLI) and Docker image generation for deploying agents as services. Developers define agent configuration in langgraph.json (graph path, environment variables, dependencies), and the CLI generates a Dockerfile, builds images, and deploys to local or cloud environments. The framework handles dependency management, environment setup, and service configuration automatically, enabling one-command deployment.

Provides a BaseStore interface for persisting data across multiple execution threads, enabling agents to maintain long-term memory and shared knowledge bases. Unlike channels (which are thread-specific), the Store API provides a key-value interface for storing and retrieving data that persists across different conversation threads or agent runs. Developers implement custom stores (e.g., vector databases, SQL databases) or use prebuilt implementations, and access them via store.put() and store.get() methods.

Implements a caching layer that memoizes node execution results based on input state, avoiding redundant computation when the same state is encountered. The framework uses content-addressable caching where cache keys are derived from input state hashes, enabling automatic deduplication across different execution paths. Developers can configure cache backends (in-memory, Redis, custom) and cache invalidation policies per node.

Handles serialization of state, checkpoints, and messages to JSON and other formats, with pluggable serializers for custom types. The framework provides default serializers for Pydantic models, dataclasses, and standard Python types, and allows developers to register custom serializers for domain-specific types. Serialization is used for checkpoint persistence, remote execution, and API responses, ensuring all state can be safely transmitted and stored.

Implements a Bulk Synchronous Parallel (BSP) execution model where each superstep atomically updates all active nodes' state channels, then synchronizes before the next superstep. The Pregel engine manages node scheduling, channel merging, and state consistency across distributed or local execution contexts. Each superstep produces a deterministic checkpoint containing all channel values and execution metadata, enabling exact-state resumption after failures or interrupts.

Manages agent state through a channel system where each state field is a typed container with configurable merge semantics (LastValue, Topic, BinaryOperatorAggregate). Channels define how concurrent node updates are combined when multiple nodes write to the same state field in a superstep. The framework validates all state updates against the TypedDict schema and applies merge functions atomically, ensuring type safety and predictable state evolution.

Allows agents to pause execution at any superstep via the interrupt system, enabling external inspection and modification of state before resumption. Developers call interrupt() to halt execution, then use update_state() to modify any state field, and resume execution from the exact interruption point. The framework maintains full execution history and checkpoint state, allowing humans to inspect intermediate results, correct agent decisions, or inject new information before continuing.

Persists agent execution state at each superstep via the BaseCheckpointSaver interface, storing Checkpoint objects containing channel values, execution metadata, and version information. Developers implement custom checkpoint savers (e.g., SQLite, PostgreSQL, in-memory) by extending BaseCheckpointSaver with put() and get() methods. The framework automatically invokes checkpoint savers after each superstep, enabling exact-state recovery after failures, interrupts, or explicit resumption from past checkpoints.

Allows developers to compose complex agents by nesting StateGraph instances as nodes within parent graphs, enabling hierarchical agent architectures. Subgraphs execute as atomic units within parent supersteps, with their internal state isolated from parent state via explicit input/output mapping. The framework handles state marshaling between parent and subgraph contexts, allowing developers to build modular agent components that can be reused across multiple parent graphs.

Provides built-in error handling and retry mechanisms for node execution failures, allowing developers to define retry policies (max attempts, backoff strategy) at the node or graph level. When a node fails, the framework can automatically retry with exponential backoff, linear backoff, or custom retry logic before propagating the error. Failed checkpoints are preserved, enabling inspection of failure context and manual recovery via state modification.

Enables developers to retrieve historical checkpoints and fork execution from any past state, creating alternative execution branches without restarting from the beginning. The framework maintains a complete execution history indexed by checkpoint ID and timestamp, allowing queries like 'get state at step 5' or 'fork from checkpoint X and execute with different parameters'. Forked executions are independent and can be persisted separately, enabling experimentation and what-if analysis.

Allows agents to be deployed as remote services and invoked via HTTP, with the Python SDK providing a RemoteGraph client that streams results back to the caller. The framework handles serialization of state, inputs, and outputs across the network, and supports streaming responses for long-running agents. Remote execution maintains full checkpoint semantics, enabling interrupt/resume and state modification on remote agents.