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

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

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

A tuple containing a checkpoint and its associated data.

A node that runs the tools called in the last AIMessage. It can be used either in StateGraph with a "messages" key or in MessageGraph. If mul

A KV store backed by an in-memory python dictionary. Useful for testing/experimentation and lightweight PoC's. For actual persistence, use a

Raised when attempting to update a channel with an invalid set of updates.

Operation to store, update, or delete an item.

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

r"""UUID draft version objects

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

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

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

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

Operation to retrieve an item by namespace and key.

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

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

Configuration for retrying nodes.

Operation to search for items within a namespace prefix.

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

Operation to list namespaces with optional match conditions.

Represents a stored item with metadata. Args: value (dict[str, Any]): The stored data as a dictionary. Keys are filterable. (str)

A context manager that runs sync tasks in the background. Uses a thread pool executor to delegate tasks to separate threads. On exit, - ca

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

A StateGraph where every node receives a list of messages as input and returns one or more messages as output. MessageGraph is a subclass of Stat

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

Responsible for executing a set of Pregel tasks concurrently, committing their writes, yielding control to caller when there is output to emit, an

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

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

A simpler version of RunnableSequence.

State snapshot at a given point in time.

Annotation for a Tool arg that is meant to be populated with the graph state. Any Tool argument annotated with InjectedState will be hidden from

Annotation for a Tool arg that is meant to be populated with LangGraph store. Any Tool argument annotated with InjectedStore will be hidden from

Raised by a node to interrupt execution.

A context manager that runs async tasks in the background. Uses the current event loop to delegate tasks to asyncio tasks. On exit, - canc

Raised when the checkpoint is not the latest version (for distributed mode).

Raised when a graph is delegated (for distributed mode).

Raised when the graph has exhausted the maximum number of steps. This prevents infinite loops. To increase the maximum number of steps, run y

Represents a single match condition.

This custom checkpointer is for verifying that a run's configurable fields are merged with the previous checkpoint config for each step in the

A callback handler that implements stream_mode=messages. Collects messages from (1) chat model stream events and (2) node outputs.

Represents a part of a stream response.

Raised when the executor is unable to find a task (for distributed mode).

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

Async unbounded FIFO queue with a wait() method. Subclassed from asyncio.Queue, adding a wait() method.

An asynchronous checkpoint saver that stores checkpoints in a SQLite database. This class provides an asynchronous interface for saving and retri