langgraph

Enables developers to define multi-step agentic workflows as directed acyclic graphs using a declarative API where nodes are functions and edges define control flow. StateGraph uses TypedDict schemas to enforce typed state contracts across nodes, with automatic channel management for state mutations. The framework validates graph topology at definition time and compiles it into an executable Pregel engine that enforces deterministic execution ordering.

Implements a Pregel-inspired BSP execution model where all nodes execute in synchronized supersteps, with state mutations collected and applied atomically between steps. The Pregel engine manages message passing between nodes through typed channels, enforces deterministic ordering, and supports both synchronous and asynchronous node execution. Each superstep reads current channel state, executes eligible nodes in parallel, collects mutations, and applies them atomically before advancing to the next superstep.

Provides a functional programming interface for defining agents using @task and @entrypoint decorators, enabling developers to compose workflows without explicit StateGraph definitions. Tasks are decorated functions that become nodes in an implicit graph, with @entrypoint marking the workflow entry point. The framework automatically infers state schema from function signatures and manages state threading, reducing boilerplate compared to declarative StateGraph definitions.

Enables executing graphs deployed on a LangGraph server from Python or JavaScript clients via HTTP, with streaming support for real-time output. RemoteGraph wraps a deployed graph and provides the same interface as local StateGraph, transparently handling serialization, network communication, and streaming. The framework supports both request-response and streaming execution modes, with automatic retry and error handling for network failures.

Provides a command-line interface for deploying graphs as HTTP services and a configuration system (langgraph.json) for specifying deployment parameters. The CLI generates Docker images, manages local development servers, and handles multi-service orchestration. Configuration includes graph definitions, environment variables, dependencies, and deployment targets, enabling one-command deployment of agent services.

Provides a high-level API for managing multi-turn conversations through threads, where each thread maintains independent execution state and checkpoint history. The Assistants API abstracts away graph execution details, exposing a simple interface for creating threads, sending messages, and retrieving responses. Threads are persisted in the checkpoint store, enabling long-lived conversations that survive process restarts.

Enables scheduling agent graphs to execute on a recurring basis using cron expressions, with execution results persisted as runs in the checkpoint store. Cron jobs are defined declaratively in langgraph.json or via the Assistants API, with configurable schedules, input parameters, and error handling. The framework manages job scheduling and execution, with built-in support for timezone handling and missed execution recovery.

Provides a factory function (create_react_agent) that generates a complete ReAct agent graph with built-in tool-use loop, reasoning, and action execution. The prebuilt agent handles tool selection, execution, and result integration without requiring manual graph definition. It supports both LLM-based tool selection and explicit tool routing, with configurable system prompts and tool definitions.

Provides serialization infrastructure for persisting complex state objects (LLM messages, tool calls, custom types) to checkpoint storage and remote execution. The framework supports JSON serialization with custom type handlers, enabling developers to define serializers for non-standard types. Serialization is transparent during checkpoint persistence and remote execution, with automatic fallback to JSON for standard types.

Manages agent state through a channel system where each channel is a typed container with configurable merge semantics (LastValue, Topic, BinaryOperatorAggregate). Channels enforce type contracts via TypedDict schemas and handle state mutations across nodes by collecting updates and applying them atomically. The framework supports both simple value channels (LastValue) and aggregation channels (Topic for lists, BinaryOperatorAggregate for custom reductions), enabling flexible state composition patterns.

Persists agent execution state to external storage (SQLite, PostgreSQL, or custom BaseCheckpointSaver implementations) after each superstep, enabling resumption from exact execution point after failures. Checkpoints capture channel values, execution metadata, and version information, allowing agents to recover without re-executing completed steps. The framework supports multiple checkpoint backends through a pluggable interface, with built-in implementations for SQLite and PostgreSQL.

Enables pausing agent execution at any superstep to inspect and modify state before resumption, supporting human oversight and intervention workflows. The interrupt system uses breakpoint predicates to pause execution when conditions are met, allowing external systems to read current state via get_state() and modify it via update_state() before resuming. Interrupts are persisted as part of checkpoint metadata, enabling recovery of interrupted workflows across process restarts.

Routes execution to different nodes based on runtime predicates evaluated on current state, enabling dynamic control flow without explicit branching logic. Conditional edges accept a predicate function that reads current state and returns the next node name, supporting both deterministic routing (based on state values) and probabilistic routing (based on LLM outputs). The framework validates that all predicate return values correspond to valid nodes, catching routing errors at graph definition time.

Enables composing complex workflows from reusable subgraphs, where a node can invoke another StateGraph as a nested execution unit. Nested graphs receive a subset of parent state, execute independently with their own checkpoint boundaries, and return results that are merged back into parent state. The framework handles state mapping between parent and child graphs, enabling modular workflow composition without explicit state threading.

Provides configurable error handling and retry mechanisms at the node level, supporting exponential backoff, max retry limits, and custom error handlers. Nodes can define retry policies that automatically re-execute on failure with configurable backoff strategies, and custom error handlers can transform exceptions into state mutations or routing decisions. Retry state is persisted in checkpoints, enabling recovery of partially-retried nodes across process restarts.

Enables rewinding execution to any previous checkpoint and forking from that point to explore alternative execution paths without affecting the original execution history. The framework stores complete checkpoint history, allowing developers to query state at any superstep and create new execution branches from historical states. Forked executions are isolated from the original, enabling safe exploration and debugging without side effects.

Provides a key-value store abstraction (BaseStore interface) for persisting data across multiple execution threads and agent instances, complementing the per-thread channel state. The store system supports custom implementations (e.g., Redis, DynamoDB) and enables agents to access shared knowledge bases, conversation history, and long-term memory without explicit state threading. Store operations are integrated into the execution model, with reads/writes captured in checkpoint metadata for reproducibility.