An empty sequence of strings.
Unset sentinel value.
The last (maybe virtual) node in graph-style Pregel.
The first (maybe virtual) node in graph-style Pregel.
Tag to hide a node/edge from certain tracing/streaming environments.
Special value to indicate that graph should interrupt on all nodes.
Type variable used to represent graph run scoped context.
Defaults to None.
Type variable used to represent the input to a StateGraph.
Defaults to StateT.
Type variable used to represent the input to a node.
Type variable used to represent the output of a StateGraph.
Defaults to StateT.
Type variable used to represent the state in a graph.
Return cached annotated keys for a Python class.
Determine the default value for a field in a state schema.
Get Pydantic state update as a list of (key, value) tuples.
Create a pydantic model with the given field definitions.
Coerce a runnable-like object into a Runnable.
Normalize a timeout value to positive-second policy fields.
TypedDict to use for extra keyword arguments, enabling type checking warnings for deprecated arguments.
Base class for all channels.
Reducer channel that stores only a sentinel in checkpoint blobs and reconstructs state by replaying ancestor writes through the reducer.
DeltaChannel is in beta. The API and on-disk representation may
change in future releases. Threads written with DeltaChannel today
are expected to remain readable, but the surrounding contract
(BaseCheckpointSaver.get_delta_channel_history, the
_DeltaSnapshot blob shape, the counters_since_delta_snapshot
metadata field) is not yet stable.
The reducer receives the current accumulated value and a batch of writes
in one call: reducer(state, [write1, write2, ...]) -> new_state.
Reducers must be deterministic and batching-invariant (associative across folds): applying two consecutive write batches separately must produce the same state as applying their concatenation once:
reducer(reducer(state, xs), ys) == reducer(state, xs + ys)
This lets LangGraph replay checkpointed writes in larger batches than they were originally produced without changing reconstructed state.
Snapshot cadence is driven by two counters: per-channel update count and
total supersteps since last snapshot. create_checkpoint writes a full
_DeltaSnapshot blob when EITHER the update count reaches
snapshot_frequency OR the supersteps count reaches the system-wide
DELTA_MAX_SUPERSTEPS_SINCE_SNAPSHOT bound (default 5000), bounding
replay depth even for channels that stop receiving writes.
Stores the value received in the step immediately preceding, clears after.
Stores the last value received, can receive at most one value per step.
Stores the last value received, but only made available after finish(). Once made available, clears the value.
A channel that waits until all named values are received before making the value available.
A channel that waits until all named values are received before making the value ready to be made available. It is only made available after finish() is called.
Raised when attempting to update a channel with an invalid set of updates.
Troubleshooting guides:
Pregel manages the runtime behavior for LangGraph applications.
Pregel combines actors and channels into a single application. Actors read data from channels and write data to channels. Pregel organizes the execution of the application into multiple steps, following the Pregel Algorithm/Bulk Synchronous Parallel model.
Each step consists of three phases:
Repeat until no actors are selected for execution, or a maximum number of steps is reached.
An actor is a PregelNode.
It subscribes to channels, reads data from them, and writes data to them.
It can be thought of as an actor in the Pregel algorithm.
PregelNodes implement LangChain's
Runnable interface.
Channels are used to communicate between actors (PregelNodes).
Each channel has a value type, an update type, and an update function – which
takes a sequence of updates and
modifies the stored value. Channels can be used to send data from one chain to
another, or to send data from a chain to itself in a future step. LangGraph
provides a number of built-in channels:
LastValue: The default channel, stores the last value sent to the channel,
useful for input and output values, or for sending data from one step to the nextTopic: A configurable PubSub Topic, useful for sending multiple values
between actors, or for accumulating output. Can be configured to deduplicate
values, and/or to accumulate values over the course of multiple steps.Context: exposes the value of a context manager, managing its lifecycle.
Useful for accessing external resources that require setup and/or teardown. e.g.
client = Context(httpx.Client)BinaryOperatorAggregate: stores a persistent value, updated by applying
a binary operator to the current value and each update
sent to the channel, useful for computing aggregates over multiple steps. e.g.
total = BinaryOperatorAggregate(int, operator.add)Most users will interact with Pregel via a StateGraph (Graph API) or via an entrypoint (Functional API).
However, for advanced use cases, Pregel can be used directly. If you're not sure whether you need to use Pregel directly, then the answer is probably no
Here are some examples to give you a sense of how it works:
Implements the logic for reading state from CONFIG_KEY_READ. Usable both as a runnable as well as a static method to call imperatively.
A node in a Pregel graph. This won't be invoked as a runnable by the graph itself, but instead acts as a container for the components necessary to make a PregelExecutableTask for a node.
Implements the logic for sending writes to CONFIG_KEY_SEND. Can be used as a runnable or as a static method to call imperatively.
Configuration for caching nodes.
One or more commands to update the graph's state and send messages to nodes.
Configuration for retrying nodes.
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
dynamically invoke a node with a custom state at the next step.
Importantly, the sent state can differ from the core graph's state, allowing for flexible and dynamic workflow management.
One such example is a "map-reduce" workflow where your graph invokes the same node multiple times in parallel with different states, before aggregating the results back into the main graph's state.
Configuration for timing out node attempts.
Timeouts rely on asyncio cancellation. If your node uses synchronous time.sleep() or other CPU-bound work that blocks the GIL, the timeout will not be fired until after the event loop has been released.
Under refresh_on="auto", an internal handler refreshes the timeout on any
callback event that occurs in the execution of the node or its nested descendants.
A specific LangGraphDeprecationWarning subclass defining functionality deprecated since LangGraph v0.5.0
A specific LangGraphDeprecationWarning subclass defining functionality deprecated since LangGraph v1.0.0
A graph whose nodes communicate by reading and writing to a shared state.
The signature of each node is State -> Partial<State>.
Each state key can optionally be annotated with a reducer function that
will be used to aggregate the values of that key received from multiple nodes.
The signature of a reducer function is (Value, Value) -> Value.
StateGraph is a builder class and cannot be used directly for execution.
You must first call .compile() to create an executable graph that supports
methods like invoke(), stream(), astream(), and ainvoke(). See the
CompiledStateGraph documentation for more details.
Type of the checkpointer to use for a subgraph.
True enables persistent checkpointing for this subgraph.False disables checkpointing, even if the parent graph has a checkpointer.None inherits checkpointer from the parent graph.Stores the result of applying a binary operator to the current value and each new value.
import operator
total = Channels.BinaryOperatorAggregate(int, operator.add)