LangGraph

Enables developers to define multi-step LLM workflows as directed acyclic graphs (DAGs) using the StateGraph class, where nodes represent functions/LLM calls and edges define control flow. Supports conditional routing, loops, and branching through a declarative Python API that compiles to an internal graph representation executed by the Pregel engine. State is managed through typed TypedDict schemas with merge semantics per channel.

Provides a decorator-based API (@task, @entrypoint) as an alternative to StateGraph for defining workflows in a more functional style. Functions decorated with @task become graph nodes, and @entrypoint marks the entry point. The framework automatically infers graph structure from function call chains and type annotations, reducing boilerplate compared to explicit StateGraph construction.

Provides built-in error handling and retry mechanisms for node failures. Developers can define retry policies (max attempts, backoff strategy) per node or globally. When a node fails, the framework automatically retries with exponential backoff, optionally with jitter. Failed executions are logged with full context (state, error, attempt count), and after max retries are exceeded, execution can be paused for manual intervention or routed to an error handler node.

Provides native SDKs for Python and JavaScript/TypeScript that enable local graph execution and remote execution via LangGraph Cloud. Both SDKs support streaming execution (yielding intermediate results as they become available), enabling real-time feedback to users. The Python SDK is feature-complete; the JavaScript SDK provides a subset of functionality with async/await semantics. Both SDKs handle serialization, checkpoint management, and remote API communication transparently.

Enables deploying graphs to LangGraph Cloud and invoking them via HTTP API. The cloud platform manages infrastructure, persistence, and scaling. Graphs are invoked via the Assistants API, which manages long-lived conversation threads and maintains execution history. Each thread is a separate execution context with its own checkpoint history, enabling multi-turn conversations where state persists across invocations. The platform handles authentication, rate limiting, and monitoring transparently.

Provides a BaseStore interface for persistent, cross-thread storage of long-term memory and knowledge. Unlike channels (which are per-execution state), stores persist across multiple executions and threads, enabling agents to accumulate knowledge over time. Built-in implementations include in-memory stores and database-backed stores. Developers can implement custom stores by extending BaseStore, enabling integration with external knowledge bases, vector databases, or semantic search systems.

Provides a caching layer that memoizes node outputs based on input state, reducing redundant computation. The cache is keyed by node ID and input state hash, enabling deterministic caching across executions. For LLM calls, caching can be enabled at the LLM level (via LangChain's caching) or at the node level. Cache hits return stored outputs without re-executing the node, reducing latency and API costs. Cache invalidation can be manual or time-based.

Provides a factory function (create_react_agent) that generates a complete ReAct (Reasoning + Acting) agent graph with tool calling support. The agent implements the ReAct loop: think (LLM reasoning), act (tool call), observe (tool result), repeat. ToolNode handles tool execution, managing tool definitions, argument validation, and error handling. The prebuilt agent is fully customizable (LLM, tools, system prompt) and integrates with the standard graph execution model, enabling extension with custom nodes or sub-graphs.

Provides a command-line interface (langgraph CLI) for local development, testing, and deployment. The CLI reads graph definitions from langgraph.json (configuration file specifying graph entry points, dependencies, and deployment settings) and generates Docker images for cloud deployment. Local development uses langgraph dev to run a local server with hot-reloading. The CLI handles dependency installation, Docker image building, and deployment to LangGraph Cloud.

Handles serialization of graph state, checkpoints, and messages to JSON and other formats. The framework provides default serializers for common types (strings, numbers, lists, dicts) and allows custom serializers for application-specific types (e.g., Pydantic models, custom classes). Serialization is required for checkpoint persistence, remote execution, and message passing. Deserialization reconstructs objects from serialized form, enabling checkpoint resumption and state reconstruction.

Executes compiled graphs using a Bulk Synchronous Parallel (BSP) model where each execution step is a synchronization barrier. After each step, all node outputs are collected, state is merged via channel semantics (LastValue, Topic, BinaryOperatorAggregate), and a checkpoint is persisted containing channel values and execution metadata. This enables deterministic replay, resumption from exact state, and cycle-aware execution (loops) that pure DAG engines cannot support.

Manages workflow state through a channel system where each channel is a typed container with defined merge semantics. Channels support three merge strategies: LastValue (overwrites with latest), Topic (accumulates all values as a list), and BinaryOperatorAggregate (applies a custom aggregation function). State is defined via TypedDict schemas, and channels are declared with explicit types and merge rules, enabling safe, predictable state evolution across graph steps.

Enables pausing graph execution at specified nodes, inspecting the current state, and resuming with modified state via the interrupt system. Developers mark nodes with interrupt=True, and at runtime the Pregel engine pauses before executing those nodes, allowing external systems (UI, human reviewers, external APIs) to inspect state via update_state() and resume execution. Supports both blocking interrupts (pause and wait) and non-blocking interrupts (log and continue).

Persists execution state to durable storage via the BaseCheckpointSaver interface, with built-in implementations for SQLite, PostgreSQL, and in-memory storage. Each checkpoint contains channel values, execution metadata (step count, timestamps), and version information. The framework automatically creates checkpoints after each execution step, enabling resumption from any previous state. Custom checkpoint implementations can be plugged in by extending BaseCheckpointSaver.

Enables developers to replay execution from any previous checkpoint, inspect state at that point, and fork execution in a new direction. The framework stores full execution history as a sequence of checkpoints, allowing non-destructive exploration of alternative execution paths. Developers can query checkpoint history, load a specific checkpoint, and resume execution with modified state, creating a new execution branch without affecting the original.

Enables distributed execution of graph nodes across multiple processes/machines using Kafka as a message broker. Nodes can be deployed as separate services, and the framework routes messages between them via Kafka topics. Each node subscribes to input topics and publishes to output topics, enabling horizontal scaling of compute-intensive steps. The Pregel engine coordinates execution across distributed nodes while maintaining checkpoint semantics.

Allows graphs to be composed hierarchically by embedding one graph as a node within another. Sub-graphs receive input state, execute their internal workflow, and return output state to the parent graph. The framework handles state mapping between parent and sub-graph scopes, enabling modular workflow design. Sub-graphs are executed atomically from the parent's perspective, but maintain their own checkpoint history internally.

Provides explicit control flow primitives for branching, looping, and conditional execution. Edges can be conditional (routing to different nodes based on state), and nodes can emit control signals (e.g., 'continue', 'break', 'loop') to direct execution flow. The framework supports both deterministic routing (based on state values) and dynamic routing (based on node outputs), enabling complex control flow patterns without explicit if-else chains in node code.