A graph whose nodes communicate by reading and writing to a shared state. The signature of each node is `State -> Partial<State>`. Each stat

One or more commands to update the graph's state and send messages to nodes. Args: graph: Graph to send the command to. Supported values

Handle async requests to the LangGraph API. Adds additional error messaging & content handling above the provided httpx client. Attribut

Client for managing threads in LangGraph. A thread maintains the state of a graph across multiple interactions/invocations (aka runs). It acc

Holds scripted state for tests and exposes a Starlette app. Attributes: received_commands: every command body posted to /commands, in ord

A node for executing tools in LangGraph workflows. Handles tool execution patterns including function calls, state injection, persistent stor

An in-memory checkpoint saver. This checkpoint saver stores checkpoints in memory using a `defaultdict`. Note: Only use `InMemorySav

Handle synchronous requests to the LangGraph API. Provides error messaging and content handling enhancements above the underlying httpx clien

Central event dispatcher for the streaming infrastructure. Owns the main event log and routes events through a transformer pipeline. StreamCh

Serializer that uses ormsgpack, with optional fallbacks. !!! warning Security note: This serializer is intended for use within the `Base

Synchronous client for managing threads in LangGraph. This class provides methods to create, retrieve, and manage threads, which represent co

Single-consumer drainable queue for streaming events, with optional protocol auto-forwarding. When constructed with a `name`, the StreamMux a

Synchronous fake for `/commands`, `/stream/events`, and `/state`.

Information about an interrupt that occurred in a node. !!! version-added "Added in version 0.2.24" !!! version-changed "Changed in version

Stores the last value received, can receive at most one value per step.

Pregel manages the runtime behavior for LangGraph applications. ## Overview Pregel combines [**actors**](https://en.wikipedia.org/wiki/Actor

Snapshot of the state of the graph at the beginning of a step.

A message or packet to send to a specific node in the graph. The `Send` class is used within a `StateGraph`'s conditional edges to dynamicall

The `RemoteGraph` class is a client implementation for calling remote APIs that implement the LangGraph Server API specification. For example

A Pregel task.

Configuration for retrying nodes. !!! version-added "Added in version 0.2.24"

In-memory dictionary-backed store with optional vector search. !!! example "Examples" Basic key-value storage: store = InMemo

Reducer channel that stores only a sentinel in checkpoint blobs and reconstructs state by replaying ancestor writes through the reducer. !!!

v3 protocol transport bound to a single `thread_id`. Commands go to `POST /threads/{thread_id}/commands` (JSON in, JSON out). `open_event_str

Configuration for timing out node attempts. !!! note "Cooperative cancellation" Timeouts rely on asyncio cancellation. If your node uses

v3 protocol transport using HTTP commands and WebSocket events.

A tuple containing a checkpoint and its associated data.

Operation to store, update, or delete an item in the store. This class represents a single operation to modify the store's contents, whether

Represents a part of a stream response.

Dual-mode output: JSON-lines (``--json``) or human-readable click text.

Run-scoped control surface for cooperative draining. Intended for a single graph run. Create a fresh `RunControl` per run; reusing a control

Minimal JSON HTTP client for the host backend deployment service.

A much simpler version of RunnableLambda that requires sync and async functions.

Synchronous client for managing cron jobs in LangGraph. This class provides methods to create and manage scheduled tasks (cron jobs) for automate

Sync run stream with caller-driven pumping. The caller's iteration on any projection (`values`, `messages`, raw events, or `output`) drives t

Client for managing recurrent runs (cron jobs) in LangGraph. A run is a single invocation of an assistant with optional input, config, and contex

Stores the value received in the step immediately preceding, clears after.

Operation to retrieve a specific item by its namespace and key. This operation allows precise retrieval of stored items using their full path

Yields one tool-call handle per `tool-started` event. Mirrors the per-event body of `_ToolCallsProjection._tool_calls_iter` (`_async/stream.p

