LangGraph

Defines multi-step LLM workflows as directed acyclic graphs using the StateGraph class, where nodes are Python functions and edges define control flow. Implements a Bulk Synchronous Parallel (BSP) execution model inspired by Google's Pregel, enabling developers to declare complex agent architectures with branching, loops, and conditional routing without imperative orchestration code. State flows through typed channels with merge semantics (LastValue, Topic, BinaryOperatorAggregate), ensuring deterministic composition of multi-actor workflows.

Provides a functional programming API using Python decorators (@task, @entrypoint) as an alternative to StateGraph for defining workflows. Tasks are decorated functions that automatically integrate into a graph, with dependency injection of runtime context and automatic state threading. This approach reduces boilerplate compared to explicit node/edge declaration while maintaining the same underlying Pregel execution semantics and persistence guarantees.

Implements a caching layer that stores node outputs based on input hash, enabling deterministic execution and cost reduction for expensive operations (LLM calls, API requests). Cache is keyed by node input and can be persisted across executions, allowing subsequent runs with identical inputs to skip execution and return cached results. This integrates with the checkpoint system to ensure cache consistency.

Provides native SDKs for Python and JavaScript/TypeScript enabling graph definition and execution in multiple languages. The SDKs share the same underlying execution semantics (Pregel, checkpointing, state management) while providing language-idiomatic APIs. JavaScript/TypeScript SDK uses HTTP client for remote execution against LangGraph Server, enabling browser-based and Node.js clients.

Enables deploying compiled graphs to LangGraph Server, a cloud-hosted execution environment accessible via HTTP/WebSocket APIs. Clients invoke graphs remotely, with support for streaming results, authentication (API keys, OAuth), and multi-tenant isolation. Server handles persistence, checkpointing, and execution scheduling, allowing agents to run independently of client lifecycle.

Provides a high-level Assistants API for managing long-running conversations with agents, using threads to maintain conversation history and state. Each thread is a persistent conversation context with its own checkpoint history, enabling multi-turn interactions without explicit state management. Threads support message history, file attachments, and tool execution, abstracting away graph-level details for end-user interactions.

Provides a BaseStore interface for persistent, cross-thread storage of long-term memory and knowledge bases. Unlike channels (which are per-execution state), the Store persists data across multiple graph executions and threads, enabling agents to build and access shared knowledge. Store supports key-value operations and is pluggable (in-memory, PostgreSQL, custom implementations).

Provides a pre-built ReAct (Reasoning + Acting) agent pattern via create_react_agent factory, implementing the think-act-observe loop where agents reason about tasks, select and execute tools, and observe results. The factory creates a StateGraph with predefined nodes (agent reasoning, tool execution) and routing logic, reducing boilerplate for common agent patterns. Supports multiple LLM providers and tool schemas.

Provides a ToolNode component that executes tools (functions) selected by the agent, with automatic schema extraction from Pydantic models and error handling. ToolNode maps tool names to implementations, validates inputs against schemas, executes tools, and captures results or errors. This abstracts away tool invocation boilerplate and integrates with the agent's tool-calling interface.

Implements serialization of graph state and checkpoints to JSON and pickle formats, with support for custom type serialization via pluggable serializers. This enables checkpoint persistence, state transmission over HTTP, and debugging. The serialization system handles complex types (Pydantic models, custom classes) and maintains type information for deserialization.

Implements the Pregel bulk synchronous parallel execution model where all nodes execute in lockstep supersteps, with state synchronized between steps via channels. The Pregel execution engine processes graphs by iterating supersteps until convergence (no node produces output), enabling deterministic execution order and exact resumption from checkpoints. Each superstep atomically reads input channels, executes node functions, and writes output channels, with built-in support for partial execution and streaming.

Manages workflow state through a channel system where each channel is a typed container with defined merge semantics (LastValue, Topic, BinaryOperatorAggregate). State is defined as a TypedDict schema, and channels determine how multiple node outputs are combined when multiple nodes write to the same channel in a superstep. This design enables safe concurrent writes, automatic state aggregation, and type-safe state access across the entire workflow.

Enables pausing agent execution at any point via an interrupt system, allowing external actors to inspect the current state, modify it, and resume execution. The interrupt mechanism is implemented via the update_state() method and checkpoint-based resumption, allowing humans or external systems to inject decisions, correct errors, or provide additional context before the agent continues. This is critical for workflows requiring human approval, feedback loops, or error recovery.

Persists agent execution state at each superstep using a BaseCheckpointSaver interface, storing channel values, execution metadata, and version information. Checkpoints enable exact resumption from any prior step without re-executing completed work, and support time-travel debugging by allowing inspection and replay of any historical state. The checkpoint system is pluggable (SQLite, PostgreSQL, custom implementations) and integrates with the Pregel execution engine for atomic checkpoint writes.

Implements control flow through edge conditions and node routing logic, enabling conditional branching (if/else), loops (while), and parallel execution paths. Routing is implemented via edge conditions (functions returning node names) and END sentinel, allowing dynamic control flow based on node output. This enables complex agent patterns like ReAct loops (think-act-observe cycles), conditional tool selection, and multi-path exploration.

Enables composing multiple StateGraphs into larger graphs by treating subgraphs as nodes, allowing modular workflow design and code reuse. Nested graphs maintain their own state and execution semantics while integrating into parent graph execution. This pattern enables building libraries of reusable workflow components (e.g., a 'research' subgraph, 'planning' subgraph) that can be combined into larger applications without code duplication.

Provides built-in error handling and retry mechanisms at the node level, with configurable retry policies (exponential backoff, max retries, jitter). Errors are caught during node execution and can trigger retries or propagate to parent graph. This integrates with the checkpoint system to ensure retries resume from the same state without re-executing prior steps.

Provides a dependency injection system allowing nodes to request runtime context (configuration, secrets, external services) without explicit parameter passing. Context is injected at execution time via a RunnableConfig object, enabling nodes to access configuration, API keys, and other runtime dependencies. This pattern reduces boilerplate and enables dynamic configuration without modifying graph definitions.