To help you ship LangGraph apps to production faster, check out LangSmith. LangSmith is a unified developer platform for building, testing, and monitoring LLM applications.
uv add langgraph-checkpointThis library defines the base interface for LangGraph checkpointers. Checkpointers provide a persistence layer for LangGraph: they save graph state at every superstep, enabling human-in-the-loop, memory between interactions, durable execution, and more.
For full documentation, see the API reference. For conceptual guides on persistence and memory, see the LangGraph Docs.
Checkpoint is a snapshot of the graph state at a given point in time. Checkpoint tuple refers to an object containing checkpoint and the associated config, metadata and pending writes.
Threads enable the checkpointing of multiple different runs, making them essential for multi-tenant chat applications and other scenarios where maintaining separate states is necessary. A thread is a unique ID assigned to a series of checkpoints saved by a checkpointer. When using a checkpointer, you must specify a thread_id and optionally checkpoint_id when running the graph.
thread_id is simply the ID of a thread. This is always required.checkpoint_id can optionally be passed. This identifier refers to a specific checkpoint within a thread. This can be used to kick off a run of a graph from some point halfway through a thread.You must pass these when invoking the graph as part of the configurable part of the config, e.g.
{"configurable": {"thread_id": "1"}} # valid config
{"configurable": {"thread_id": "1", "checkpoint_id": "0c62ca34-ac19-445d-bbb0-5b4984975b2a"}} # also valid configlanggraph-checkpoint also defines protocol for serialization/deserialization (serde) and provides a default implementation (langgraph.checkpoint.serde.jsonplus.JsonPlusSerializer) that handles a wide variety of types, including LangChain and LangGraph primitives, datetimes, enums and more.
[!IMPORTANT] Checkpoint deserialization security: By default the serializer allows any Python type found in checkpoint data. New applications should set the environment variable
LANGGRAPH_STRICT_MSGPACK=trueor pass an explicitallowed_msgpack_moduleslist toJsonPlusSerializerto restrict deserialization to known-safe types.
When a graph node fails mid-execution at a given superstep, LangGraph stores pending checkpoint writes from any other nodes that completed successfully at that superstep, so that whenever we resume graph execution from that superstep we don't re-run the successful nodes.
Each checkpointer should conform to langgraph.checkpoint.base.BaseCheckpointSaver interface and must implement the following methods:
.put - Store a checkpoint with its configuration and metadata..put_writes - Store intermediate writes linked to a checkpoint (i.e. pending writes)..get_tuple - Fetch a checkpoint tuple using for a given configuration (thread_id and checkpoint_id)..list - List checkpoints that match a given configuration and filter criteria..delete_thread() - Delete all checkpoints and writes associated with a thread..get_next_version() - Generate the next version ID for a channel.If the checkpointer will be used with asynchronous graph execution (i.e. executing the graph via .ainvoke, .astream, .abatch), checkpointer must implement asynchronous versions of the above methods (.aput, .aput_writes, .aget_tuple, .alist). Similarly, the checkpointer must implement .adelete_thread() if asynchronous thread cleanup is desired. The base class provides a default implementation of .get_next_version() that generates an integer sequence starting from 1, but this method should be overridden for custom versioning schemes.
from langgraph.checkpoint.memory import InMemorySaver
write_config = {"configurable": {"thread_id": "1", "checkpoint_ns": ""}}
read_config = {"configurable": {"thread_id": "1"}}
checkpointer = InMemorySaver()
checkpoint = {
"v": 4,
"ts": "2024-07-31T2019.804150+00:00",
"id": "1ef4f797-8335-6428-8001-8a1503f9b875",
"channel_values": {
"my_key": "meow",
"node": "node"
},
"channel_versions": {
"__start__": 2,
"my_key": 3,
"start:node": 3,
"node": 3
},
"versions_seen": {
"__input__": {},
"__start__": {
"__start__": 1
},
"node": {
"start:node": 2
}
},
}
# store checkpoint
checkpointer.put(write_config, checkpoint, {}, {})
# load checkpoint
checkpointer.get(read_config)
# list checkpoints
list(checkpointer.list(read_config))See our Releases and Versioning policies.
As an open-source project in a rapidly developing field, we are extremely open to contributions, whether it be in the form of a new feature, improved infrastructure, or better documentation.
For detailed information on how to contribute, see the Contributing Guide.
Sentinel singleton.
Represents a stored item with metadata.
Represents an item returned from a search operation with additional metadata.
Operation to retrieve a specific item by its namespace and key.
This operation allows precise retrieval of stored items using their full path (namespace) and unique identifier (key) combination.
???
Operation to search for items within a specified namespace hierarchy.
This operation supports both structured filtering and natural language search within a given namespace prefix. It provides pagina
Represents a pattern for matching namespaces in the store.
This class combines a match type (prefix or suffix) with a namespace path pattern that can include wildcards to flexibly match different nam
Operation to list and filter namespaces in the store.
This operation allows exploring the organization of data, finding specific collections, and navigating the namespace hierarchy.
"Ex
Operation to store, update, or delete an item in the store.
This class represents a single operation to modify the store's contents, whether adding new items, updating existing ones, or removing them
Provided namespace is invalid.
Configuration for TTL (time-to-live) behavior in the store.
Configuration for indexing documents for semantic search in the store.
If not provided to the store, the store will not support vector search.
In that case, all index arguments to put() and `aput
Abstract base class for persistent key-value stores.
Stores enable persistence and memory that can be shared across threads, scoped to user IDs, assistant IDs, or other arbitrary namespaces. Some imp
Wrapper to convert embedding functions into LangChain's Embeddings interface.
This class allows arbitrary embedding functions to be used with LangChain-compatible tools. It supports both synchronous
Efficiently batch operations in a background task.
In-memory dictionary-backed store with optional vector search.
Basic key-value storage: store = InMemoryStore() store.put(("users", "123"), "prefs", {"theme
Ensure that an embedding function conforms to LangChain's Embeddings interface.
This function wraps arbitrary embedding functions to make them compatible with LangChain's Embeddings interface. It han
Extract text from an object using a path expression or pre-tokenized path.
Tokenize a path into components.