Raised when attempting to update a channel with an invalid set of updates. Troubleshooting guides: - [`INVALID_CONCURRENT_GRAPH_UPDATE`](htt

Discovers child subgraph handles and fans out events to active ones. Mirrors the per-event body of `_SubgraphsProjection._subgraphs_iter` (`_

Async context manager for one thread's v3 streaming session. Construct via `client.threads.stream(thread_id=None, *, assistant_id, ...)` rath

Operation to list and filter namespaces in the store. This operation allows exploring the organization of data, finding specific collections,

Yields one chat-model stream per `message-start` event. Subsequent events route to the matching stream via `stream.dispatch(data)`. Mirrors t

Capture messages events as ChatModelStream objects. The messages projection yields one `ChatModelStream` (or `AsyncChatModelStream`) per LLM

Scoped streaming handle for one discovered child invocation.

Yields `params.data` from events of a single `method`. Covers the channels whose projection is just "emit the payload": `values`, `updates`,

Annotation for injecting graph state into tool arguments. This annotation enables tools to access graph state without exposing state manageme

Convenience class that bundles run-scoped context and other runtime utilities. This class is injected into graph nodes and middleware. It provide

Operation to search for items within a specified namespace hierarchy. This operation supports both structured filtering and natural language sear

Manages subscriptions and fan-out against one shared SSE connection. Responsibilities: - subscription registry (register / unregister)

Sync v3 protocol transport using HTTP commands and WebSocket events.

State snapshot at a given point in time.

Simplest implementation of WritesProtocol, for usage with writes that don't originate from a runnable task, eg. graph input, update_state, etc.

Synchronous client for managing runs in LangGraph. This class provides methods to create, retrieve, and manage runs, which represent individu

r"""UUID draft version objects

Minimal stand-in for PregelExecutableTask covering only what map_debug_tasks reads.

Raised when attempting to get the value of a channel that hasn't been updated for the first time yet.

Read-only execution info/metadata for the execution of current thread/run/node.

Yields `params.data` from one named custom channel. Mirrors `_ExtensionProjection._iter` (`_async/stream.py:1278-1299`), with an added name f

Fake tracer that records LangChain execution. It replaces run ids with deterministic UUIDs for snapshotting.

Raised when a subgraph is interrupted, suppressed by the root graph. Never raised directly, or surfaced to the user.

Annotation for injecting persistent store into tool arguments. This annotation enables tools to access LangGraph's persistent storage system

Capture values events as a drainable stream of state snapshots. Provides the `run.values` projection. `run.output`, `run.interrupted` and `ru

Stores the result of applying a binary operator to the current value and each new value. ```python import operator total = Channels.Bina

Capture custom events as a drainable stream of arbitrary payloads. Nodes emit custom data via `get_stream_writer()`. This transformer surface

Handle for one async filtered event stream.

Represents a stored item with metadata. Args: value: The stored data as a dictionary. Keys are filterable. key: Unique identifier

Bypass a reducer and write the wrapped value directly to a `BinaryOperatorAggregate` channel. Receiving multiple `Overwrite` values for the same

A configurable PubSub Topic. Args: typ: The type of the value stored in the channel. accumulate: Whether to accumulate values acr

Implements the logic for sending writes to CONFIG_KEY_SEND. Can be used as a runnable or as a static method to call imperatively.

Typed container returned by `invoke()` / `ainvoke()` with `version="v2"`. Attributes: value: The final output of the graph (dict, Pydanti

A container for referencing and managing local Python dependencies. A "local dependency" is any entry in the config's `dependencies` list tha

Redis-based cache implementation with TTL support.

Client for managing runs in LangGraph. A run is a single assistant invocation with optional input, config, context, and metadata. This client

Scoped streaming handle for one discovered child invocation.

Sync v3 protocol transport bound to one thread id.

Owns the sync shared SSE handle, subscription registry, and fan-out thread.

Capture raw task events as a drainable stream. Surfaces `stream_mode="tasks"` data on `run.tasks` as a `StreamChannel[dict[str, Any]]`. Each

LRU set of event ids with bounded memory.

Represents a request to execute an action by an agent. The action consists of the name of the tool to execute and the input to pass to t

Final return value of an ActionAgent. Agents return an AgentFinish when they have reached a stopping condition.

Client for managing assistants in LangGraph. This class provides methods to interact with assistants, which are versioned configurations of y

Represents a pattern for matching namespaces in the store. This class combines a match type (prefix or suffix) with a namespace path pattern