first pass at data storage docs

* docs: fix assistants links

* fix another page

.github/dependabot.yml

@@ -1,11 +0,0 @@
-# Please see the documentation for all configuration options:
-# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
-# and
-# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
-
-version: 2
-updates:
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "weekly"

.github/workflows/_lint.yml

@@ -49,7 +49,7 @@ jobs:
 
       - name: Get .mypy_cache to speed up mypy
         if: steps.changed-files.outputs.all
-        uses: actions/cache@v4
+        uses: actions/cache@v3
         env:
           SEGMENT_DOWNLOAD_TIMEOUT_MIN: "2"
         with:
@@ -75,7 +75,7 @@ jobs:
 
       - name: Get .mypy_cache_test to speed up mypy
         if: steps.changed-files.outputs.all
-        uses: actions/cache@v4
+        uses: actions/cache@v3
         env:
           SEGMENT_DOWNLOAD_TIMEOUT_MIN: "2"
         with:

.github/workflows/_test_release.yml

@@ -13,7 +13,7 @@ env:
 
 jobs:
   build:
-    if: github.ref == 'refs/heads/main'
+    if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/v0'
     runs-on: ubuntu-latest
 
     outputs:

.github/workflows/_test_scheduler_kafka.yml

@@ -0,0 +1,52 @@
+name: test
+
+on:
+  workflow_call:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version:
+          - "3.11"
+          - "3.12"
+
+    defaults:
+      run:
+        working-directory: libs/scheduler-kafka
+    name: "test #${{ matrix.python-version }}"
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: astral-sh/setup-uv@v6
+        with:
+          python-version: ${{ matrix.python-version }}
+          enable-cache: true
+          cache-suffix: "test-scheduler-kafka"
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        if: ${{ !github.event.pull_request.head.repo.fork }}
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_RO_TOKEN }}
+
+      - name: Install dependencies
+        shell: bash
+        run: uv sync --frozen --group dev
+
+      - name: Run tests
+        shell: bash
+        run: make test
+
+      - name: Ensure the tests did not create any additional files
+        shell: bash
+        run: |
+          set -eu
+
+          STATUS="$(git status)"
+          echo "$STATUS"
+
+          # grep will exit non-zero if the target message isn't found,
+          # and `set -e` above will cause the step to fail.
+          echo "$STATUS" | grep 'nothing to commit, working tree clean'

.github/workflows/ci.yml

@@ -35,6 +35,7 @@ jobs:
               - 'libs/checkpoint/**'
               - 'libs/checkpoint-sqlite/**'
               - 'libs/checkpoint-postgres/**'
+              - 'libs/scheduler-kafka/**'
               - 'libs/prebuilt/**'
             sdk-js:
               - 'libs/sdk-js/**'
@@ -52,7 +53,7 @@ jobs:
             "libs/checkpoint",
             "libs/checkpoint-sqlite",
             "libs/checkpoint-postgres",
-
+            "libs/scheduler-kafka",
             "libs/prebuilt",
           ]
     if: needs.changes.outputs.python == 'true'
@@ -88,6 +89,14 @@ jobs:
     uses: ./.github/workflows/_test_langgraph.yml
     secrets: inherit
 
+  # NOTE: we're testing scheduler-kafka separately because it requires a different matrix
+  test-scheduler-kafka:
+    needs: changes
+    if: needs.changes.outputs.python == 'true'
+    name: "cd libs/scheduler-kafka"
+    uses: ./.github/workflows/_test_scheduler_kafka.yml
+    secrets: inherit
+
   check-sdk-methods:
     needs: changes
     if: needs.changes.outputs.python == 'true'
@@ -157,9 +166,9 @@ jobs:
       run:
         working-directory: ${{ matrix.working-directory }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
       - name: Setup Node.js (LTS)
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v3
         with:
           node-version: "20"
           cache: "yarn"
@@ -183,9 +192,9 @@ jobs:
       run:
         working-directory: ${{ matrix.working-directory }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
       - name: Setup Node.js (LTS)
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v3
         with:
           node-version: "20"
           cache: "yarn"
@@ -203,6 +212,7 @@ jobs:
         lint-js,
         test,
         test-langgraph,
+        test-scheduler-kafka,
         check-sdk-methods,
         check-schema,
         integration-test,

.github/workflows/release.yml

@@ -13,7 +13,7 @@ env:
 
 jobs:
   build:
-    if: github.ref == 'refs/heads/main'
+    if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/v0'
     runs-on: ubuntu-latest
 
     outputs:

.github/workflows/release_js.yml

@@ -22,7 +22,7 @@ jobs:
       - uses: actions/checkout@v4
       # JS Build
       - name: Use Node.js
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v3
         with:
           node-version: "20"
           cache: "yarn"

.gitignore

@@ -181,4 +181,3 @@ Chinook.db
 .vercel
 .turbo
 .editorconfig
-.scratch

CONTRIBUTING.md

@@ -109,7 +109,7 @@ Here are some high-level tips on writing a good how-to guide:
 LangGraph's conceptual guides fall under the **Explanation** quadrant of Diataxis. They should cover LangChain terms and concepts
 in a more abstract way than how-to guides or tutorials, and should be geared towards curious users interested in
 gaining a deeper understanding of the framework. Try to avoid excessively large code examples. The goal here is to
-impart perspective to the user rather than to finish a practical project. These guides should cover **why** things work the way they do.
+impart perspective to the user rather than to finish a practical project. These guides should cover **why** things work they way they do.
 
 
 To quote the Diataxis website:

docs/docs/agents/mcp.md

@@ -38,7 +38,7 @@ client = MultiServerMCPClient(
             "transport": "stdio",
         },
         "weather": {
-            # Ensure you start your weather server on port 8000
+            # Ensure your start your weather server on port 8000
             "url": "http://localhost:8000/mcp",
             "transport": "streamable_http",
         }

docs/docs/agents/memory.md

@@ -88,7 +88,7 @@ ny_response = agent.invoke(
 
 When the agent is invoked the second time with the same `thread_id`, the original message history from the first conversation is automatically included, allowing the agent to infer that the user is asking specifically about the **weather** in New York.
 
-!!! Note "LangGraph Platform provides a production-ready checkpointer"
+!!! Note "LangGraph Platform providers a production-ready checkpointer"
 
     If you're using [LangGraph Platform](./deployment.md), during deployment your checkpointer will be automatically configured to use a production-ready database.
 

docs/docs/agents/multi-agent.md

@@ -9,7 +9,7 @@ hide:
 
 # Multi-agent
 
-A single agent might struggle if it needs to specialize in multiple domains or manage many tools. To tackle this, you can break your agent into smaller, independent agents and compose them into a [multi-agent system](../concepts/multi_agent.md).
+A single agent might struggle if it needs to specialize in multiple domains or manage many tools. To tackle this, you can break your agent into smaller, independent agents and composing them into a [multi-agent system](../concepts/multi_agent.md).
 
 In multi-agent systems, agents need to communicate between each other. They do so via [handoffs](#handoffs) — a primitive that describes which agent to hand control to and the payload to send to that agent.
 

docs/docs/cloud/deployment/cloud.md

@@ -62,6 +62,15 @@ Starting from the `LangGraph Platform` view...
 1. In the panel, select the `Server` tab to view server logs for the revision. Server logs are only available after a revision has been deployed.
 1. Within the `Server` tab, adjust the date/time range picker as needed. By default, the date/time range picker is set to the `Last 7 days`.
 
+## View Deployment Metrics
+
+Starting from the <a href="https://smith.langchain.com/" target="_blank">LangSmith UI</a>...
+
+1. In the left-hand navigation panel, select `LangGraph Platform`. The `LangGraph Platform` view contains a list of existing LangGraph Platform deployments.
+1. Select an existing deployment to monitor.
+1. Select the `Monitoring` tab to view the deployment metrics. See a list of [all available metrics](../../concepts/langgraph_control_plane.md#monitoring).
+1. Within the `Monitoring` tab, use the date/time range picker as needed. By default, the date/time range picker is set to the `Last 15 minutes`.
+
 ## Interrupt Revision
 
 Interrupting a revision will stop deployment of the revision.

docs/docs/cloud/deployment/custom_docker.md

@@ -16,4 +16,4 @@ Users can add an array of additional lines to add to the Dockerfile following th
 }
 ```
 
-This would install the system packages required to use Pillow if we were working with `jpeg` or `png` image formats. 
+This would install the system packages required to use Pillow if we were working with `jpeq` or `png` image formats. 

docs/docs/cloud/deployment/graph_rebuild.md

@@ -20,7 +20,7 @@ my-app/
 |-- openai_agent.py     # code for your graph
 ```
 
-where the graph is defined in `openai_agent.py`.
+where the graph is defined in `openai_agent.py`. 
 
 ### No rebuild
 
@@ -28,11 +28,11 @@ In the standard LangGraph API configuration, the server uses the compiled graph
 
 ```python
 from langchain_openai import ChatOpenAI
-from langgraph.graph import END, START, StateGraph, MessagesState
+from langgraph.graph import END, START, MessageGraph
 
 model = ChatOpenAI(temperature=0)
 
-graph_workflow = StateGraph(MessagesState)
+graph_workflow = MessageGraph()
 
 graph_workflow.add_node("agent", model)
 graph_workflow.add_edge("agent", END)
@@ -61,7 +61,7 @@ To make your graph rebuild on each new run with custom configuration, you need t
 from typing import Annotated
 from typing_extensions import TypedDict
 from langchain_openai import ChatOpenAI
-from langgraph.graph import END, START
+from langgraph.graph import END, START, MessageGraph
 from langgraph.graph.state import StateGraph
 from langgraph.graph.message import add_messages
 from langgraph.prebuilt import ToolNode
@@ -144,4 +144,4 @@ Finally, you need to specify the path to your graph-making function (`make_graph
 }
 ```
 
-See more info on LangGraph API configuration file [here](../reference/cli.md#configuration-file)
+See more info on LangGraph API configuration file [here](../reference/cli.md#configuration-file)

docs/docs/cloud/deployment/self_hosted_control_plane.md

@@ -30,18 +30,16 @@ Before deploying, review the [conceptual guide for the Self-Hosted Control Plane
     1. `LangGraphPlatform CRD`: A CRD for LangGraph Platform deployments. This contains the spec for managing an instance of a LangGraph platform deployment.
     1. `operator`: This operator handles changes to your LangGraph Platform CRDs.
     1. `host-backend`: This is the [control plane](../../concepts/langgraph_control_plane.md).
-1. Two additional images will be used by the chart.
+1. Two additional images will be used by the chart. Use the images that are specified in the latest release.
 
         hostBackendImage:
           repository: "docker.io/langchain/hosted-langserve-backend"
           pullPolicy: IfNotPresent
-          tag: "0.9.80"
         operatorImage:
           repository: "docker.io/langchain/langgraph-operator"
           pullPolicy: IfNotPresent
-          tag: "aa9dff4"
 
-1. In your `langsmith_config.yaml` file, enable the `langgraphPlatform` option. Note that you must also have a valid ingress setup:
+1. In your config file for langsmith (usually `langsmith_config.yaml`, enable the `langgraphPlatform` option. Note that you must also have a valid ingress setup:
 
         config:
           langgraphPlatform:

docs/docs/cloud/deployment/setup.md

@@ -95,7 +95,7 @@ my-app/
 
 ## Define Graphs
 
-Implement your graphs! Graphs can be defined in a single file or multiple files. Make note of the variable names of each [CompiledStateGraph][langgraph.graph.state.CompiledStateGraph] to be included in the LangGraph application. The variable names will be used later when creating the [LangGraph configuration file](../reference/cli.md#configuration-file).
+Implement your graphs! Graphs can be defined in a single file or multiple files. Make note of the variable names of each [CompiledGraph][langgraph.graph.graph.CompiledGraph] to be included in the LangGraph application. The variable names will be used later when creating the [LangGraph configuration file](../reference/cli.md#configuration-file).
 
 Example `agent.py` file, which shows how to import from other modules you define (code for the modules is not shown here, please see [this repository](https://github.com/langchain-ai/langgraph-example) to see their implementation):
 

docs/docs/cloud/deployment/setup_pyproject.md

@@ -108,7 +108,7 @@ my-app/
 
 ## Define Graphs
 
-Implement your graphs! Graphs can be defined in a single file or multiple files. Make note of the variable names of each [CompiledStateGraph][langgraph.graph.state.CompiledStateGraph] to be included in the LangGraph application. The variable names will be used later when creating the [LangGraph configuration file](../reference/cli.md#configuration-file).
+Implement your graphs! Graphs can be defined in a single file or multiple files. Make note of the variable names of each [CompiledGraph][langgraph.graph.graph.CompiledGraph] to be included in the LangGraph application. The variable names will be used later when creating the [LangGraph configuration file](../reference/cli.md#configuration-file).
 
 Example `agent.py` file, which shows how to import from other modules you define (code for the modules is not shown here, please see [this repository](https://github.com/langchain-ai/langgraph-example-pyproject) to see their implementation):
 

docs/docs/cloud/how-tos/studio/manage_assistants.md

@@ -2,7 +2,7 @@
 
 !!! info "Prerequisites"
 
-    - [Assistants Overview](../../concepts/assistants.md)
+    - [Assistants Overview](../../../concepts/assistants.md)
 
 LangGraph Studio lets you view, edit, and update your assistants, and allows you to run your graph using these assistant configurations.
 

docs/docs/cloud/how-tos/studio/run_evals.md

@@ -0,0 +1,57 @@
+# Run experiments over a dataset
+
+LangGraph Studio supports evaluations by allowing you to run your assistant over a pre-defined LangSmith dataset. This enables you to understand how your application performs over a variety of inputs, compare the results to reference outputs, and score the results using [evaluators](../../../agents/evals.md).
+
+This guide shows you how to run an experiment end-to-end from Studio.
+
+---
+
+## Prerequisites
+
+Before running an experiment, ensure you have the following:
+
+1.  **A LangSmith dataset**: Your dataset should contain the inputs you want to test and optionally, reference outputs for comparison.
+
+    - The schema for the inputs must match the required input schema for the assistant. For more information on schemas, see [here](../../../concepts/low_level.md#schema).
+    - For more on creating datasets, see [How to Manage Datasets](https://docs.smith.langchain.com/evaluation/how_to_guides/manage_datasets_in_application#set-up-your-dataset).
+
+2.  **(Optional) Evaluators**: You can attach evaluators (e.g., LLM-as-a-Judge, heuristics, or custom functions) to your dataset in LangSmith. These will run automatically after the graph has processed all inputs.
+
+    - To learn more, read about [Evaluation Concepts](https://docs.smith.langchain.com/evaluation/concepts#evaluators).
+
+3.  **A running application**: The experiment can be run against:
+    - An application deployed on [LangGraph Platform](../../quick_start.md).
+    - A locally running application started via the [langgraph-cli](../../../tutorials/langgraph-platform/local-server.md).
+
+---
+
+## Step-by-step guide
+
+### 1. Launch the experiment
+
+Click the **Run experiment** button in the top right corner of the Studio page.
+
+### 2. Select your dataset
+
+In the modal that appears, select the dataset (or a specific dataset split) to use for the experiment and click **Start**.
+
+### 3. Monitor the progress
+
+All of the inputs in the dataset will now be run against the active assistant. Monitor the experiment's progress via the badge in the top right corner.
+
+You can continue to work in Studio while the experiment runs in the background. Click the arrow icon button at any time to navigate to LangSmith and view the detailed experiment results.
+
+---
+
+## Troubleshooting
+
+### "Run experiment" button is disabled
+
+If the "Run experiment" button is disabled, check the following:
+
+- **Deployed application**: If your application is deployed on LangGraph Platform, you may need to create a new revision to enable this feature.
+- **Local development server**: If you are running your application locally, make sure you have upgraded to the latest version of the `langgraph-cli` (`pip install -U langgraph-cli`). Additionally, ensure you have tracing enabled by setting the `LANGSMITH_API_KEY` in your project's `.env` file.
+
+### Evaluator results are missing
+
+When you run an experiment, any attached evaluators are scheduled for execution in a queue. If you don't see results immediately, it likely means they are still pending.

docs/docs/cloud/how-tos/use_stream_react.md

@@ -1,8 +1,8 @@
-How to integrate LangGraph into your React application# How to integrate LangGraph into your React application
+# How to integrate LangGraph into your React application
 
-!!! info "Prerequisites"
+!!! info "Prerequisites" 
 
-    - [LangGraph Platform](../../concepts/langgraph_platform.md)
+    - [LangGraph Platform](../../concepts/langgraph_platform.md) 
     - [LangGraph Server](../../concepts/langgraph_server.md)
 
 The `useStream()` React hook provides a seamless way to integrate LangGraph into your React applications. It handles all the complexities of streaming, state management, and branching logic, letting you focus on building great chat experiences.
@@ -113,115 +113,6 @@ export default function App() {
 }
 ```
 
-### Resume a stream after page refresh
-
-The `useStream()` hook can automatically resume an ongoing run upon mounting by setting `reconnectOnMount: true`. This is useful for continuing a stream after a page refresh, ensuring no messages and events generated during the downtime are lost.
-
-```tsx
-const thread = useStream<{ messages: Message[] }>({
-  apiUrl: "http://localhost:2024",
-  assistantId: "agent",
-  reconnectOnMount: true,
-});
-```
-
-By default the ID of the created run is stored in `window.sessionStorage`, which can be swapped by passing a custom storage in `reconnectOnMount` instead. The storage is used to persist the in-flight run ID for a thread (under `lg:stream:${threadId}` key).
-
-```tsx
-const thread = useStream<{ messages: Message[] }>({
-  apiUrl: "http://localhost:2024",
-  assistantId: "agent",
-  reconnectOnMount: () => window.localStorage,
-});
-```
-
-You can also manually manage the resuming process by using the run callbacks to persist the run metadata and the `joinStream` function to resume the stream. Make sure to pass `streamResumable: true` when creating the run; otherwise some events might be lost.
-
-````tsx
-import type { Message } from "@langchain/langgraph-sdk";
-import { useStream } from "@langchain/langgraph-sdk/react";
-import { useCallback, useState, useEffect, useRef } from "react";
-
-export default function App() {
-  const [threadId, onThreadId] = useSearchParam("threadId");
-
-  const thread = useStream<{ messages: Message[] }>({
-    apiUrl: "http://localhost:2024",
-    assistantId: "agent",
-
-    threadId,
-    onThreadId,
-
-    onCreated: (run) => {
-      window.sessionStorage.setItem(`resume:${run.thread_id}`, run.run_id);
-    },
-    onFinish: (_, run) => {
-      window.sessionStorage.removeItem(`resume:${run?.thread_id}`);
-    },
-  });
-
-  // Ensure that we only join the stream once per thread.
-  const joinedThreadId = useRef<string | null>(null);
-  useEffect(() => {
-    if (!threadId) return;
-
-    const resume = window.sessionStorage.getItem(`resume:${threadId}`);
-    if (resume && joinedThreadId.current !== threadId) {
-      thread.joinStream(resume);
-      joinedThreadId.current = threadId;
-    }
-  }, [threadId]);
-
-  return (
-    <form
-      onSubmit={(e) => {
-        e.preventDefault();
-        const form = e.target as HTMLFormElement;
-        const message = new FormData(form).get("message") as string;
-        thread.submit(
-          { messages: [{ type: "human", content: message }] },
-          { streamResumable: true }
-        );
-      }}
-    >
-      <div>
-        {thread.messages.map((message) => (
-          <div key={message.id}>{message.content as string}</div>
-        ))}
-      </div>
-      <input type="text" name="message" />
-      <button type="submit">Send</button>
-    </form>
-  );
-}
-
-// Utility method to retrieve and persist data in URL as search param
-function useSearchParam(key: string) {
-  const [value, setValue] = useState<string | null>(() => {
-    const params = new URLSearchParams(window.location.search);
-    return params.get(key) ?? null;
-  });
-
-  const update = useCallback(
-    (value: string | null) => {
-      setValue(value);
-
-      const url = new URL(window.location.href);
-      if (value == null) {
-        url.searchParams.delete(key);
-      } else {
-        url.searchParams.set(key, value);
-      }
-
-      window.history.pushState({}, "", url.toString());
-    },
-    [key]
-  );
-
-  return [value, update] as const;
-}
-```
-
 ### Thread Management
 
 Keep track of conversations with built-in thread management. You can access the current thread ID and get notified when new threads are created:
@@ -236,7 +127,7 @@ const thread = useStream<{ messages: Message[] }>({
   threadId: threadId,
   onThreadId: setThreadId,
 });
-````
+```
 
 We recommend storing the `threadId` in your URL's query parameters to let users resume conversations after page refreshes.
 

docs/docs/cloud/reference/cli.md

@@ -43,6 +43,7 @@ The LangGraph CLI requires a JSON configuration file that follows this [schema](
     | <span style="white-space: nowrap;">`graphs`</span>           | **Required**. Mapping from graph ID to path where the compiled graph or a function that makes a graph is defined. Example: <ul><li>`./your_package/your_file.py:variable`, where `variable` is an instance of `langgraph.graph.state.CompiledStateGraph`</li><li>`./your_package/your_file.py:make_graph`, where `make_graph` is a function that takes a config dictionary (`langchain_core.runnables.RunnableConfig`) and returns an instance of `langgraph.graph.state.StateGraph` or `langgraph.graph.state.CompiledStateGraph`. See [how to rebuild a graph at runtime](../../cloud/deployment/graph_rebuild.md) for more details.</li></ul>                                    |
     | <span style="white-space: nowrap;">`auth`</span>             | _(Added in v0.0.11)_ Auth configuration containing the path to your authentication handler. Example: `./your_package/auth.py:auth`, where `auth` is an instance of `langgraph_sdk.Auth`. See [authentication guide](../../concepts/auth.md) for details.                                                                                                                                                                                                                                                                                                                        |
     | <span style="white-space: nowrap;">`base_image`</span>       | Optional. Base image to use for the LangGraph API server. Defaults to `langchain/langgraph-api` or `langchain/langgraphjs-api`. Use this to pin your builds to a particular version of the langgraph API, such as `"langchain/langgraph-server:0.2"`. See https://hub.docker.com/r/langchain/langgraph-server/tags for more details. (added in `langgraph-cli==0.2.8`) |
+    | <span style="white-space: nowrap;">`image_distro`</span>     | Optional. Linux distribution for the base image. Must be either `"debian"` or `"wolfi"`. If omitted, defaults to `"debian"`. Available in `langgraph-cli>=0.2.11`.|
     | <span style="white-space: nowrap;">`env`</span>              | Path to `.env` file or a mapping from environment variable to its value.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
     | <span style="white-space: nowrap;">`store`</span>            | Configuration for adding semantic search and/or time-to-live (TTL) to the BaseStore. Contains the following fields: <ul><li>`index` (optional): Configuration for semantic search indexing with fields `embed`, `dims`, and optional `fields`.</li><li>`ttl` (optional): Configuration for item expiration. An object with optional fields: `refresh_on_read` (boolean, defaults to `true`), `default_ttl` (float, lifespan in **minutes**, defaults to no expiration), and `sweep_interval_minutes` (integer, how often to check for expired items, defaults to no sweeping).</li></ul> |
     | <span style="white-space: nowrap;">`ui`</span>               | Optional. Named definitions of UI components emitted by the agent, each pointing to a JS/TS file. (added in `langgraph-cli==0.1.84`)                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
@@ -79,6 +80,20 @@ The LangGraph CLI requires a JSON configuration file that follows this [schema](
     }
     ```
 
+    #### Using Wolfi Base Images
+
+    You can specify the Linux distribution for your base image using the `image_distro` field. Valid options are `debian` or `wolfi`. Wolfi is the recommended option as it provides smaller and more secure images. This is available in `langgraph-cli>=0.2.11`.
+
+    ```json
+    {
+      "dependencies": ["."],
+      "graphs": {
+        "chat": "./chat/graph.py:graph"
+      },
+      "image_distro": "wolfi"
+    }
+    ```
+
     #### Adding semantic search to the store
 
     All deployments come with a DB-backed BaseStore. Adding an "index" configuration to your `langgraph.json` will enable [semantic search](../deployment/semantic_search.md) within the BaseStore of your deployment.

docs/docs/cloud/reference/env_var.md

@@ -123,3 +123,12 @@ Defaults to `''`.
 Set `REDIS_CLUSTER` to `True` to enable Redis Cluster mode. When enabled, the system will connect to Redis using cluster mode. This is useful when connecting to a Redis Cluster deployment.
 
 Defaults to `False`.
+
+## `MOUNT_PREFIX`
+
+!!! info "Only Allowed in Self-Hosted Deployments"
+    The `MOUNT_PREFIX` environment variable is only allowed in Self-Hosted Deployment models, LangGraph Platform SaaS will not allow this environment variable.
+
+Set `MOUNT_PREFIX` to serve the LangGraph Server under a specific path prefix. This is useful for deployments where the server is behind a reverse proxy or load balancer that requires a specific path prefix.
+
+For example, if the server is to be served under `https://example.com/langgraph`, set `MOUNT_PREFIX` to `/langgraph`.

docs/docs/concepts/application_structure.md

@@ -32,7 +32,7 @@ Below are examples of directory structures for Python and JavaScript application
     │   ├── utils # utilities for your graph
     │   │   ├── __init__.py
     │   │   ├── tools.py # tools for your graph
-    │   │   ├── nodes.py # node functions for your graph
+    │   │   ├── nodes.py # node functions for you graph
     │   │   └── state.py # state definition of your graph
     │   ├── __init__.py
     │   └── agent.py # code for constructing your graph

docs/docs/concepts/assistants.md

@@ -26,4 +26,4 @@ Once you've created an assistant, subsequent edits to that assistant will create
 
 ## Learn more
 
-* The LangGraph Cloud API provides several endpoints for creating and managing assistants and their versions. See the [API reference](../cloud/reference/api/api_ref.html#tag/assistants) for more details.
+* The LangGraph Cloud API provides several endpoints for creating and managing assistants their versions. See the [API reference](../cloud/reference/api/api_ref.html#tag/assistants) for more details.

docs/docs/concepts/data_storage_and_privacy.md

@@ -0,0 +1,127 @@
+# Data Storage and Privacy
+
+This document provides a comprehensive overview of what data is stored, collected, and processed when using LangGraph, particularly with the CLI tools like `langgraph dev`.
+
+## What Data is Stored
+
+### CLI Telemetry (Opt-out)
+
+By default, the LangGraph CLI collects minimal analytics data to help improve the tool:
+
+**Data Collected:**
+- CLI command used (e.g., `dev`, `up`, `build`)
+- CLI version
+- Operating system type and version
+- Python version
+- Anonymized parameter usage (boolean flags indicating non-default options were used)
+
+**Data NOT Collected:**
+- Actual parameter values
+- File contents or paths
+- Personal information
+- Code or graph implementations
+- API keys or sensitive data
+
+**How to Opt Out:**
+Set the environment variable `LANGGRAPH_CLI_NO_ANALYTICS=1` to disable all CLI analytics collection.
+
+### LangSmith Integration (Opt-in)
+
+When a `LANGSMITH_API_KEY` is provided (not required):
+- Metadata on number of runs executed
+- Current API version being run
+- Trace data (if tracing is enabled)
+
+This data is only sent when explicitly configured with LangSmith credentials.
+
+### Tracing Data (Opt-in)
+
+When tracing is enabled:
+- Execution traces are logged to the configured tracing backend
+- This requires explicit configuration and is not enabled by default
+
+## What Data is NOT Stored Remotely
+
+- **Checkpoints**: Stored locally in your development environment
+- **Memory store data**: Persisted locally, not transmitted
+- **Graph state**: Remains in your local environment
+- **Application data**: Your actual application logic and data stay local
+
+## Local Data Storage
+
+### Development Mode (`langgraph dev`)
+
+When using `langgraph dev`:
+- State is persisted to a local directory
+- Checkpoints are stored locally for debugging and development
+- No remote storage or transmission of your application data
+
+### Checkpoints and State Persistence
+
+LangGraph automatically persists:
+- **Checkpoints**: Snapshots of graph state at each execution step
+- **Thread data**: Conversation/execution history organized by thread IDs
+- **Graph state**: Node outputs, intermediate results, and execution metadata
+- **Memory/Store data**: Information that persists across multiple threads
+
+**Storage Locations:**
+- **Local development**: Local directory (configurable)
+- **Docker deployment**: Local Docker volumes
+- **LangGraph Platform**: Managed database infrastructure
+
+## Security and Encryption
+
+### Data Encryption
+
+- Checkpointers can optionally encrypt all persisted state
+- Encryption uses AES encryption via `EncryptedSerializer`
+- When `LANGGRAPH_AES_KEY` environment variable is present, encryption is automatically enabled on LangGraph Platform
+
+### Data Retention
+
+- **TTL (Time-to-Live)**: Configurable automatic cleanup of old data
+- **Default TTL**: Can be set in minutes for automatic expiration
+- **Automatic sweeping**: Expired data is automatically removed at configurable intervals
+
+## Privacy Controls
+
+### Environment Variables
+
+Key environment variables for controlling data collection and storage:
+
+- `LANGGRAPH_CLI_NO_ANALYTICS=1`: Disable CLI analytics collection
+- `LANGGRAPH_AES_KEY`: Enable automatic encryption of stored data
+- `LANGSMITH_TRACING=false`: Disable tracing to LangSmith (self-hosted deployments)
+- `LANGSMITH_API_KEY`: Enable LangSmith integration (opt-in)
+
+### Logging Controls
+
+- `LOG_LEVEL`: Control verbosity of logs
+- `LOG_JSON`: Format logs as JSON
+- Various other logging configuration options
+
+## Security Policy
+
+For security vulnerabilities:
+- Report through the huntr.com bounty program
+- LangGraph is in-scope for security bounties
+- Security contact: `security@langchain.dev`
+
+## Best Practices for Privacy
+
+1. **Review Analytics**: Set `LANGGRAPH_CLI_NO_ANALYTICS=1` if you prefer not to share usage analytics
+2. **Enable Encryption**: Use `LANGGRAPH_AES_KEY` for sensitive data
+3. **Configure TTL**: Set appropriate data retention policies
+4. **Monitor Tracing**: Only enable tracing when needed and review what data is being sent
+5. **Environment Variables**: Audit your environment variables to ensure proper privacy controls
+
+## Summary
+
+LangGraph is designed with privacy in mind:
+- Minimal data collection (analytics can be disabled)
+- Local storage by default for development
+- Optional encryption for sensitive data
+- Clear opt-in requirements for external services
+- Comprehensive privacy controls through environment variables
+
+Your application data, checkpoints, and state remain under your control and are not transmitted unless you explicitly configure external services like LangSmith.

docs/docs/concepts/deployment_options.md

@@ -59,7 +59,7 @@ For more information, please see:
 !!! info "Important"
     The Self-Hosted Control Plane deployment option is currently in beta stage and requires an [Enterprise](../concepts/plans.md) plan.
 
-The [Self-Hosted Control Plane](./langgraph_self_hosted_control_plane.md) deployment option is a fully self-hosted model for deployment where you manage the [control plane](./langgraph_control_plane.md) and [data plane](./langgraph_data_plane.md) in your cloud. This option gives you full control and responsibility of the control plane and data plane infrastructure.
+The [Self-Hosted Control Plane](./langgraph_self_hosted_control_plane.md) deployment option is a fully self-hosted model for deployment where you manage the [control plane](./langgraph_control_plane.md) and [data plane](./langgraph_data_plane.md) in your cloud. This option give you full control and responsibility of the control plane and data plane infrastructure.
 
 Build a Docker image using the [LangGraph CLI](./langgraph_cli.md) and deploy your LangGraph Server from the [control plane UI](./langgraph_control_plane.md#control-plane-ui).
 

docs/docs/concepts/faq.md

@@ -59,8 +59,8 @@ Yes! You can use LangGraph with any LLMs. The main reason we use LLMs that suppo
 
 Yes! LangGraph is totally ambivalent to what LLMs are used under the hood. The main reason we use closed LLMs in most of the tutorials is that they seamlessly support tool calling, while OSS LLMs often don't. But tool calling is not necessary (see [this section](#does-langgraph-work-with-llms-that-dont-support-tool-calling)) so you can totally use LangGraph with OSS LLMs.
 
-## Can I use LangGraph Studio without logging in to LangSmith
+## Can I use LangGraph Studio without logging to LangSmith
 
 Yes! You can use the [development version of LangGraph Server](../tutorials/langgraph-platform/local-server.md) to run the backend locally.
 This will connect to the studio frontend hosted as part of LangSmith.
-If you set an environment variable of `LANGSMITH_TRACING=false`, then no traces will be sent to LangSmith.
+If you set an environment variable of `LANGSMITH_TRACING=false` then no traces will be sent to LangSmith.

docs/docs/concepts/functional_api.md

@@ -186,7 +186,7 @@ When declaring an `entrypoint`, you can request access to additional parameters
 
 | Parameter    | Description                                                                                                                                                        |
 |--------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| **previous** | Access the state associated with the previous `checkpoint` for the given thread. See [short-term-memory](#short-term-memory).                                  |
+| **previous** | Access the the state associated with the previous `checkpoint` for the given thread. See [short-term-memory](#short-term-memory).                                  |
 | **store**    | An instance of [BaseStore][langgraph.store.base.BaseStore]. Useful for [long-term memory](../how-tos/use-functional-api.md#long-term-memory).                      |
 | **writer**   | Use to access the StreamWriter when working with Async Python < 3.11. See [streaming with functional API for details](../how-tos/use-functional-api.md#streaming). |
 | **config**   | For accessing run time configuration. See [RunnableConfig](https://python.langchain.com/docs/concepts/runnables/#runnableconfig) for information.                  |

docs/docs/concepts/langgraph_control_plane.md

@@ -19,6 +19,7 @@ From the control plane UI, you can:
 - Update a deployment.
 - Update environment variables for a deployment.
 - View build and server logs of a deployment.
+- View deployment metrics such as CPU and memory usage.
 - Delete a deployment.
 
 The Control Plane UI is embedded in [LangSmith](https://docs.smith.langchain.com/langgraph_cloud).
@@ -88,6 +89,17 @@ Infrastructure for deployments and revisions are provisioned and deployed asynch
 
 The control plane and [LangGraph Data Plane](./langgraph_data_plane.md) "listener" application coordinate to achieve asynchronous deployments.
 
+### Monitoring
+
+After a deployment is ready, the control plane monitors the deployment and records various metrics, such as:
+
+- CPU and memory usage of the deployment.
+- Number of container restarts.
+- Number of replicas (this will increase with [autoscaling](../concepts/langgraph_data_plane.md#autoscaling)).
+- [Postgres](../concepts/langgraph_data_plane.md#postgres) CPU, memory usage, and disk usage.
+
+These metrics are displayed as charts in the Control Plane UI.
+
 ### LangSmith Integration
 
 A [LangSmith](https://docs.smith.langchain.com/) tracing project is automatically created for each deployment. The tracing project has the same name as the deployment. When creating a deployment, the `LANGCHAIN_TRACING` and `LANGSMITH_API_KEY`/`LANGCHAIN_API_KEY` environment variables do not need to be specified; they are set automatically by the control plane.

docs/docs/concepts/langgraph_data_plane.md

@@ -9,7 +9,7 @@ The term "data plane" is used broadly to refer to [LangGraph Servers](./langgrap
 
 ## Server Infrastructure
 
-In addition to the [LangGraph Server](./langgraph_server.md) itself, the following infrastructure components for each server are also included in the broad definition of "data plane":
+In addition to the [LangGraph Server](./langgraph_server.md) itself, the following infrastructure for each server are also included in the broad definition of "data plane":
 
 - Postgres
 - Redis
@@ -44,7 +44,7 @@ All runs in a LangGraph Server are executed by a pool of background workers that
 
 ### Ephemeral metadata
 
-Runs in a LangGraph Server may be retried for specific failures (currently only for transient Postgres errors encountered during the run). In order to limit the number of retries (currently limited to 3 attempts per run) we record the attempt number in a Redis string when it is picked up. This contains no run-specific info other than its ID, and expires after a short delay.
+Runs in a LangGraph Server may be retried for specific failures (currently only for transient Postgres errors encountered during the run). In order to limit the number of retries (currently limited to 3 attempts per run) we record the attempt number in a Redis string when is picked up. This contains no run-specific info other than its ID, and expires after a short delay.
 
 ## Data Plane Features
 
@@ -62,7 +62,7 @@ For CPU utilization, the autoscaler targets 75% utilization. This means the auto
 
 For number of pending runs, the autoscaler targets 10 pending runs. For example, if the current number of containers is 1, but the number of pending runs in 20, the autoscaler will scale up the deployment to 2 containers (20 pending runs / 2 containers = 10 pending runs per container).
 
-Each metric is computed independently and the autoscaler will determine the scaling action based on the metric that results in the largest number of containers.
+Each metric is computed independently and the autoscaler will determine the scaling action based on the metric that results in the most number of containers.
 
 Scale down actions are delayed for 30 minutes before any action is taken. In other words, if the autoscaler decides to scale down a deployment, it will first wait for 30 minutes before scaling down. After 30 minutes, the metrics are recomputed and the deployment will scale down if the recomputed metrics result in a lower number of containers than the current number. Otherwise, the deployment remains scaled up. This "cool down" period ensures that deployments do not scale up and down too frequently.
 

docs/docs/concepts/langgraph_platform.md

@@ -9,7 +9,7 @@ Develop, deploy, scale, and manage agents with **LangGraph Platform** — the pu
 
 !!! tip "Get started with LangGraph Platform"
 
-    Check out the [LangGraph Platform quickstart](../tutorials/langgraph-platform/local-server.md) for instructions on how to use LangGraph Platform to run a LangGraph application locally.
+    Check out the [LangGraph Platform quickstart](../tutorials/langgraph-platform/local-server.md) for instructions on how to use LangGraph Platform run a LangGraph application locally.
 
 ## Why use LangGraph Platform?
 
@@ -33,4 +33,4 @@ LangGraph Platform makes it easy to get your agent running in production —  wh
 
 - **[LangGraph Studio](./langgraph_studio.md)**: Enables visualization, interaction, and debugging of agentic systems that implement the LangGraph Server API protocol. Studio also integrates with LangSmith to enable tracing, evaluation, and prompt engineering.
 
-- **[Deployment](./deployment_options.md)**: There are four ways to deploy on LangGraph Platform: [Cloud SaaS](../concepts/langgraph_cloud.md), [Self-Hosted Data Plane](../concepts/langgraph_self_hosted_data_plane.md), [Self-Hosted Control Plane](../concepts/langgraph_self_hosted_control_plane.md), and [Standalone Container](../concepts/langgraph_standalone_container.md).
+- **[Deployment](./deployment_options.md)**: There are four ways to deploy on LangGraph Platform: [Cloud Saas](../concepts/langgraph_cloud.md), [Self-Hosted Data Plane](../concepts/langgraph_self_hosted_data_plane.md), [Self-Hosted Control Plane](../concepts/langgraph_self_hosted_control_plane.md), and [Standalone Container](../concepts/langgraph_standalone_container.md).

docs/docs/concepts/langgraph_self_hosted_control_plane.md

@@ -9,12 +9,10 @@ There are two versions of the self-hosted deployment: [Self-Hosted Data Plane](.
 
 - You use `langgraph-cli` and/or [LangGraph Studio](./langgraph_studio.md) app to test graph locally.
 - You use `langgraph build` command to build image.
-- You have a Self-Hosted LangSmith instance deployed.
-- You are using Ingress for your LangSmith instance. All agents will be deployed as Kubernetes services behind this ingress.
 
 ## Self-Hosted Control Plane
 
-The [Self-Hosted Control Plane](./langgraph_self_hosted_control_plane.md) deployment option is a fully self-hosted model for deployment where you manage the [control plane](./langgraph_control_plane.md) and [data plane](./langgraph_data_plane.md) in your cloud. This option gives you full control and responsibility of the control plane and data plane infrastructure.
+The [Self-Hosted Control Plane](./langgraph_self_hosted_control_plane.md) deployment option is a fully self-hosted model for deployment where you manage the [control plane](./langgraph_control_plane.md) and [data plane](./langgraph_data_plane.md) in your cloud. This option give you full control and responsibility of the control plane and data plane infrastructure.
 
 |                   | [Control plane](../concepts/langgraph_control_plane.md) | [Data plane](../concepts/langgraph_data_plane.md) |
 |-------------------|-------------------|------------|
@@ -31,4 +29,4 @@ The [Self-Hosted Control Plane](./langgraph_self_hosted_control_plane.md) deploy
  - **Kubernetes**: The Self-Hosted Control Plane deployment option supports deploying control plane and data plane infrastructure to any Kubernetes cluster.
 
 !!! tip
-    If you would like to enable this on your LangSmith instance, please follow the [Self-Hosted Control Plane deployment guide](../cloud/deployment/self_hosted_control_plane.md).
+    If you would like to deploy to Kubernetes, you can use this [Helm chart](https://github.com/langchain-ai/helm/blob/main/charts/langgraph-cloud/README.md).

docs/docs/concepts/langgraph_self_hosted_data_plane.md

@@ -37,4 +37,4 @@ For information on how to deploy a [LangGraph Server](../concepts/langgraph_serv
 - **Amazon ECS**: Coming soon!
 
 !!! tip
-    If you would like to deploy to Kubernetes, you can follow the [Self-Hosted Data Plane deployment guide](../cloud/deployment/self_hosted_data_plane.md).
+    If you would like to deploy to Kubernetes, you can use this [Helm chart](https://github.com/langchain-ai/helm/blob/main/charts/langgraph-cloud/README.md).

docs/docs/concepts/langgraph_server.md

@@ -26,7 +26,7 @@ Feature Differences:
 |-------|------------|------------|
 | [Cron Jobs](../cloud/concepts/cron_jobs.md) |❌|✅|
 | [Custom Authentication](../concepts/auth.md) |❌|✅|
-| [Deployment options](../concepts/deployment_options.md) | Standalone container | Cloud SaaS, Self-Hosted Data Plane, Self-Hosted Control Plane, Standalone container
+| [Deployment options](../concepts/deployment_options.md) | Standalone container | Cloud Saas, Self-Hosted Data Plane, Self-Hosted Control Plane, Standalone container
 
 ## Application structure
 

docs/docs/concepts/langgraph_studio.md

@@ -24,6 +24,7 @@ Key features of LangGraph Studio:
 - [Manage assistants](../cloud/how-tos/studio/manage_assistants.md)
 - [Manage threads](../cloud/how-tos/threads_studio.md)
 - [Iterate on prompts](../cloud/how-tos/iterate_graph_studio.md)
+- [Run experiments over a dataset](../cloud/how-tos/studio/run_evals.md)
 - Manage [long term memory](memory.md)
 - Debug agent state via [time travel](time-travel.md)
 
@@ -33,7 +34,7 @@ Studio supports two modes:
 
 ### Graph mode
 
-Graph mode exposes the full feature-set of Studio and is useful when you would like as many details about the execution of your agent, including the nodes traversed, intermediate states, and LangSmith integrations (such as adding to datasets and playground).
+Graph mode exposes the full feature-set of Studio and is useful when you would like as many details about the execution of your agent, including the nodes traversed, intermediate states, and LangSmith integrations (such as adding to datasets an playground).
 
 ### Chat mode
 
@@ -41,4 +42,4 @@ Chat mode is a simpler UI for iterating on and testing chat-specific agents. It
 
 ## Learn more
 
-- See this guide on how to [get started](../cloud/how-tos/studio/quick_start.md) with LangGraph Studio.
+- See this guide on how to [get started](../cloud/how-tos/studio/quick_start.md) with LangGraph Studio.

docs/docs/concepts/low_level.md

@@ -105,7 +105,7 @@ graph.invoke({"user_input":"My"})
 
 There are two subtle and important points to note here:
 
-1. We pass `state: InputState` as the input schema to `node_1`. But, we write out to `foo`, a channel in `OverallState`. How can we write out to a state channel that is not included in the input schema? This is because a node _can write to any state channel in the graph state._ The graph state is the union of the state channels defined at initialization, which includes `OverallState` and the filters `InputState` and `OutputState`.
+1. We pass `state: InputState` as the input schema to `node_1`. But, we write out to `foo`, a channel in `OverallState`. How can we write out to a state channel that is not included in the input schema? This is because a node _can write to any state channel in the graph state._ The graph state is the union of of the state channels defined at initialization, which includes `OverallState` and the filters `InputState` and `OutputState`.
 
 2. We initialize the graph with `StateGraph(OverallState,input=InputState,output=OutputState)`. So, how can we write to `PrivateState` in `node_2`? How does the graph gain access to this schema if it was not passed in the `StateGraph` initialization? We can do this because _nodes can also declare additional state channels_ as long as the state schema definition exists. In this case, the `PrivateState` schema is defined, so we can add `bar` as a new state channel in the graph and write to it.
 
@@ -167,7 +167,7 @@ In addition to keeping track of message IDs, the `add_messages` function will al
 {"messages": [{"type": "human", "content": "message"}]}
 ```
 
-Since the state updates are always deserialized into LangChain `Messages` when using `add_messages`, you should use dot notation to access message attributes, like `state["messages"][-1].content`. Below is an example of a graph that uses `add_messages` as its reducer function.
+Since the state updates are always deserialized into LangChain `Messages` when using `add_messages`, you should use dot notation to access message attributes, like `state["messages"][-1].content`. Below is an example of a graph that uses `add_messages` as it's reducer function.
 
 ```python
 from langchain_core.messages import AnyMessage
@@ -197,19 +197,25 @@ In LangGraph, nodes are typically python functions (sync or async) where the **f
 Similar to `NetworkX`, you add these nodes to a graph using the [add_node][langgraph.graph.StateGraph.add_node] method:
 
 ```python
+from typing_extensions import TypedDict
+
 from langchain_core.runnables import RunnableConfig
 from langgraph.graph import StateGraph
 
-builder = StateGraph(dict)
+class State(TypedDict):
+    input: str
+    results: str
+
+builder = StateGraph(State)
 
 
-def my_node(state: dict, config: RunnableConfig):
+def my_node(state: State, config: RunnableConfig):
     print("In node: ", config["configurable"]["user_id"])
     return {"results": f"Hello, {state['input']}!"}
 
 
 # The second argument is optional
-def my_other_node(state: dict):
+def my_other_node(state: State):
     return state
 
 

docs/docs/concepts/persistence.md

@@ -383,7 +383,7 @@ def update_memory(state: MessagesState, config: RunnableConfig, *, store: BaseSt
 
 ```
 
-As we showed above, we can also access the store in any node and use the `store.search` method to get memories. Recall the memories are returned as a list of objects that can be converted to a dictionary.
+As we showed above, we can also access the store in any node and use the `store.search` method to get memories. Recall the the memories are returned as a list of objects that can be converted to a dictionary.
 
 ```python
 memories[-1].dict()
@@ -470,9 +470,34 @@ If the checkpointer is used with asynchronous graph execution (i.e. executing th
 
 ### Serializer
 
-When checkpointers save the graph state, they need to serialize the channel values in the state. This is done using serializer objects. 
+When checkpointers save the graph state, they need to serialize the channel values in the state. This is done using serializer objects.
 `langgraph_checkpoint` defines [protocol][langgraph.checkpoint.serde.base.SerializerProtocol] for implementing serializers provides a default implementation ([JsonPlusSerializer][langgraph.checkpoint.serde.jsonplus.JsonPlusSerializer]) that handles a wide variety of types, including LangChain and LangGraph primitives, datetimes, enums and more.
 
+#### Encryption
+
+Checkpointers can optionally encrypt all persisted state. To enable this, pass an instance of [`EncryptedSerializer`][langgraph.checkpoint.serde.encrypted.EncryptedSerializer] to the `serde` argument of any `BaseCheckpointSaver` implementation. The easiest way to create an encrypted serializer is via [`from_pycryptodome_aes`][langgraph.checkpoint.serde.encrypted.EncryptedSerializer.from_pycryptodome_aes], which reads the AES key from the `LANGGRAPH_AES_KEY` environment variable (or accepts a `key` argument):
+
+```python
+import sqlite3
+
+from langgraph.checkpoint.serde.encrypted import EncryptedSerializer
+from langgraph.checkpoint.sqlite import SqliteSaver
+
+serde = EncryptedSerializer.from_pycryptodome_aes()  # reads LANGGRAPH_AES_KEY
+checkpointer = SqliteSaver(sqlite3.connect("checkpoint.db"), serde=serde)
+```
+
+```python
+from langgraph.checkpoint.serde.encrypted import EncryptedSerializer
+from langgraph.checkpoint.postgres import PostgresSaver
+
+serde = EncryptedSerializer.from_pycryptodome_aes()
+checkpointer = PostgresSaver.from_conn_string("postgresql://...", serde=serde)
+checkpointer.setup()
+```
+
+When running on LangGraph Platform, encryption is automatically enabled whenever `LANGGRAPH_AES_KEY` is present, so you only need to provide the environment variable. Other encryption schemes can be used by implementing [`CipherProtocol`][langgraph.checkpoint.serde.base.CipherProtocol] and supplying it to `EncryptedSerializer`.
+
 ## Capabilities
 
 ### Human-in-the-loop

docs/docs/concepts/pregel.md

@@ -25,7 +25,7 @@ Each step consists of three phases:
 
 Repeat until no **actors** are selected for execution, or a maximum number of steps is reached.
 
-## Actors
+## Actors 
 
 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.
 
@@ -39,7 +39,7 @@ Channels are used to communicate between actors (PregelNodes). Each channel has
 
 ## Examples
 
-While most users will interact with Pregel through the [StateGraph][langgraph.graph.StateGraph] API or
+While most users will interact with Pregel through the [StateGraph][langgraph.graph.StateGraph] API or 
 the [entrypoint][langgraph.func.entrypoint] decorator, it is possible to interact with Pregel directly.
 
 Below are a few different examples to give you a sense of the Pregel API.
@@ -49,12 +49,12 @@ Below are a few different examples to give you a sense of the Pregel API.
     ```python
 
     from langgraph.channels import EphemeralValue
-    from langgraph.pregel import Pregel, NodeBuilder
+    from langgraph.pregel import Pregel, Channel 
 
     node1 = (
-        NodeBuilder().subscribe_only("a")
-        .do(lambda x: x + x)
-        .write_to("b")
+        Channel.subscribe_to("a")
+        | (lambda x: x + x)
+        | Channel.write_to("b")
     )
 
     app = Pregel(
@@ -78,18 +78,18 @@ Below are a few different examples to give you a sense of the Pregel API.
 
     ```python
     from langgraph.channels import LastValue, EphemeralValue
-    from langgraph.pregel import Pregel, NodeBuilder
+    from langgraph.pregel import Pregel, Channel 
 
     node1 = (
-        NodeBuilder().subscribe_only("a")
-        .do(lambda x: x + x)
-        .write_to("b")
+        Channel.subscribe_to("a")
+        | (lambda x: x + x)
+        | Channel.write_to("b")
     )
 
     node2 = (
-        NodeBuilder().subscribe_only("b")
-        .do(lambda x: x + x)
-        .write_to("c")
+        Channel.subscribe_to("b")
+        | (lambda x: x + x)
+        | Channel.write_to("c")
     )
 
 
@@ -115,18 +115,23 @@ Below are a few different examples to give you a sense of the Pregel API.
 
     ```python
     from langgraph.channels import EphemeralValue, Topic
-    from langgraph.pregel import Pregel, NodeBuilder
+    from langgraph.pregel import Pregel, Channel 
 
     node1 = (
-        NodeBuilder().subscribe_only("a")
-        .do(lambda x: x + x)
-        .write_to("b", "c")
+        Channel.subscribe_to("a")
+        | (lambda x: x + x)
+        | {
+            "b": Channel.write_to("b"),
+            "c": Channel.write_to("c")
+        }
     )
 
     node2 = (
-        NodeBuilder().subscribe_to("b")
-        .do(lambda x: x["b"] + x["b"])
-        .write_to("c")
+        Channel.subscribe_to("b")
+        | (lambda x: x + x)
+        | {
+            "c": Channel.write_to("c"),
+        }
     )
 
     app = Pregel(
@@ -153,19 +158,24 @@ Below are a few different examples to give you a sense of the Pregel API.
 
     ```python
     from langgraph.channels import EphemeralValue, BinaryOperatorAggregate
-    from langgraph.pregel import Pregel, NodeBuilder
+    from langgraph.pregel import Pregel, Channel
 
 
     node1 = (
-        NodeBuilder().subscribe_only("a")
-        .do(lambda x: x + x)
-        .write_to("b", "c")
+        Channel.subscribe_to("a")
+        | (lambda x: x + x)
+        | {
+            "b": Channel.write_to("b"),
+            "c": Channel.write_to("c")
+        }
     )
 
     node2 = (
-        NodeBuilder().subscribe_only("b")
-        .do(lambda x: x + x)
-        .write_to("c")
+        Channel.subscribe_to("b")
+        | (lambda x: x + x)
+        | {
+            "c": Channel.write_to("c"),
+        }
     )
 
     def reducer(current, update):
@@ -187,7 +197,8 @@ Below are a few different examples to give you a sense of the Pregel API.
 
     app.invoke({"a": "foo"})
     ```
-
+    
+    
 === "Cycle"
 
     This example demonstrates how to introduce a cycle in the graph, by having
@@ -196,12 +207,12 @@ Below are a few different examples to give you a sense of the Pregel API.
 
     ```python
     from langgraph.channels import EphemeralValue
-    from langgraph.pregel import Pregel, NodeBuilder, ChannelWriteEntry
+    from langgraph.pregel import Pregel, Channel, ChannelWrite, ChannelWriteEntry
 
     example_node = (
-        NodeBuilder().subscribe_only("value")
-        .do(lambda x: x + x if len(x) < 10 else None)
-        .write_to(ChannelWriteEntry("value", skip_none=True))
+        Channel.subscribe_to("value")
+        | (lambda x: x + x if len(x) < 10 else None)
+        | ChannelWrite(writes=[ChannelWriteEntry(channel="value", skip_none=True)])
     )
 
     app = Pregel(
@@ -224,6 +235,7 @@ Below are a few different examples to give you a sense of the Pregel API.
 
 LangGraph provides two high-level APIs for creating a Pregel application: the [StateGraph (Graph API)](./low_level.md) and the [Functional API](functional_api.md).
 
+
 === "StateGraph (Graph API)"
 
     The [StateGraph (Graph API)][langgraph.graph.StateGraph] is a higher-level abstraction that simplifies the creation of Pregel applications. It allows you to define a graph of nodes and edges. When you compile the graph, the StateGraph API automatically creates the Pregel application for you.
@@ -254,7 +266,7 @@ LangGraph provides two high-level APIs for creating a Pregel application: the [S
     builder.add_node(score_essay)
     builder.add_edge(START, "write_essay")
 
-    # Compile the graph.
+    # Compile the graph. 
     # This will return a Pregel instance.
     graph = builder.compile()
     ```
@@ -267,7 +279,7 @@ LangGraph provides two high-level APIs for creating a Pregel application: the [S
 
     You will see something like this:
 
-    ```pycon
+    ```pycon 
     {'__start__': <langgraph.pregel.read.PregelNode at 0x7d05e3ba1810>,
      'write_essay': <langgraph.pregel.read.PregelNode at 0x7d05e3ba14d0>,
      'score_essay': <langgraph.pregel.read.PregelNode at 0x7d05e3ba1710>}
@@ -298,7 +310,7 @@ LangGraph provides two high-level APIs for creating a Pregel application: the [S
 === "Functional API"
 
     In the [Functional API](functional_api.md), you can use an [`entrypoint`][langgraph.func.entrypoint] to create
-    a Pregel application. The `entrypoint` decorator allows you to define a function that takes input and returns output.
+    a Pregel application. The `entrypoint` decorator allows you to define a function that takes input and returns output. 
 
     ```python
     from typing import TypedDict, Optional
@@ -327,8 +339,8 @@ LangGraph provides two high-level APIs for creating a Pregel application: the [S
     ```
 
     ```pycon
-    Nodes:
+    Nodes: 
     {'write_essay': <langgraph.pregel.read.PregelNode object at 0x7d05e2f9aad0>}
-    Channels:
+    Channels: 
     {'__start__': <langgraph.channels.ephemeral_value.EphemeralValue object at 0x7d05e2c906c0>, '__end__': <langgraph.channels.last_value.LastValue object at 0x7d05e2c90c40>, '__previous__': <langgraph.channels.last_value.LastValue object at 0x7d05e1007280>}
     ```

docs/docs/concepts/scalability_and_resilience.md

@@ -25,7 +25,7 @@ When a graceful shutdown request is received (SIGINT) an instance enters shutdow
 - gives any in-progress runs a limited number of seconds to finish (if not finished it will be put back in the queue)
 - stops the instance from picking up more runs from the queue
 
-If a hard shutdown occurs due to a server crash or an infrastructure failure, any runs that were in progress will be picked up by an internal sweeper task that looks for in-progress runs that have breached their heartbeat window. The sweeper runs every 2 minutes and will put the runs back in the queue for another instance to pick them up.
+If a hard shutdown occurs due to a server crash or an infrastructure failure, any runs that were in progress will be picked up by a internal sweeper task that looks for in-progress runs that have breached their heartbeat window. The sweeper runs every 2 minutes and will put the runs back in the queue for another instance to pick them up.
 
 ## Postgres resilience
 

docs/docs/concepts/sdk.md

@@ -5,7 +5,7 @@ search:
 
 # LangGraph SDK
 
-LangGraph Platform provides both a Python SDK for interacting with [LangGraph Server](./langgraph_server.md).
+LangGraph Platform provides both a Python and JS SDK for interacting with [LangGraph Server](./langgraph_server.md).
 
 !!! tip "Python SDK reference"
   

docs/docs/how-tos/auth/custom_auth.md

@@ -74,7 +74,7 @@ In your `langgraph.json`, add the path to your auth file:
 
 ## 3. Connect from the client
 
-Once you've set up authentication in your server, requests must include the required authorization information based on your chosen scheme.
+Once you've set up authentication in your server, requests must include the the required authorization information based on your chosen scheme.
 Assuming you are using JWT token authentication, you could access your deployments using any of the following methods:
 
 === "Python Client"

docs/docs/how-tos/graph-api.ipynb

@@ -1198,7 +1198,7 @@
     "\n",
     "There are many use cases where you may wish for your node to have a custom retry policy, for example if you are calling an API, querying a database, or calling an LLM, etc. LangGraph lets you add retry policies to nodes.\n",
     "\n",
-    "To configure a retry policy, pass the `retry_policy` parameter to the [add_node](https://langchain-ai.github.io/langgraph/reference/graphs/#langgraph.graph.state.StateGraph.add_node). The `retry_policy` parameter takes in a `RetryPolicy` named tuple object. Below we instantiate a `RetryPolicy` object with the default parameters and associate it with a node:\n",
+    "To configure a retry policy, pass the `retry` parameter to the [add_node](https://langchain-ai.github.io/langgraph/reference/graphs/#langgraph.graph.state.StateGraph.add_node). The `retry` parameter takes in a `RetryPolicy` named tuple object. Below we instantiate a `RetryPolicy` object with the default parameters and associate it with a node:\n",
     "\n",
     "```python\n",
     "from langgraph.pregel import RetryPolicy\n",
@@ -1206,7 +1206,7 @@
     "builder.add_node(\n",
     "    \"node_name\",\n",
     "    node_function,\n",
-    "    retry_policy=RetryPolicy(),\n",
+    "    retry=RetryPolicy(),\n",
     ")\n",
     "```"
    ]
@@ -1241,7 +1241,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "id": "ad92598c-b688-42fa-aae0-9de36273d584",
    "metadata": {},
    "outputs": [],
@@ -1276,9 +1276,9 @@
     "builder.add_node(\n",
     "    \"query_database\",\n",
     "    query_database,\n",
-    "    retry_policy=RetryPolicy(retry_on=sqlite3.OperationalError),\n",
+    "    retry=RetryPolicy(retry_on=sqlite3.OperationalError),\n",
     ")\n",
-    "builder.add_node(\"model\", call_model, retry_policy=RetryPolicy(max_attempts=5))\n",
+    "builder.add_node(\"model\", call_model, retry=RetryPolicy(max_attempts=5))\n",
     "builder.add_edge(START, \"model\")\n",
     "builder.add_edge(\"model\", \"query_database\")\n",
     "builder.add_edge(\"query_database\", END)\n",
@@ -3416,7 +3416,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": ".venv",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -3430,7 +3430,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.9"
+   "version": "3.10.4"
   }
  },
  "nbformat": 4,

docs/docs/how-tos/human_in_the_loop/time-travel.ipynb

@@ -12,9 +12,9 @@
     "\n",
     "\n",
     "1. **Run the graph** with initial inputs using `invoke` or `stream` APIs.\n",
-    "2. **Identify a checkpoint in an existing thread**: Use the [`get_state_history()`][langgraph.graph.state.CompiledStateGraph.get_state_history] method to retrieve the execution history for a specific `thread_id` and locate the desired `checkpoint_id`.  \n",
+    "2. **Identify a checkpoint in an existing thread**: Use the [`get_state_history()`][langgraph.graph.graph.CompiledGraph.get_state_history] method to retrieve the execution history for a specific `thread_id` and locate the desired `checkpoint_id`.  \n",
     "   Alternatively, set a [breakpoint](../../../concepts/breakpoints/) before the node(s) where you want execution to pause. You can then find the most recent checkpoint recorded up to that breakpoint.\n",
-    "3. **(Optional) modify the graph state**: Use the [`update_state`][langgraph.graph.state.CompiledStateGraph.update_state] method to modify the graph’s state at the checkpoint and resume execution from alternative state.\n",
+    "3. **(Optional) modify the graph state**: Use the [`update_state`][langgraph.graph.graph.CompiledGraph.update_state] method to modify the graph’s state at the checkpoint and resume execution from alternative state.\n",
     "4. **Resume execution from the checkpoint**: Use the `invoke` or `stream` APIs with an input of `None` and a configuration containing the appropriate `thread_id` and `checkpoint_id`.\n",
     "\n",
     "## Example\n",

docs/docs/how-tos/many-tools.ipynb

@@ -405,7 +405,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 46,
    "id": "1954a5f1-91e4-4b32-9be9-c8bc1cc43cb5",
    "metadata": {},
    "outputs": [],
@@ -465,9 +465,7 @@
     "\n",
     "graph_builder = StateGraph(State)\n",
     "graph_builder.add_node(\"agent\", agent)\n",
-    "graph_builder.add_node(\n",
-    "    \"select_tools\", select_tools, retry_policy=RetryPolicy(max_attempts=3)\n",
-    ")\n",
+    "graph_builder.add_node(\"select_tools\", select_tools, retry=RetryPolicy(max_attempts=3))\n",
     "\n",
     "tool_node = ToolNode(tools=tools)\n",
     "graph_builder.add_node(\"tools\", tool_node)\n",

docs/docs/how-tos/multi-agent-multi-turn-convo-functional.ipynb

@@ -207,7 +207,7 @@
    "id": "213d661e-6ba4-42b9-bc7f-6c8c423e3419",
    "metadata": {},
    "source": [
-    "Let's now create our agents using the prebuilt [`create_react_agent`][langgraph.prebuilt.chat_agent_executor.create_react_agent] and our multi-agent workflow. Note that will be calling [`interrupt`][langgraph.types.interrupt] every time after we get the final response from each of the agents."
+    "Let's now create our agents using the the prebuilt [`create_react_agent`][langgraph.prebuilt.chat_agent_executor.create_react_agent] and our multi-agent workflow. Note that will be calling [`interrupt`][langgraph.types.interrupt] every time after we get the final response from each of the agents."
    ]
   },
   {

docs/docs/how-tos/persistence.ipynb

@@ -739,6 +739,7 @@
     "                'id': '1f029ca3-1f5b-6704-8004-820c16b69a5a',\n",
     "                'channel_versions': {'__start__': '00000000000000000000000000000005.0.5290678567601859', 'messages': '00000000000000000000000000000006.0.3205149138784782', 'branch:to:call_model': '00000000000000000000000000000006.0.14611156755133758'}, 'versions_seen': {'__input__': {}, '__start__': {'__start__': '00000000000000000000000000000004.0.5736472536395331'}, 'call_model': {'branch:to:call_model': '00000000000000000000000000000005.0.1410174088651449'}},\n",
     "                'channel_values': {'messages': [HumanMessage(content=\"hi! I'm bob\"), AIMessage(content='Hi Bob! How are you doing today?), HumanMessage(content=\"what's my name?\"), AIMessage(content='Your name is Bob.')]},\n",
+    "                'pending_sends': []\n",
     "            },\n",
     "            metadata={\n",
     "                'source': 'loop',\n",
@@ -855,7 +856,7 @@
     "                    'id': '1f029ca3-1f5b-6704-8004-820c16b69a5a', \n",
     "                    'channel_versions': {'__start__': '00000000000000000000000000000005.0.5290678567601859', 'messages': '00000000000000000000000000000006.0.3205149138784782', 'branch:to:call_model': '00000000000000000000000000000006.0.14611156755133758'}, \n",
     "                    'versions_seen': {'__input__': {}, '__start__': {'__start__': '00000000000000000000000000000004.0.5736472536395331'}, 'call_model': {'branch:to:call_model': '00000000000000000000000000000005.0.1410174088651449'}},\n",
-    "                    'channel_values': {'messages': [HumanMessage(content=\"hi! I'm bob\"), AIMessage(content='Hi Bob! How are you doing today? Is there anything I can help you with?'), HumanMessage(content=\"what's my name?\"), AIMessage(content='Your name is Bob.')]},\n",
+    "                    'channel_values': {'messages': [HumanMessage(content=\"hi! I'm bob\"), AIMessage(content='Hi Bob! How are you doing today? Is there anything I can help you with?'), HumanMessage(content=\"what's my name?\"), AIMessage(content='Your name is Bob.')]}, 'pending_sends': []\n",
     "                },\n",
     "                metadata={'source': 'loop', 'writes': {'call_model': {'messages': AIMessage(content='Your name is Bob.')}}, 'step': 4, 'parents': {}, 'thread_id': '1'}, \n",
     "                parent_config={'configurable': {'thread_id': '1', 'checkpoint_ns': '', 'checkpoint_id': '1f029ca3-1790-6b0a-8003-baf965b6a38f'}}, \n",
@@ -869,7 +870,8 @@
     "                    'id': '1f029ca3-1790-6b0a-8003-baf965b6a38f', \n",
     "                    'channel_versions': {'__start__': '00000000000000000000000000000005.0.5290678567601859', 'messages': '00000000000000000000000000000005.0.7935064215293443', 'branch:to:call_model': '00000000000000000000000000000005.0.1410174088651449'}, \n",
     "                    'versions_seen': {'__input__': {}, '__start__': {'__start__': '00000000000000000000000000000004.0.5736472536395331'}, 'call_model': {'branch:to:call_model': '00000000000000000000000000000002.0.9300422176788571'}}, \n",
-    "                    'channel_values': {'messages': [HumanMessage(content=\"hi! I'm bob\"), AIMessage(content='Hi Bob! How are you doing today? Is there anything I can help you with?'), HumanMessage(content=\"what's my name?\")], 'branch:to:call_model': None}\n",
+    "                    'channel_values': {'messages': [HumanMessage(content=\"hi! I'm bob\"), AIMessage(content='Hi Bob! How are you doing today? Is there anything I can help you with?'), HumanMessage(content=\"what's my name?\")], 'branch:to:call_model': None}, \n",
+    "                    'pending_sends': []\n",
     "                }, \n",
     "                metadata={'source': 'loop', 'writes': None, 'step': 3, 'parents': {}, 'thread_id': '1'}, \n",
     "                parent_config={...}, \n",
@@ -883,7 +885,8 @@
     "                    'id': '1f029ca3-1790-616e-8002-9e021694a0cd', \n",
     "                    'channel_versions': {'__start__': '00000000000000000000000000000004.0.5736472536395331', 'messages': '00000000000000000000000000000003.0.7056767754077798', 'branch:to:call_model': '00000000000000000000000000000003.0.22059023329132854'}, \n",
     "                    'versions_seen': {'__input__': {}, '__start__': {'__start__': '00000000000000000000000000000001.0.7040775356287469'}, 'call_model': {'branch:to:call_model': '00000000000000000000000000000002.0.9300422176788571'}}, \n",
-    "                    'channel_values': {'__start__': {'messages': [{'role': 'user', 'content': \"what's my name?\"}]}, 'messages': [HumanMessage(content=\"hi! I'm bob\"), AIMessage(content='Hi Bob! How are you doing today? Is there anything I can help you with?')]}\n",
+    "                    'channel_values': {'__start__': {'messages': [{'role': 'user', 'content': \"what's my name?\"}]}, 'messages': [HumanMessage(content=\"hi! I'm bob\"), AIMessage(content='Hi Bob! How are you doing today? Is there anything I can help you with?')]}, \n",
+    "                    'pending_sends': []\n",
     "                }, \n",
     "                metadata={'source': 'input', 'writes': {'__start__': {'messages': [{'role': 'user', 'content': \"what's my name?\"}]}}, 'step': 2, 'parents': {}, 'thread_id': '1'}, \n",
     "                parent_config={...}, \n",
@@ -897,7 +900,8 @@
     "                    'id': '1f029ca3-178d-6f54-8001-d7b180db0c89', \n",
     "                    'channel_versions': {'__start__': '00000000000000000000000000000002.0.18673090920108737', 'messages': '00000000000000000000000000000003.0.7056767754077798', 'branch:to:call_model': '00000000000000000000000000000003.0.22059023329132854'}, \n",
     "                    'versions_seen': {'__input__': {}, '__start__': {'__start__': '00000000000000000000000000000001.0.7040775356287469'}, 'call_model': {'branch:to:call_model': '00000000000000000000000000000002.0.9300422176788571'}}, \n",
-    "                    'channel_values': {'messages': [HumanMessage(content=\"hi! I'm bob\"), AIMessage(content='Hi Bob! How are you doing today? Is there anything I can help you with?')]}\n",
+    "                    'channel_values': {'messages': [HumanMessage(content=\"hi! I'm bob\"), AIMessage(content='Hi Bob! How are you doing today? Is there anything I can help you with?')]}, \n",
+    "                    'pending_sends': []\n",
     "                }, \n",
     "                metadata={'source': 'loop', 'writes': {'call_model': {'messages': AIMessage(content='Hi Bob! How are you doing today? Is there anything I can help you with?')}}, 'step': 1, 'parents': {}, 'thread_id': '1'}, \n",
     "                parent_config={...}, \n",
@@ -911,7 +915,8 @@
     "                    'id': '1f029ca3-0874-6612-8000-339f2abc83b1', \n",
     "                    'channel_versions': {'__start__': '00000000000000000000000000000002.0.18673090920108737', 'messages': '00000000000000000000000000000002.0.30296526818059655', 'branch:to:call_model': '00000000000000000000000000000002.0.9300422176788571'}, \n",
     "                    'versions_seen': {'__input__': {}, '__start__': {'__start__': '00000000000000000000000000000001.0.7040775356287469'}}, \n",
-    "                    'channel_values': {'messages': [HumanMessage(content=\"hi! I'm bob\")], 'branch:to:call_model': None}\n",
+    "                    'channel_values': {'messages': [HumanMessage(content=\"hi! I'm bob\")], 'branch:to:call_model': None}, \n",
+    "                    'pending_sends': []\n",
     "                }, \n",
     "                metadata={'source': 'loop', 'writes': None, 'step': 0, 'parents': {}, 'thread_id': '1'}, \n",
     "                parent_config={...}, \n",
@@ -925,7 +930,8 @@
     "                    'id': '1f029ca3-0870-6ce2-bfff-1f3f14c3e565', \n",
     "                    'channel_versions': {'__start__': '00000000000000000000000000000001.0.7040775356287469'}, \n",
     "                    'versions_seen': {'__input__': {}}, \n",
-    "                    'channel_values': {'__start__': {'messages': [{'role': 'user', 'content': \"hi! I'm bob\"}]}}\n",
+    "                    'channel_values': {'__start__': {'messages': [{'role': 'user', 'content': \"hi! I'm bob\"}]}}, \n",
+    "                    'pending_sends': []\n",
     "                }, \n",
     "                metadata={'source': 'input', 'writes': {'__start__': {'messages': [{'role': 'user', 'content': \"hi! I'm bob\"}]}}, 'step': -1, 'parents': {}, 'thread_id': '1'}, \n",
     "                parent_config=None, \n",

docs/docs/how-tos/use-functional-api.md

@@ -321,7 +321,7 @@ attempts = 0
 # The default RetryPolicy is optimized for retrying specific network errors.
 retry_policy = RetryPolicy(retry_on=ValueError)
 
-@task(retry_policy=retry_policy) 
+@task(retry=retry_policy) 
 def get_info():
     global attempts
     attempts += 1

docs/docs/reference/checkpoints.md

@@ -12,12 +12,18 @@
     options:
       members:
         - SerializerProtocol
+        - CipherProtocol
 
 ::: langgraph.checkpoint.serde.jsonplus
     options:
       members:
         - JsonPlusSerializer
 
+::: langgraph.checkpoint.serde.encrypted
+    options:
+      members:
+        - EncryptedSerializer
+
 ::: langgraph.checkpoint.memory
 
 ::: langgraph.checkpoint.sqlite
@@ -32,4 +38,4 @@
 ::: langgraph.checkpoint.postgres.aio
     options:
       members:
-        - AsyncPostgresSaver
+        - AsyncPostgresSaver

docs/docs/reference/graphs.md

@@ -36,6 +36,41 @@
         - aget_subgraphs
         - with_config
 
+::: langgraph.graph.graph.Graph
+    options:
+      show_if_no_docstring: true
+      show_root_heading: true
+      show_root_full_path: false
+      members:
+        - add_node
+        - add_edge
+        - add_conditional_edges
+        - compile
+
+::: langgraph.graph.graph.CompiledGraph
+    options:
+      show_if_no_docstring: true
+      show_root_heading: true
+      show_root_full_path: false
+      members:
+        - stream
+        - astream
+        - invoke
+        - ainvoke
+        - get_state
+        - aget_state
+        - get_state_history
+        - aget_state_history
+        - update_state
+        - aupdate_state
+        - bulk_update_state
+        - abulk_update_state
+        - get_graph
+        - aget_graph
+        - get_subgraphs
+        - aget_subgraphs
+        - with_config
+
 ::: langgraph.graph.message
     options:
       members:

docs/docs/reference/pregel.md

@@ -1,21 +1,5 @@
 # Pregel
 
-::: langgraph.pregel.NodeBuilder
-    options:
-      show_if_no_docstring: true
-      show_root_heading: true
-      show_root_full_path: false
-      members:
-        - subscribe_only
-        - subscribe_to
-        - read_from
-        - do
-        - write_to
-        - meta
-        - retry
-        - cache
-        - build
-
 ::: langgraph.pregel.Pregel
     options:
       show_if_no_docstring: true

docs/docs/tutorials/customer-support/customer-support.ipynb

@@ -833,7 +833,7 @@
     "@tool\n",
     "def book_excursion(recommendation_id: int) -> str:\n",
     "    \"\"\"\n",
-    "    Book an excursion by its recommendation ID.\n",
+    "    Book a excursion by its recommendation ID.\n",
     "\n",
     "    Args:\n",
     "        recommendation_id (int): The ID of the trip recommendation to book.\n",

docs/docs/tutorials/extraction/retries.ipynb

@@ -89,7 +89,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "id": "baf669a0-04ee-492d-80d8-8fcb658ed128",
    "metadata": {},
    "outputs": [],
@@ -313,8 +313,8 @@
     "\n",
     "    builder.add_edge(\"finalizer\", END)\n",
     "\n",
-    "    # These functions let the step be used in a\n",
-    "    # StateGraph with 'messages' as the key.\n",
+    "    # These functions let the step be used in a MessageGraph\n",
+    "    # or a StateGraph with 'messages' as the key.\n",
     "    def encode(x: Union[Sequence[AnyMessage], PromptValue]) -> dict:\n",
     "        \"\"\"Ensure the input is the correct format.\"\"\"\n",
     "        if isinstance(x, PromptValue):\n",

docs/docs/tutorials/get-started/2-add-tools.md

@@ -1,6 +1,6 @@
 # Add tools
 
-To handle queries that your chatbot can't answer "from memory", integrate a web search tool. The chatbot can use this tool to find relevant information and provide better responses.
+To handle queries you chatbot can't answer "from memory", integrate a web search tool. The chatbot can use this tool to find relevant information and provide better responses.
 
 !!! note
 

docs/docs/tutorials/rag/langgraph_adaptive_rag.ipynb

@@ -516,13 +516,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "id": "b76b5ec3-0720-443d-85b1-c0e79659ca0a",
    "metadata": {},
    "outputs": [],
    "source": [
-    "from pprint import pprint\n",
-    "\n",
     "from langchain.schema import Document\n",
     "\n",
     "\n",
@@ -798,7 +796,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 14,
    "id": "29acc541-d726-4b75-84d1-a215845fe88a",
    "metadata": {},
    "outputs": [
@@ -825,6 +823,8 @@
     }
    ],
    "source": [
+    "from pprint import pprint\n",
+    "\n",
     "# Run\n",
     "inputs = {\n",
     "    \"question\": \"What player at the Bears expected to draft first in the 2024 NFL draft?\"\n",

docs/docs/tutorials/reflection/reflection.ipynb

@@ -389,7 +389,7 @@
      "text": [
       "{'generate': {'messages': [AIMessage(content='Title: The Little Prince: A Topical Allegory for Modern Life\\n\\nIntroduction:\\nAntoine de Saint-Exupéry\\'s \"The Little Prince\" is a classic novella that has captured the hearts of millions since its publication in 1943. While it might be easy to dismiss this work as a children\\'s story, its profound themes and timeless message make it a relevant and topical piece in modern life. This essay will explore the allegorical nature of \"The Little Prince\" and discuss how its message can be applied to the complexities of the modern world.\\n\\nBody Paragraph 1 - The Allegory of the Little Prince:\\n\"The Little Prince\" is an allegorical tale that explores various aspects of the human condition through its whimsical characters and situations. The Little Prince himself represents innocence, curiosity, and the importance of human connection. As the story unfolds, readers encounter different characters that symbolize various aspects of adult life, such as vanity, materialism, and authority. These representations allow the story to transcend age and culture, making it relatable to a wide range of readers, even in the modern context.\\n\\nBody Paragraph 2 - The Relevance of the Little Prince\\'s Message:\\nThe Little Prince\\'s message is centered around the importance of looking beyond superficial appearances and forming meaningful connections with others. In a world increasingly dominated by technology and social media, where surface-level interactions are commonplace, this message is more relevant than ever. The Little Prince encourages readers to cherish and nurture genuine relationships, reminding us that true happiness and fulfillment come from understanding and empathizing with others.\\n\\nBody Paragraph 3 - The Critique of Modern Society:\\n\"The Little Prince\" also offers a critique of modern society, highlighting the dangers of materialism, consumerism, and the pursuit of power. These themes resonate strongly in today\\'s world, where wealth inequality and environmental degradation are pressing issues. The story serves as a reminder that the pursuit of material possessions and status often comes at the expense of our own happiness and the well-being of our planet.\\n\\nConclusion:\\nIn conclusion, \"The Little Prince\" remains a topical and relevant work in modern life due to its allegorical nature, timeless message, and critique of modern society. Its exploration of human connections, materialism, and the pursuit of power offers valuable insights for readers of all ages. By embracing the story\\'s wisdom, we can better navigate the complexities of the modern world and foster a more compassionate, sustainable, and interconnected society.', response_metadata={'token_usage': {'prompt_tokens': 72, 'total_tokens': 632, 'completion_tokens': 560}, 'model_name': 'accounts/fireworks/models/mixtral-8x7b-instruct', 'system_fingerprint': '', 'finish_reason': 'stop', 'logprobs': None}, id='run-b39a25ab-24f6-42d0-96c2-0f74c3ecc8f7-0', usage_metadata={'input_tokens': 72, 'output_tokens': 560, 'total_tokens': 632})]}}\n",
       "---\n",
-      "{'reflect': {'messages': [HumanMessage(content='Essay Critique and Recommendations:\\n\\nTitle: The Little Prince: A Topical Allegory for Modern Life\\n\\nIntroduction:\\nThe introduction effectively sets the stage for the essay by providing background information on \"The Little Prince\" and its relevance in modern life. However, consider adding a hook to engage the reader\\'s attention and create a stronger first impression.\\n\\nBody Paragraph 1 - The Allegory of the Little Prince:\\nThis paragraph provides a clear explanation of the allegorical nature of \"The Little Prince.\" To enhance this section, consider offering specific examples from the text to illustrate how the characters and situations symbolize various aspects of adult life. This will strengthen your analysis and make it more engaging for the reader.\\n\\nBody Paragraph 2 - The Relevance of the Little Prince\\'s Message:\\nThe relevance of the Little Prince\\'s message is well-articulated in this paragraph. To further strengthen your argument, consider discussing the consequences of ignoring this message in the context of modern society. This will help emphasize the importance of the Little Prince\\'s wisdom and its relevance to contemporary issues.\\n\\nBody Paragraph 3 - The Critique of Modern Society:\\nThis paragraph effectively highlights the story\\'s critique of modern society. To deepen your analysis, explore how themes of materialism, consumerism, and the pursuit of power interconnect and contribute to the challenges faced by modern society. Additionally, consider discussing potential solutions or actions inspired by the Little Prince\\'s message that could help address these issues.\\n\\nConclusion:\\nThe conclusion effectively summarizes the main points of the essay and emphasizes the relevance of \"The Little Prince\" in modern life. To further enhance this section, consider incorporating a thought-provoking question or statement that encourages readers to reflect on the story\\'s message and its implications for their own lives.\\n\\nRecommendations:\\n1. Expand the essay to approximately 1,200-1,500 words to allow for a more in-depth analysis.\\n2. Incorporate specific examples and quotes from \"The Little Prince\" to support your arguments and engage the reader.\\n3. Ensure that each body paragraph contains a clear thesis statement, supporting evidence, and analysis.\\n4. Consider discussing counterarguments or potential criticisms of the Little Prince\\'s message to add depth and complexity to your essay.\\n5. Revise and edit the essay for clarity, coherence, and grammar.')]}}\n",
+      "{'reflect': {'messages': [HumanMessage(content='Essay Critique and Recommendations:\\n\\nTitle: The Little Prince: A Topical Allegory for Modern Life\\n\\nIntroduction:\\nThe introduction effectively sets the stage for the essay by providing background information on \"The Little Prince\" and its relevance in modern life. However, consider adding a hook to engage the reader\\'s attention and create a stronger first impression.\\n\\nBody Paragraph 1 - The Allegory of the Little Prince:\\nThis paragraph provides a clear explanation of the allegorical nature of \"The Little Prince.\" To enhance this section, consider offering specific examples from the text to illustrate how the characters and situations symbolize various aspects of adult life. This will strengthen your analysis and make it more engaging for the reader.\\n\\nBody Paragraph 2 - The Relevance of the Little Prince\\'s Message:\\nThe relevance of the Little Prince\\'s message is well-articulated in this paragraph. To further strengthen your argument, consider discussing the consequences of ignoring this message in the context of modern society. This will help emphasize the importance of the Little Prince\\'s wisdom and its relevance to contemporary issues.\\n\\nBody Paragraph 3 - The Critique of Modern Society:\\nThis paragraph effectively highlights the story\\'s critique of modern society. To deepen your analysis, explore how the themes of materialism, consumerism, and the pursuit of power interconnect and contribute to the challenges faced by modern society. Additionally, consider discussing potential solutions or actions inspired by the Little Prince\\'s message that could help address these issues.\\n\\nConclusion:\\nThe conclusion effectively summarizes the main points of the essay and emphasizes the relevance of \"The Little Prince\" in modern life. To further enhance this section, consider incorporating a thought-provoking question or statement that encourages readers to reflect on the story\\'s message and its implications for their own lives.\\n\\nRecommendations:\\n1. Expand the essay to approximately 1,200-1,500 words to allow for a more in-depth analysis.\\n2. Incorporate specific examples and quotes from \"The Little Prince\" to support your arguments and engage the reader.\\n3. Ensure that each body paragraph contains a clear thesis statement, supporting evidence, and analysis.\\n4. Consider discussing counterarguments or potential criticisms of the Little Prince\\'s message to add depth and complexity to your essay.\\n5. Revise and edit the essay for clarity, coherence, and grammar.')]}}\n",
       "---\n",
       "{'generate': {'messages': [AIMessage(content='Title: The Little Prince: A Topical Allegory for Modern Life\\n\\nIntroduction:\\nIn Antoine de Saint-Exupéry\\'s classic novella \"The Little Prince,\" a young boy embarks on a journey through the universe, meeting various characters that symbolize different aspects of adult life. This timeless tale, published in 1943, remains incredibly relevant in today\\'s modern world. Its allegorical nature, thought-provoking message, and critique of modern society offer invaluable insights for readers of all ages. This essay will explore the allegory of \"The Little Prince,\" analyze the relevance of its message, and discuss its critique of modern society, demonstrating its topicality in contemporary life.\\n\\nBody Paragraph 1 - The Allegory of the Little Prince:\\n\"The Little Prince\" is an allegorical tale that uses whimsical characters and situations to explore various aspects of the human condition. For instance, the king represents authority without substance, while the businessman embodies the futility of materialism. The fox, conversely, symbolizes the importance of forming genuine connections and nurturing meaningful relationships. These allegorical representations allow the story to transcend age and culture, making it relatable to a wide range of readers, even in the modern context.\\n\\nBody Paragraph 2 - The Relevance of the Little Prince\\'s Message:\\nThe Little Prince\\'s message is centered around the importance of looking beyond superficial appearances and forming meaningful connections with others. In a world increasingly dominated by technology and social media, where surface-level interactions are commonplace, this message is more relevant than ever. Neglecting this message can lead to feelings of isolation, loneliness, and dissatisfaction. By embracing the story\\'s wisdom, we can prioritize genuine relationships, fostering a more compassionate and interconnected society.\\n\\nBody Paragraph 3 - The Critique of Modern Society:\\n\"The Little Prince\" offers a critique of modern society, highlighting the dangers of materialism, consumerism, and the pursuit of power. These themes resonate strongly in today\\'s world, where wealth inequality and environmental degradation are pressing issues. The story serves as a reminder that the pursuit of material possessions and status often comes at the expense of our own happiness and the well-being of our planet. To address these challenges, we must reevaluate our priorities, focusing on sustainability, empathy, and the cultivation of meaningful relationships.\\n\\nConclusion:\\nIn conclusion, \"The Little Prince\" remains a topical and relevant work in modern life due to its allegorical nature, timeless message, and critique of modern society. Its exploration of human connections, materialism, and the pursuit of power offers valuable insights for readers of all ages. By embracing the story\\'s wisdom, we can better navigate the complexities of the modern world and foster a more compassionate, sustainable, and interconnected society. As the Little Prince so eloquently states, \"What is essential is invisible to the eye,\" reminding us that true happiness and fulfillment come from understanding and empathizing with others.\\n\\nExpanded Essay Recommendations:\\n\\n1. Expand the essay to approximately 1,200-1,500 words to allow for a more in-depth analysis.\\n2. Incorporate specific examples and quotes from \"The Little Prince\" to support your arguments and engage the reader. For instance, use quotes like, \"You become responsible, forever, for what you have tamed,\" to emphasize the importance of forming genuine connections.\\n3. Ensure that each body paragraph contains a clear thesis statement, supporting evidence, and analysis.\\n4. Consider discussing counterarguments or potential criticisms of the Little Prince\\'s message to add depth and complexity to your essay. For example, explore the idea that the pursuit of material possessions can provide a sense of security and comfort.\\n5. Revise and edit the essay for clarity, coherence, and grammar. Ensure that transitions between paragraphs are smooth and that your arguments flow logically.', response_metadata={'token_usage': {'prompt_tokens': 1168, 'total_tokens': 2044, 'completion_tokens': 876}, 'model_name': 'accounts/fireworks/models/mixtral-8x7b-instruct', 'system_fingerprint': '', 'finish_reason': 'stop', 'logprobs': None}, id='run-9bfc9ff2-3186-43f5-8b75-498d532d8d1a-0', usage_metadata={'input_tokens': 1168, 'output_tokens': 876, 'total_tokens': 2044})]}}\n",
       "---\n",
@@ -478,7 +478,7 @@
       "The relevance of the Little Prince's message is well-articulated in this paragraph. To further strengthen your argument, consider discussing the consequences of ignoring this message in the context of modern society. This will help emphasize the importance of the Little Prince's wisdom and its relevance to contemporary issues.\n",
       "\n",
       "Body Paragraph 3 - The Critique of Modern Society:\n",
-      "This paragraph effectively highlights the story's critique of modern society. To deepen your analysis, explore how themes of materialism, consumerism, and the pursuit of power interconnect and contribute to the challenges faced by modern society. Additionally, consider discussing potential solutions or actions inspired by the Little Prince's message that could help address these issues.\n",
+      "This paragraph effectively highlights the story's critique of modern society. To deepen your analysis, explore how the themes of materialism, consumerism, and the pursuit of power interconnect and contribute to the challenges faced by modern society. Additionally, consider discussing potential solutions or actions inspired by the Little Prince's message that could help address these issues.\n",
       "\n",
       "Conclusion:\n",
       "The conclusion effectively summarizes the main points of the essay and emphasizes the relevance of \"The Little Prince\" in modern life. To further enhance this section, consider incorporating a thought-provoking question or statement that encourages readers to reflect on the story's message and its implications for their own lives.\n",

docs/mkdocs.yml

@@ -179,10 +179,12 @@ nav:
           - cloud/how-tos/studio/manage_assistants.md
           - cloud/how-tos/threads_studio.md
           - cloud/how-tos/iterate_graph_studio.md
+          - cloud/how-tos/studio/run_evals.md
           - cloud/how-tos/clone_traces_studio.md
           - cloud/how-tos/datasets_studio.md
         - LangGraph SDK: concepts/sdk.md
       - Data management:
+        - Data storage & privacy: concepts/data_storage_and_privacy.md
         - Add semantic search: cloud/deployment/semantic_search.md
         - Add TTLs: how-tos/ttl/configure_ttl.md
       - Authentication & access control:
@@ -364,16 +366,6 @@ markdown_extensions:
 hooks:
   - _scripts/notebook_hooks.py
 extra:
-  consent:
-    title: Cookie consent
-    actions:
-      - accept
-      - reject
-    description: >- 
-      We use cookies to recognize your repeated visits and preferences, as well
-      as to measure the effectiveness of our documentation and whether users
-      find what they're searching for. <strong>Clicking "Accept" makes our
-      documentation better. Thank you!</strong> ❤️
   social:
     - icon: fontawesome/brands/js
       link: https://langchain-ai.github.io/langgraphjs/
@@ -381,25 +373,6 @@ extra:
       link: https://github.com/langchain-ai/langgraph
     - icon: fontawesome/brands/twitter
       link: https://twitter.com/LangChainAI
-  analytics:
-    provider: google
-    property: G-G8X6ELZYE0
-    feedback:
-      title: Was this page helpful?
-      ratings:
-        - icon: material/emoticon-happy-outline
-          name: This page was helpful
-          data: 1
-          note: >-
-            Thanks for your feedback!
-        - icon: material/emoticon-sad-outline
-          name: This page could be improved
-          data: 0
-          note: >-
-            Thanks for your feedback! Please help us improve this page by adding to the discussion below.
-  shared_analytics:
-    provider: google
-    property: G-47WX3HKKY2
 validation:
   # https://www.mkdocs.org/user-guide/configuration/
   # We are still raising for omitted files because they determine the breadcrumbs for pages.

libs/checkpoint-postgres/README.md

@@ -25,7 +25,7 @@ with PostgresSaver.from_conn_string(DB_URI) as checkpointer:
     # call .setup() the first time you're using the checkpointer
     checkpointer.setup()
     checkpoint = {
-        "v": 4,
+        "v": 2,
         "ts": "2024-07-31T20:14:19.804150+00:00",
         "id": "1ef4f797-8335-6428-8001-8a1503f9b875",
         "channel_values": {
@@ -47,6 +47,7 @@ with PostgresSaver.from_conn_string(DB_URI) as checkpointer:
             "start:node": 2
             }
         },
+        "pending_sends": [],
     }
 
     # store checkpoint
@@ -66,7 +67,7 @@ from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver
 
 async with AsyncPostgresSaver.from_conn_string(DB_URI) as checkpointer:
     checkpoint = {
-        "v": 4,
+        "v": 2,
         "ts": "2024-07-31T20:14:19.804150+00:00",
         "id": "1ef4f797-8335-6428-8001-8a1503f9b875",
         "channel_values": {
@@ -88,6 +89,7 @@ async with AsyncPostgresSaver.from_conn_string(DB_URI) as checkpointer:
             "start:node": 2
             }
         },
+        "pending_sends": [],
     }
 
     # store checkpoint

libs/checkpoint-postgres/langgraph/checkpoint/postgres/__init__.py

@@ -1,5 +1,4 @@
 import threading
-from collections import defaultdict
 from collections.abc import Iterator, Sequence
 from contextlib import contextmanager
 from typing import Any, Optional
@@ -21,6 +20,7 @@ from langgraph.checkpoint.base import (
 )
 from langgraph.checkpoint.postgres import _internal
 from langgraph.checkpoint.postgres.base import BasePostgresSaver
+from langgraph.checkpoint.postgres.shallow import ShallowPostgresSaver
 from langgraph.checkpoint.serde.base import SerializerProtocol
 
 Conn = _internal.Conn  # For backward compatibility
@@ -143,36 +143,8 @@ class PostgresSaver(BasePostgresSaver):
             query += f" LIMIT {limit}"
         # if we change this to use .stream() we need to make sure to close the cursor
         with self._cursor() as cur:
-            cur.execute(query, args)
-            values = cur.fetchall()
-            if not values:
-                return
-            # migrate pending sends if necessary
-            if to_migrate := [
-                v
-                for v in values
-                if v["checkpoint"]["v"] < 4 and v["parent_checkpoint_id"]
-            ]:
-                cur.execute(
-                    self.SELECT_PENDING_SENDS_SQL,
-                    (
-                        values[0]["thread_id"],
-                        [v["parent_checkpoint_id"] for v in to_migrate],
-                    ),
-                )
-                grouped_by_parent = defaultdict(list)
-                for value in to_migrate:
-                    grouped_by_parent[value["parent_checkpoint_id"]].append(value)
-                for sends in cur:
-                    for value in grouped_by_parent[sends["checkpoint_id"]]:
-                        if value["channel_values"] is None:
-                            value["channel_values"] = []
-                        self._migrate_pending_sends(
-                            sends["sends"],
-                            value["checkpoint"],
-                            value["channel_values"],
-                        )
-            for value in values:
+            cur.execute(query, args, binary=True)
+            for value in cur:
                 yield CheckpointTuple(
                     {
                         "configurable": {
@@ -181,11 +153,12 @@ class PostgresSaver(BasePostgresSaver):
                             "checkpoint_id": value["checkpoint_id"],
                         }
                     },
-                    {
-                        **value["checkpoint"],
-                        "channel_values": self._load_blobs(value["channel_values"]),
-                    },
-                    value["metadata"],
+                    self._load_checkpoint(
+                        value["checkpoint"],
+                        value["channel_values"],
+                        value["pending_sends"],
+                    ),
+                    self._load_metadata(value["metadata"]),
                     (
                         {
                             "configurable": {
@@ -249,52 +222,37 @@ class PostgresSaver(BasePostgresSaver):
             cur.execute(
                 self.SELECT_SQL + where,
                 args,
+                binary=True,
             )
-            value = cur.fetchone()
-            if value is None:
-                return None
 
-            # migrate pending sends if necessary
-            if value["checkpoint"]["v"] < 4 and value["parent_checkpoint_id"]:
-                cur.execute(
-                    self.SELECT_PENDING_SENDS_SQL,
-                    (thread_id, [value["parent_checkpoint_id"]]),
-                )
-                if sends := cur.fetchone():
-                    if value["channel_values"] is None:
-                        value["channel_values"] = []
-                    self._migrate_pending_sends(
-                        sends["sends"],
-                        value["checkpoint"],
-                        value["channel_values"],
-                    )
-
-            return CheckpointTuple(
-                {
-                    "configurable": {
-                        "thread_id": thread_id,
-                        "checkpoint_ns": checkpoint_ns,
-                        "checkpoint_id": value["checkpoint_id"],
-                    }
-                },
-                {
-                    **value["checkpoint"],
-                    "channel_values": self._load_blobs(value["channel_values"]),
-                },
-                value["metadata"],
-                (
+            for value in cur:
+                return CheckpointTuple(
                     {
                         "configurable": {
                             "thread_id": thread_id,
                             "checkpoint_ns": checkpoint_ns,
-                            "checkpoint_id": value["parent_checkpoint_id"],
+                            "checkpoint_id": value["checkpoint_id"],
                         }
-                    }
-                    if value["parent_checkpoint_id"]
-                    else None
-                ),
-                self._load_writes(value["pending_writes"]),
-            )
+                    },
+                    self._load_checkpoint(
+                        value["checkpoint"],
+                        value["channel_values"],
+                        value["pending_sends"],
+                    ),
+                    self._load_metadata(value["metadata"]),
+                    (
+                        {
+                            "configurable": {
+                                "thread_id": thread_id,
+                                "checkpoint_ns": checkpoint_ns,
+                                "checkpoint_id": value["parent_checkpoint_id"],
+                            }
+                        }
+                        if value["parent_checkpoint_id"]
+                        else None
+                    ),
+                    self._load_writes(value["pending_writes"]),
+                )
 
     def put(
         self,
@@ -361,8 +319,8 @@ class PostgresSaver(BasePostgresSaver):
                     checkpoint_ns,
                     checkpoint["id"],
                     checkpoint_id,
-                    Jsonb(copy),
-                    Jsonb(get_checkpoint_metadata(config, metadata)),
+                    Jsonb(self._dump_checkpoint(copy)),
+                    self._dump_metadata(get_checkpoint_metadata(config, metadata)),
                 ),
             )
         return next_config
@@ -433,7 +391,7 @@ class PostgresSaver(BasePostgresSaver):
                 Will be applied regardless of whether the PostgresSaver instance was initialized with a pipeline.
                 If pipeline mode is not supported, will fall back to using transaction context manager.
         """
-        with self.lock, _internal.get_connection(self.conn) as conn:
+        with _internal.get_connection(self.conn) as conn:
             if self.pipe:
                 # a connection in pipeline mode can be used concurrently
                 # in multiple threads/coroutines, but only one cursor can be
@@ -449,6 +407,7 @@ class PostgresSaver(BasePostgresSaver):
                 # thread/coroutine at a time, so we acquire a lock
                 if self.supports_pipeline:
                     with (
+                        self.lock,
                         conn.pipeline(),
                         conn.cursor(binary=True, row_factory=dict_row) as cur,
                     ):
@@ -456,13 +415,14 @@ class PostgresSaver(BasePostgresSaver):
                 else:
                     # Use connection's transaction context manager when pipeline mode not supported
                     with (
+                        self.lock,
                         conn.transaction(),
                         conn.cursor(binary=True, row_factory=dict_row) as cur,
                     ):
                         yield cur
             else:
-                with conn.cursor(binary=True, row_factory=dict_row) as cur:
+                with self.lock, conn.cursor(binary=True, row_factory=dict_row) as cur:
                     yield cur
 
 
-__all__ = ["PostgresSaver", "BasePostgresSaver", "Conn"]
+__all__ = ["PostgresSaver", "BasePostgresSaver", "ShallowPostgresSaver", "Conn"]

libs/checkpoint-postgres/langgraph/checkpoint/postgres/aio.py

@@ -1,5 +1,4 @@
 import asyncio
-from collections import defaultdict
 from collections.abc import AsyncIterator, Iterator, Sequence
 from contextlib import asynccontextmanager
 from typing import Any, Optional
@@ -21,6 +20,7 @@ from langgraph.checkpoint.base import (
 )
 from langgraph.checkpoint.postgres import _ainternal
 from langgraph.checkpoint.postgres.base import BasePostgresSaver
+from langgraph.checkpoint.postgres.shallow import AsyncShallowPostgresSaver
 from langgraph.checkpoint.serde.base import SerializerProtocol
 
 Conn = _ainternal.Conn  # For backward compatibility
@@ -131,35 +131,7 @@ class AsyncPostgresSaver(BasePostgresSaver):
         # if we change this to use .stream() we need to make sure to close the cursor
         async with self._cursor() as cur:
             await cur.execute(query, args, binary=True)
-            values = await cur.fetchall()
-            if not values:
-                return
-            # migrate pending sends if necessary
-            if to_migrate := [
-                v
-                for v in values
-                if v["checkpoint"]["v"] < 4 and v["parent_checkpoint_id"]
-            ]:
-                await cur.execute(
-                    self.SELECT_PENDING_SENDS_SQL,
-                    (
-                        values[0]["thread_id"],
-                        [v["parent_checkpoint_id"] for v in to_migrate],
-                    ),
-                )
-                grouped_by_parent = defaultdict(list)
-                for value in to_migrate:
-                    grouped_by_parent[value["parent_checkpoint_id"]].append(value)
-                async for sends in cur:
-                    for value in grouped_by_parent[sends["checkpoint_id"]]:
-                        if value["channel_values"] is None:
-                            value["channel_values"] = []
-                        self._migrate_pending_sends(
-                            sends["sends"],
-                            value["checkpoint"],
-                            value["channel_values"],
-                        )
-            for value in values:
+            async for value in cur:
                 yield CheckpointTuple(
                     {
                         "configurable": {
@@ -168,11 +140,13 @@ class AsyncPostgresSaver(BasePostgresSaver):
                             "checkpoint_id": value["checkpoint_id"],
                         }
                     },
-                    {
-                        **value["checkpoint"],
-                        "channel_values": self._load_blobs(value["channel_values"]),
-                    },
-                    value["metadata"],
+                    await asyncio.to_thread(
+                        self._load_checkpoint,
+                        value["checkpoint"],
+                        value["channel_values"],
+                        value["pending_sends"],
+                    ),
+                    self._load_metadata(value["metadata"]),
                     (
                         {
                             "configurable": {
@@ -217,51 +191,36 @@ class AsyncPostgresSaver(BasePostgresSaver):
                 args,
                 binary=True,
             )
-            value = await cur.fetchone()
-            if value is None:
-                return None
 
-            # migrate pending sends if necessary
-            if value["checkpoint"]["v"] < 4 and value["parent_checkpoint_id"]:
-                await cur.execute(
-                    self.SELECT_PENDING_SENDS_SQL,
-                    (thread_id, [value["parent_checkpoint_id"]]),
-                )
-                if sends := await cur.fetchone():
-                    if value["channel_values"] is None:
-                        value["channel_values"] = []
-                    self._migrate_pending_sends(
-                        sends["sends"],
-                        value["checkpoint"],
-                        value["channel_values"],
-                    )
-
-            return CheckpointTuple(
-                {
-                    "configurable": {
-                        "thread_id": thread_id,
-                        "checkpoint_ns": checkpoint_ns,
-                        "checkpoint_id": value["checkpoint_id"],
-                    }
-                },
-                {
-                    **value["checkpoint"],
-                    "channel_values": self._load_blobs(value["channel_values"]),
-                },
-                value["metadata"],
-                (
+            async for value in cur:
+                return CheckpointTuple(
                     {
                         "configurable": {
                             "thread_id": thread_id,
                             "checkpoint_ns": checkpoint_ns,
-                            "checkpoint_id": value["parent_checkpoint_id"],
+                            "checkpoint_id": value["checkpoint_id"],
                         }
-                    }
-                    if value["parent_checkpoint_id"]
-                    else None
-                ),
-                await asyncio.to_thread(self._load_writes, value["pending_writes"]),
-            )
+                    },
+                    await asyncio.to_thread(
+                        self._load_checkpoint,
+                        value["checkpoint"],
+                        value["channel_values"],
+                        value["pending_sends"],
+                    ),
+                    self._load_metadata(value["metadata"]),
+                    (
+                        {
+                            "configurable": {
+                                "thread_id": thread_id,
+                                "checkpoint_ns": checkpoint_ns,
+                                "checkpoint_id": value["parent_checkpoint_id"],
+                            }
+                        }
+                        if value["parent_checkpoint_id"]
+                        else None
+                    ),
+                    await asyncio.to_thread(self._load_writes, value["pending_writes"]),
+                )
 
     async def aput(
         self,
@@ -318,8 +277,8 @@ class AsyncPostgresSaver(BasePostgresSaver):
                     checkpoint_ns,
                     checkpoint["id"],
                     checkpoint_id,
-                    Jsonb(copy),
-                    Jsonb(get_checkpoint_metadata(config, metadata)),
+                    Jsonb(self._dump_checkpoint(copy)),
+                    self._dump_metadata(get_checkpoint_metadata(config, metadata)),
                 ),
             )
         return next_config
@@ -391,7 +350,7 @@ class AsyncPostgresSaver(BasePostgresSaver):
                 Will be applied regardless of whether the AsyncPostgresSaver instance was initialized with a pipeline.
                 If pipeline mode is not supported, will fall back to using transaction context manager.
         """
-        async with self.lock, _ainternal.get_connection(self.conn) as conn:
+        async with _ainternal.get_connection(self.conn) as conn:
             if self.pipe:
                 # a connection in pipeline mode can be used concurrently
                 # in multiple threads/coroutines, but only one cursor can be
@@ -407,6 +366,7 @@ class AsyncPostgresSaver(BasePostgresSaver):
                 # thread/coroutine at a time, so we acquire a lock
                 if self.supports_pipeline:
                     async with (
+                        self.lock,
                         conn.pipeline(),
                         conn.cursor(binary=True, row_factory=dict_row) as cur,
                     ):
@@ -414,12 +374,16 @@ class AsyncPostgresSaver(BasePostgresSaver):
                 else:
                     # Use connection's transaction context manager when pipeline mode not supported
                     async with (
+                        self.lock,
                         conn.transaction(),
                         conn.cursor(binary=True, row_factory=dict_row) as cur,
                     ):
                         yield cur
             else:
-                async with conn.cursor(binary=True, row_factory=dict_row) as cur:
+                async with (
+                    self.lock,
+                    conn.cursor(binary=True, row_factory=dict_row) as cur,
+                ):
                     yield cur
 
     def list(
@@ -568,4 +532,4 @@ class AsyncPostgresSaver(BasePostgresSaver):
         ).result()
 
 
-__all__ = ["AsyncPostgresSaver", "Conn"]
+__all__ = ["AsyncPostgresSaver", "AsyncShallowPostgresSaver", "Conn"]

libs/checkpoint-postgres/langgraph/checkpoint/postgres/base.py

@@ -9,9 +9,12 @@ from langgraph.checkpoint.base import (
     WRITES_IDX_MAP,
     BaseCheckpointSaver,
     ChannelVersions,
+    Checkpoint,
+    CheckpointMetadata,
     get_checkpoint_id,
 )
-from langgraph.checkpoint.serde.types import TASKS
+from langgraph.checkpoint.serde.jsonplus import JsonPlusSerializer
+from langgraph.checkpoint.serde.types import TASKS, ChannelProtocol
 
 MetadataInput = Optional[dict[str, Any]]
 
@@ -69,7 +72,7 @@ MIGRATIONS = [
     """ALTER TABLE checkpoint_writes ADD COLUMN task_path TEXT NOT NULL DEFAULT '';""",
 ]
 
-SELECT_SQL = """
+SELECT_SQL = f"""
 select
     thread_id,
     checkpoint,
@@ -93,20 +96,17 @@ select
         where cw.thread_id = checkpoints.thread_id
             and cw.checkpoint_ns = checkpoints.checkpoint_ns
             and cw.checkpoint_id = checkpoints.checkpoint_id
-    ) as pending_writes
+    ) as pending_writes,
+    (
+        select array_agg(array[cw.type::bytea, cw.blob] order by cw.task_path, cw.task_id, cw.idx)
+        from checkpoint_writes cw
+        where cw.thread_id = checkpoints.thread_id
+            and cw.checkpoint_ns = checkpoints.checkpoint_ns
+            and cw.checkpoint_id = checkpoints.parent_checkpoint_id
+            and cw.channel = '{TASKS}'
+    ) as pending_sends
 from checkpoints """
 
-SELECT_PENDING_SENDS_SQL = f"""
-select
-    checkpoint_id,
-    array_agg(array[type::bytea, blob] order by task_path, task_id, idx) as sends
-from checkpoint_writes
-where thread_id = %s
-    and checkpoint_id = any(%s)
-    and channel = '{TASKS}'
-group by checkpoint_id
-"""
-
 UPSERT_CHECKPOINT_BLOBS_SQL = """
     INSERT INTO checkpoint_blobs (thread_id, checkpoint_ns, channel, version, type, blob)
     VALUES (%s, %s, %s, %s, %s, %s)
@@ -140,34 +140,31 @@ INSERT_CHECKPOINT_WRITES_SQL = """
 
 class BasePostgresSaver(BaseCheckpointSaver[str]):
     SELECT_SQL = SELECT_SQL
-    SELECT_PENDING_SENDS_SQL = SELECT_PENDING_SENDS_SQL
     MIGRATIONS = MIGRATIONS
     UPSERT_CHECKPOINT_BLOBS_SQL = UPSERT_CHECKPOINT_BLOBS_SQL
     UPSERT_CHECKPOINTS_SQL = UPSERT_CHECKPOINTS_SQL
     UPSERT_CHECKPOINT_WRITES_SQL = UPSERT_CHECKPOINT_WRITES_SQL
     INSERT_CHECKPOINT_WRITES_SQL = INSERT_CHECKPOINT_WRITES_SQL
 
+    jsonplus_serde = JsonPlusSerializer()
     supports_pipeline: bool
 
-    def _migrate_pending_sends(
+    def _load_checkpoint(
         self,
-        pending_sends: list[tuple[bytes, bytes]],
         checkpoint: dict[str, Any],
         channel_values: list[tuple[bytes, bytes, bytes]],
-    ) -> None:
-        if not pending_sends:
-            return
-        # add to values
-        enc, blob = self.serde.dumps_typed(
-            [self.serde.loads_typed((c.decode(), b)) for c, b in pending_sends],
-        )
-        channel_values.append((TASKS.encode(), enc.encode(), blob))
-        # add to versions
-        checkpoint["channel_versions"][TASKS] = (
-            max(checkpoint["channel_versions"].values())
-            if checkpoint["channel_versions"]
-            else self.get_next_version(None)
-        )
+        pending_sends: list[tuple[bytes, bytes]],
+    ) -> Checkpoint:
+        return {
+            **checkpoint,
+            "pending_sends": [
+                self.serde.loads_typed((c.decode(), b)) for c, b in pending_sends or []
+            ],
+            "channel_values": self._load_blobs(channel_values),
+        }
+
+    def _dump_checkpoint(self, checkpoint: Checkpoint) -> dict[str, Any]:
+        return {**checkpoint, "pending_sends": []}
 
     def _load_blobs(
         self, blob_values: list[tuple[bytes, bytes, bytes]]
@@ -244,7 +241,15 @@ class BasePostgresSaver(BaseCheckpointSaver[str]):
             for idx, (channel, value) in enumerate(writes)
         ]
 
-    def get_next_version(self, current: Optional[str]) -> str:
+    def _load_metadata(self, metadata: dict[str, Any]) -> CheckpointMetadata:
+        return self.jsonplus_serde.loads(self.jsonplus_serde.dumps(metadata))
+
+    def _dump_metadata(self, metadata: CheckpointMetadata) -> str:
+        serialized_metadata = self.jsonplus_serde.dumps(metadata)
+        # NOTE: we're using JSON serializer (not msgpack), so we need to remove null characters before writing
+        return serialized_metadata.decode().replace("\\u0000", "")
+
+    def get_next_version(self, current: Optional[str], channel: ChannelProtocol) -> str:
         if current is None:
             current_v = 0
         elif isinstance(current, int):

libs/checkpoint-postgres/langgraph/checkpoint/postgres/shallow.py

@@ -0,0 +1,941 @@
+import asyncio
+import threading
+import warnings
+from collections.abc import AsyncIterator, Iterator, Sequence
+from contextlib import asynccontextmanager, contextmanager
+from typing import Any, Optional
+
+from langchain_core.runnables import RunnableConfig
+from psycopg import (
+    AsyncConnection,
+    AsyncCursor,
+    AsyncPipeline,
+    Capabilities,
+    Connection,
+    Cursor,
+    Pipeline,
+)
+from psycopg.rows import DictRow, dict_row
+from psycopg.types.json import Jsonb
+from psycopg_pool import AsyncConnectionPool, ConnectionPool
+
+from langgraph.checkpoint.base import (
+    WRITES_IDX_MAP,
+    ChannelVersions,
+    Checkpoint,
+    CheckpointMetadata,
+    CheckpointTuple,
+    get_checkpoint_metadata,
+)
+from langgraph.checkpoint.postgres import _ainternal, _internal
+from langgraph.checkpoint.postgres.base import BasePostgresSaver
+from langgraph.checkpoint.serde.base import SerializerProtocol
+from langgraph.checkpoint.serde.types import TASKS
+
+"""
+To add a new migration, add a new string to the MIGRATIONS list.
+The position of the migration in the list is the version number.
+"""
+MIGRATIONS = [
+    """CREATE TABLE IF NOT EXISTS checkpoint_migrations (
+    v INTEGER PRIMARY KEY
+);""",
+    """CREATE TABLE IF NOT EXISTS checkpoints (
+    thread_id TEXT NOT NULL,
+    checkpoint_ns TEXT NOT NULL DEFAULT '',
+    type TEXT,
+    checkpoint JSONB NOT NULL,
+    metadata JSONB NOT NULL DEFAULT '{}',
+    PRIMARY KEY (thread_id, checkpoint_ns)
+);""",
+    """CREATE TABLE IF NOT EXISTS checkpoint_blobs (
+    thread_id TEXT NOT NULL,
+    checkpoint_ns TEXT NOT NULL DEFAULT '',
+    channel TEXT NOT NULL,
+    type TEXT NOT NULL,
+    blob BYTEA,
+    PRIMARY KEY (thread_id, checkpoint_ns, channel)
+);""",
+    """CREATE TABLE IF NOT EXISTS checkpoint_writes (
+    thread_id TEXT NOT NULL,
+    checkpoint_ns TEXT NOT NULL DEFAULT '',
+    checkpoint_id TEXT NOT NULL,
+    task_id TEXT NOT NULL,
+    idx INTEGER NOT NULL,
+    channel TEXT NOT NULL,
+    type TEXT,
+    blob BYTEA NOT NULL,
+    PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id, task_id, idx)
+);""",
+    """
+    CREATE INDEX CONCURRENTLY IF NOT EXISTS checkpoints_thread_id_idx ON checkpoints(thread_id);
+    """,
+    """
+    CREATE INDEX CONCURRENTLY IF NOT EXISTS checkpoint_blobs_thread_id_idx ON checkpoint_blobs(thread_id);
+    """,
+    """
+    CREATE INDEX CONCURRENTLY IF NOT EXISTS checkpoint_writes_thread_id_idx ON checkpoint_writes(thread_id);
+    """,
+    """
+    ALTER TABLE checkpoint_writes ADD COLUMN task_path TEXT NOT NULL DEFAULT '';
+    """,
+]
+
+SELECT_SQL = f"""
+select
+    thread_id,
+    checkpoint,
+    checkpoint_ns,
+    metadata,
+    (
+        select array_agg(array[bl.channel::bytea, bl.type::bytea, bl.blob])
+        from jsonb_each_text(checkpoint -> 'channel_versions')
+        inner join checkpoint_blobs bl
+            on bl.thread_id = checkpoints.thread_id
+            and bl.checkpoint_ns = checkpoints.checkpoint_ns
+            and bl.channel = jsonb_each_text.key
+    ) as channel_values,
+    (
+        select
+        array_agg(array[cw.task_id::text::bytea, cw.channel::bytea, cw.type::bytea, cw.blob] order by cw.task_id, cw.idx)
+        from checkpoint_writes cw
+        where cw.thread_id = checkpoints.thread_id
+            and cw.checkpoint_ns = checkpoints.checkpoint_ns
+            and cw.checkpoint_id = (checkpoint->>'id')
+    ) as pending_writes,
+    (
+        select array_agg(array[cw.type::bytea, cw.blob] order by cw.task_path, cw.task_id, cw.idx)
+        from checkpoint_writes cw
+        where cw.thread_id = checkpoints.thread_id
+            and cw.checkpoint_ns = checkpoints.checkpoint_ns
+            and cw.channel = '{TASKS}'
+    ) as pending_sends
+from checkpoints """
+
+UPSERT_CHECKPOINT_BLOBS_SQL = """
+    INSERT INTO checkpoint_blobs (thread_id, checkpoint_ns, channel, type, blob)
+    VALUES (%s, %s, %s, %s, %s)
+    ON CONFLICT (thread_id, checkpoint_ns, channel) DO UPDATE SET
+        type = EXCLUDED.type,
+        blob = EXCLUDED.blob;
+"""
+
+UPSERT_CHECKPOINTS_SQL = """
+    INSERT INTO checkpoints (thread_id, checkpoint_ns, checkpoint, metadata)
+    VALUES (%s, %s, %s, %s)
+    ON CONFLICT (thread_id, checkpoint_ns)
+    DO UPDATE SET
+        checkpoint = EXCLUDED.checkpoint,
+        metadata = EXCLUDED.metadata;
+"""
+
+UPSERT_CHECKPOINT_WRITES_SQL = """
+    INSERT INTO checkpoint_writes (thread_id, checkpoint_ns, checkpoint_id, task_id, task_path, idx, channel, type, blob)
+    VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)
+    ON CONFLICT (thread_id, checkpoint_ns, checkpoint_id, task_id, idx) DO UPDATE SET
+        channel = EXCLUDED.channel,
+        type = EXCLUDED.type,
+        blob = EXCLUDED.blob;
+"""
+
+INSERT_CHECKPOINT_WRITES_SQL = """
+    INSERT INTO checkpoint_writes (thread_id, checkpoint_ns, checkpoint_id, task_id, task_path, idx, channel, type, blob)
+    VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)
+    ON CONFLICT (thread_id, checkpoint_ns, checkpoint_id, task_id, idx) DO NOTHING
+"""
+
+
+def _dump_blobs(
+    serde: SerializerProtocol,
+    thread_id: str,
+    checkpoint_ns: str,
+    values: dict[str, Any],
+    versions: ChannelVersions,
+) -> list[tuple[str, str, str, str, Optional[bytes]]]:
+    if not versions:
+        return []
+
+    return [
+        (
+            thread_id,
+            checkpoint_ns,
+            k,
+            *(serde.dumps_typed(values[k]) if k in values else ("empty", None)),
+        )
+        for k in versions
+    ]
+
+
+class ShallowPostgresSaver(BasePostgresSaver):
+    """A checkpoint saver that uses Postgres to store checkpoints.
+
+    This checkpointer ONLY stores the most recent checkpoint and does NOT retain any history.
+    It is meant to be a light-weight drop-in replacement for the PostgresSaver that
+    supports most of the LangGraph persistence functionality with the exception of time travel.
+    """
+
+    SELECT_SQL = SELECT_SQL
+    MIGRATIONS = MIGRATIONS
+    UPSERT_CHECKPOINT_BLOBS_SQL = UPSERT_CHECKPOINT_BLOBS_SQL
+    UPSERT_CHECKPOINTS_SQL = UPSERT_CHECKPOINTS_SQL
+    UPSERT_CHECKPOINT_WRITES_SQL = UPSERT_CHECKPOINT_WRITES_SQL
+    INSERT_CHECKPOINT_WRITES_SQL = INSERT_CHECKPOINT_WRITES_SQL
+
+    lock: threading.Lock
+
+    def __init__(
+        self,
+        conn: _internal.Conn,
+        pipe: Optional[Pipeline] = None,
+        serde: Optional[SerializerProtocol] = None,
+    ) -> None:
+        warnings.warn(
+            "ShallowPostgresSaver is deprecated as of version 2.0.20 and will be removed in 3.0.0. "
+            "Use PostgresSaver instead, and invoke the graph with `graph.invoke(..., checkpoint_during=False)`.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        super().__init__(serde=serde)
+        if isinstance(conn, ConnectionPool) and pipe is not None:
+            raise ValueError(
+                "Pipeline should be used only with a single Connection, not ConnectionPool."
+            )
+
+        self.conn = conn
+        self.pipe = pipe
+        self.lock = threading.Lock()
+        self.supports_pipeline = Capabilities().has_pipeline()
+
+    @classmethod
+    @contextmanager
+    def from_conn_string(
+        cls, conn_string: str, *, pipeline: bool = False
+    ) -> Iterator["ShallowPostgresSaver"]:
+        """Create a new ShallowPostgresSaver instance from a connection string.
+
+        Args:
+            conn_string: The Postgres connection info string.
+            pipeline: whether to use Pipeline
+
+        Returns:
+            ShallowPostgresSaver: A new ShallowPostgresSaver instance.
+        """
+        with Connection.connect(
+            conn_string, autocommit=True, prepare_threshold=0, row_factory=dict_row
+        ) as conn:
+            if pipeline:
+                with conn.pipeline() as pipe:
+                    yield cls(conn, pipe)
+            else:
+                yield cls(conn)
+
+    def setup(self) -> None:
+        """Set up the checkpoint database asynchronously.
+
+        This method creates the necessary tables in the Postgres database if they don't
+        already exist and runs database migrations. It MUST be called directly by the user
+        the first time checkpointer is used.
+        """
+        with self._cursor() as cur:
+            cur.execute(self.MIGRATIONS[0])
+            results = cur.execute(
+                "SELECT v FROM checkpoint_migrations ORDER BY v DESC LIMIT 1"
+            )
+            row = results.fetchone()
+            if row is None:
+                version = -1
+            else:
+                version = row["v"]
+            for v, migration in zip(
+                range(version + 1, len(self.MIGRATIONS)),
+                self.MIGRATIONS[version + 1 :],
+            ):
+                cur.execute(migration)
+                cur.execute(f"INSERT INTO checkpoint_migrations (v) VALUES ({v})")
+        if self.pipe:
+            self.pipe.sync()
+
+    def list(
+        self,
+        config: Optional[RunnableConfig],
+        *,
+        filter: Optional[dict[str, Any]] = None,
+        before: Optional[RunnableConfig] = None,
+        limit: Optional[int] = None,
+    ) -> Iterator[CheckpointTuple]:
+        """List checkpoints from the database.
+
+        This method retrieves a list of checkpoint tuples from the Postgres database based
+        on the provided config. For ShallowPostgresSaver, this method returns a list with
+        ONLY the most recent checkpoint.
+        """
+        where, args = self._search_where(config, filter, before)
+        query = self.SELECT_SQL + where
+        if limit:
+            query += f" LIMIT {limit}"
+        with self._cursor() as cur:
+            cur.execute(self.SELECT_SQL + where, args, binary=True)
+            for value in cur:
+                checkpoint = self._load_checkpoint(
+                    value["checkpoint"],
+                    value["channel_values"],
+                    value["pending_sends"],
+                )
+                yield CheckpointTuple(
+                    config={
+                        "configurable": {
+                            "thread_id": value["thread_id"],
+                            "checkpoint_ns": value["checkpoint_ns"],
+                            "checkpoint_id": checkpoint["id"],
+                        }
+                    },
+                    checkpoint=checkpoint,
+                    metadata=self._load_metadata(value["metadata"]),
+                    pending_writes=self._load_writes(value["pending_writes"]),
+                )
+
+    def get_tuple(self, config: RunnableConfig) -> Optional[CheckpointTuple]:
+        """Get a checkpoint tuple from the database.
+
+        This method retrieves a checkpoint tuple from the Postgres database based on the
+        provided config (matching the thread ID in the config).
+
+        Args:
+            config: The config to use for retrieving the checkpoint.
+
+        Returns:
+            Optional[CheckpointTuple]: The retrieved checkpoint tuple, or None if no matching checkpoint was found.
+
+        Examples:
+
+            Basic:
+            >>> config = {"configurable": {"thread_id": "1"}}
+            >>> checkpoint_tuple = memory.get_tuple(config)
+            >>> print(checkpoint_tuple)
+            CheckpointTuple(...)
+
+            With timestamp:
+
+            >>> config = {
+            ...    "configurable": {
+            ...        "thread_id": "1",
+            ...        "checkpoint_ns": "",
+            ...        "checkpoint_id": "1ef4f797-8335-6428-8001-8a1503f9b875",
+            ...    }
+            ... }
+            >>> checkpoint_tuple = memory.get_tuple(config)
+            >>> print(checkpoint_tuple)
+            CheckpointTuple(...)
+        """  # noqa
+        thread_id = config["configurable"]["thread_id"]
+        checkpoint_ns = config["configurable"].get("checkpoint_ns", "")
+        args = (thread_id, checkpoint_ns)
+        where = "WHERE thread_id = %s AND checkpoint_ns = %s"
+
+        with self._cursor() as cur:
+            cur.execute(
+                self.SELECT_SQL + where,
+                args,
+                binary=True,
+            )
+
+            for value in cur:
+                checkpoint = self._load_checkpoint(
+                    value["checkpoint"],
+                    value["channel_values"],
+                    value["pending_sends"],
+                )
+                return CheckpointTuple(
+                    config={
+                        "configurable": {
+                            "thread_id": thread_id,
+                            "checkpoint_ns": checkpoint_ns,
+                            "checkpoint_id": checkpoint["id"],
+                        }
+                    },
+                    checkpoint=checkpoint,
+                    metadata=self._load_metadata(value["metadata"]),
+                    pending_writes=self._load_writes(value["pending_writes"]),
+                )
+
+    def put(
+        self,
+        config: RunnableConfig,
+        checkpoint: Checkpoint,
+        metadata: CheckpointMetadata,
+        new_versions: ChannelVersions,
+    ) -> RunnableConfig:
+        """Save a checkpoint to the database.
+
+        This method saves a checkpoint to the Postgres database. The checkpoint is associated
+        with the provided config. For ShallowPostgresSaver, this method saves ONLY the most recent
+        checkpoint and overwrites a previous checkpoint, if it exists.
+
+        Args:
+            config: The config to associate with the checkpoint.
+            checkpoint: The checkpoint to save.
+            metadata: Additional metadata to save with the checkpoint.
+            new_versions: New channel versions as of this write.
+
+        Returns:
+            RunnableConfig: Updated configuration after storing the checkpoint.
+
+        Examples:
+
+            >>> from langgraph.checkpoint.postgres import ShallowPostgresSaver
+            >>> DB_URI = "postgres://postgres:postgres@localhost:5432/postgres?sslmode=disable"
+            >>> with ShallowPostgresSaver.from_conn_string(DB_URI) as memory:
+            >>>     config = {"configurable": {"thread_id": "1", "checkpoint_ns": ""}}
+            >>>     checkpoint = {"ts": "2024-05-04T06:32:42.235444+00:00", "id": "1ef4f797-8335-6428-8001-8a1503f9b875", "channel_values": {"key": "value"}}
+            >>>     saved_config = memory.put(config, checkpoint, {"source": "input", "step": 1, "writes": {"key": "value"}}, {})
+            >>> print(saved_config)
+            {'configurable': {'thread_id': '1', 'checkpoint_ns': '', 'checkpoint_id': '1ef4f797-8335-6428-8001-8a1503f9b875'}}
+        """
+        configurable = config["configurable"].copy()
+        thread_id = configurable.pop("thread_id")
+        checkpoint_ns = configurable.pop("checkpoint_ns")
+
+        copy = checkpoint.copy()
+        next_config = {
+            "configurable": {
+                "thread_id": thread_id,
+                "checkpoint_ns": checkpoint_ns,
+                "checkpoint_id": checkpoint["id"],
+            }
+        }
+
+        with self._cursor(pipeline=True) as cur:
+            cur.execute(
+                """DELETE FROM checkpoint_writes
+                WHERE thread_id = %s AND checkpoint_ns = %s AND checkpoint_id NOT IN (%s, %s)""",
+                (
+                    thread_id,
+                    checkpoint_ns,
+                    checkpoint["id"],
+                    configurable.get("checkpoint_id", ""),
+                ),
+            )
+            cur.executemany(
+                self.UPSERT_CHECKPOINT_BLOBS_SQL,
+                _dump_blobs(
+                    self.serde,
+                    thread_id,
+                    checkpoint_ns,
+                    copy.pop("channel_values"),  # type: ignore[misc]
+                    new_versions,
+                ),
+            )
+            cur.execute(
+                self.UPSERT_CHECKPOINTS_SQL,
+                (
+                    thread_id,
+                    checkpoint_ns,
+                    Jsonb(self._dump_checkpoint(copy)),
+                    self._dump_metadata(get_checkpoint_metadata(config, metadata)),
+                ),
+            )
+        return next_config
+
+    def put_writes(
+        self,
+        config: RunnableConfig,
+        writes: Sequence[tuple[str, Any]],
+        task_id: str,
+        task_path: str = "",
+    ) -> None:
+        """Store intermediate writes linked to a checkpoint.
+
+        This method saves intermediate writes associated with a checkpoint to the Postgres database.
+
+        Args:
+            config: Configuration of the related checkpoint.
+            writes: List of writes to store.
+            task_id: Identifier for the task creating the writes.
+        """
+        query = (
+            self.UPSERT_CHECKPOINT_WRITES_SQL
+            if all(w[0] in WRITES_IDX_MAP for w in writes)
+            else self.INSERT_CHECKPOINT_WRITES_SQL
+        )
+        with self._cursor(pipeline=True) as cur:
+            cur.executemany(
+                query,
+                self._dump_writes(
+                    config["configurable"]["thread_id"],
+                    config["configurable"]["checkpoint_ns"],
+                    config["configurable"]["checkpoint_id"],
+                    task_id,
+                    task_path,
+                    writes,
+                ),
+            )
+
+    @contextmanager
+    def _cursor(self, *, pipeline: bool = False) -> Iterator[Cursor[DictRow]]:
+        """Create a database cursor as a context manager.
+
+        Args:
+            pipeline: whether to use pipeline for the DB operations inside the context manager.
+                Will be applied regardless of whether the ShallowPostgresSaver instance was initialized with a pipeline.
+                If pipeline mode is not supported, will fall back to using transaction context manager.
+        """
+        with _internal.get_connection(self.conn) as conn:
+            if self.pipe:
+                # a connection in pipeline mode can be used concurrently
+                # in multiple threads/coroutines, but only one cursor can be
+                # used at a time
+                try:
+                    with conn.cursor(binary=True, row_factory=dict_row) as cur:
+                        yield cur
+                finally:
+                    if pipeline:
+                        self.pipe.sync()
+            elif pipeline:
+                # a connection not in pipeline mode can only be used by one
+                # thread/coroutine at a time, so we acquire a lock
+                if self.supports_pipeline:
+                    with (
+                        self.lock,
+                        conn.pipeline(),
+                        conn.cursor(binary=True, row_factory=dict_row) as cur,
+                    ):
+                        yield cur
+                else:
+                    # Use connection's transaction context manager when pipeline mode not supported
+                    with (
+                        self.lock,
+                        conn.transaction(),
+                        conn.cursor(binary=True, row_factory=dict_row) as cur,
+                    ):
+                        yield cur
+            else:
+                with self.lock, conn.cursor(binary=True, row_factory=dict_row) as cur:
+                    yield cur
+
+
+class AsyncShallowPostgresSaver(BasePostgresSaver):
+    """A checkpoint saver that uses Postgres to store checkpoints asynchronously.
+
+    This checkpointer ONLY stores the most recent checkpoint and does NOT retain any history.
+    It is meant to be a light-weight drop-in replacement for the AsyncPostgresSaver that
+    supports most of the LangGraph persistence functionality with the exception of time travel.
+    """
+
+    SELECT_SQL = SELECT_SQL
+    MIGRATIONS = MIGRATIONS
+    UPSERT_CHECKPOINT_BLOBS_SQL = UPSERT_CHECKPOINT_BLOBS_SQL
+    UPSERT_CHECKPOINTS_SQL = UPSERT_CHECKPOINTS_SQL
+    UPSERT_CHECKPOINT_WRITES_SQL = UPSERT_CHECKPOINT_WRITES_SQL
+    INSERT_CHECKPOINT_WRITES_SQL = INSERT_CHECKPOINT_WRITES_SQL
+    lock: asyncio.Lock
+
+    def __init__(
+        self,
+        conn: _ainternal.Conn,
+        pipe: Optional[AsyncPipeline] = None,
+        serde: Optional[SerializerProtocol] = None,
+    ) -> None:
+        warnings.warn(
+            "AsyncShallowPostgresSaver is deprecated as of version 2.0.20 and will be removed in 3.0.0. "
+            "Use AsyncPostgresSaver instead, and invoke the graph with `await graph.ainvoke(..., checkpoint_during=False)`.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        super().__init__(serde=serde)
+        if isinstance(conn, AsyncConnectionPool) and pipe is not None:
+            raise ValueError(
+                "Pipeline should be used only with a single AsyncConnection, not AsyncConnectionPool."
+            )
+
+        self.conn = conn
+        self.pipe = pipe
+        self.lock = asyncio.Lock()
+        self.loop = asyncio.get_running_loop()
+        self.supports_pipeline = Capabilities().has_pipeline()
+
+    @classmethod
+    @asynccontextmanager
+    async def from_conn_string(
+        cls,
+        conn_string: str,
+        *,
+        pipeline: bool = False,
+        serde: Optional[SerializerProtocol] = None,
+    ) -> AsyncIterator["AsyncShallowPostgresSaver"]:
+        """Create a new AsyncShallowPostgresSaver instance from a connection string.
+
+        Args:
+            conn_string: The Postgres connection info string.
+            pipeline: whether to use AsyncPipeline
+
+        Returns:
+            AsyncShallowPostgresSaver: A new AsyncShallowPostgresSaver instance.
+        """
+        async with await AsyncConnection.connect(
+            conn_string, autocommit=True, prepare_threshold=0, row_factory=dict_row
+        ) as conn:
+            if pipeline:
+                async with conn.pipeline() as pipe:
+                    yield cls(conn=conn, pipe=pipe, serde=serde)
+            else:
+                yield cls(conn=conn, serde=serde)
+
+    async def setup(self) -> None:
+        """Set up the checkpoint database asynchronously.
+
+        This method creates the necessary tables in the Postgres database if they don't
+        already exist and runs database migrations. It MUST be called directly by the user
+        the first time checkpointer is used.
+        """
+        async with self._cursor() as cur:
+            await cur.execute(self.MIGRATIONS[0])
+            results = await cur.execute(
+                "SELECT v FROM checkpoint_migrations ORDER BY v DESC LIMIT 1"
+            )
+            row = await results.fetchone()
+            if row is None:
+                version = -1
+            else:
+                version = row["v"]
+            for v, migration in zip(
+                range(version + 1, len(self.MIGRATIONS)),
+                self.MIGRATIONS[version + 1 :],
+            ):
+                await cur.execute(migration)
+                await cur.execute(f"INSERT INTO checkpoint_migrations (v) VALUES ({v})")
+        if self.pipe:
+            await self.pipe.sync()
+
+    async def alist(
+        self,
+        config: Optional[RunnableConfig],
+        *,
+        filter: Optional[dict[str, Any]] = None,
+        before: Optional[RunnableConfig] = None,
+        limit: Optional[int] = None,
+    ) -> AsyncIterator[CheckpointTuple]:
+        """List checkpoints from the database asynchronously.
+
+        This method retrieves a list of checkpoint tuples from the Postgres database based
+        on the provided config. For ShallowPostgresSaver, this method returns a list with
+        ONLY the most recent checkpoint.
+        """
+        where, args = self._search_where(config, filter, before)
+        query = self.SELECT_SQL + where
+        if limit:
+            query += f" LIMIT {limit}"
+        async with self._cursor() as cur:
+            await cur.execute(self.SELECT_SQL + where, args, binary=True)
+            async for value in cur:
+                checkpoint = await asyncio.to_thread(
+                    self._load_checkpoint,
+                    value["checkpoint"],
+                    value["channel_values"],
+                    value["pending_sends"],
+                )
+                yield CheckpointTuple(
+                    config={
+                        "configurable": {
+                            "thread_id": value["thread_id"],
+                            "checkpoint_ns": value["checkpoint_ns"],
+                            "checkpoint_id": checkpoint["id"],
+                        }
+                    },
+                    checkpoint=checkpoint,
+                    metadata=self._load_metadata(value["metadata"]),
+                    pending_writes=await asyncio.to_thread(
+                        self._load_writes, value["pending_writes"]
+                    ),
+                )
+
+    async def aget_tuple(self, config: RunnableConfig) -> Optional[CheckpointTuple]:
+        """Get a checkpoint tuple from the database asynchronously.
+
+        This method retrieves a checkpoint tuple from the Postgres database based on the
+        provided config (matching the thread ID in the config).
+
+        Args:
+            config: The config to use for retrieving the checkpoint.
+
+        Returns:
+            Optional[CheckpointTuple]: The retrieved checkpoint tuple, or None if no matching checkpoint was found.
+        """
+        thread_id = config["configurable"]["thread_id"]
+        checkpoint_ns = config["configurable"].get("checkpoint_ns", "")
+        args = (thread_id, checkpoint_ns)
+        where = "WHERE thread_id = %s AND checkpoint_ns = %s"
+
+        async with self._cursor() as cur:
+            await cur.execute(
+                self.SELECT_SQL + where,
+                args,
+                binary=True,
+            )
+
+            async for value in cur:
+                checkpoint = await asyncio.to_thread(
+                    self._load_checkpoint,
+                    value["checkpoint"],
+                    value["channel_values"],
+                    value["pending_sends"],
+                )
+                return CheckpointTuple(
+                    config={
+                        "configurable": {
+                            "thread_id": thread_id,
+                            "checkpoint_ns": checkpoint_ns,
+                            "checkpoint_id": checkpoint["id"],
+                        }
+                    },
+                    checkpoint=checkpoint,
+                    metadata=self._load_metadata(value["metadata"]),
+                    pending_writes=await asyncio.to_thread(
+                        self._load_writes, value["pending_writes"]
+                    ),
+                )
+
+    async def aput(
+        self,
+        config: RunnableConfig,
+        checkpoint: Checkpoint,
+        metadata: CheckpointMetadata,
+        new_versions: ChannelVersions,
+    ) -> RunnableConfig:
+        """Save a checkpoint to the database asynchronously.
+
+        This method saves a checkpoint to the Postgres database. The checkpoint is associated
+        with the provided config. For AsyncShallowPostgresSaver, this method saves ONLY the most recent
+        checkpoint and overwrites a previous checkpoint, if it exists.
+
+        Args:
+            config: The config to associate with the checkpoint.
+            checkpoint: The checkpoint to save.
+            metadata: Additional metadata to save with the checkpoint.
+            new_versions: New channel versions as of this write.
+
+        Returns:
+            RunnableConfig: Updated configuration after storing the checkpoint.
+        """
+        configurable = config["configurable"].copy()
+        thread_id = configurable.pop("thread_id")
+        checkpoint_ns = configurable.pop("checkpoint_ns")
+
+        copy = checkpoint.copy()
+        next_config = {
+            "configurable": {
+                "thread_id": thread_id,
+                "checkpoint_ns": checkpoint_ns,
+                "checkpoint_id": checkpoint["id"],
+            }
+        }
+
+        async with self._cursor(pipeline=True) as cur:
+            await cur.execute(
+                """DELETE FROM checkpoint_writes
+                WHERE thread_id = %s AND checkpoint_ns = %s AND checkpoint_id NOT IN (%s, %s)""",
+                (
+                    thread_id,
+                    checkpoint_ns,
+                    checkpoint["id"],
+                    configurable.get("checkpoint_id", ""),
+                ),
+            )
+            await cur.executemany(
+                self.UPSERT_CHECKPOINT_BLOBS_SQL,
+                _dump_blobs(
+                    self.serde,
+                    thread_id,
+                    checkpoint_ns,
+                    copy.pop("channel_values"),  # type: ignore[misc]
+                    new_versions,
+                ),
+            )
+            await cur.execute(
+                self.UPSERT_CHECKPOINTS_SQL,
+                (
+                    thread_id,
+                    checkpoint_ns,
+                    Jsonb(self._dump_checkpoint(copy)),
+                    self._dump_metadata(get_checkpoint_metadata(config, metadata)),
+                ),
+            )
+        return next_config
+
+    async def aput_writes(
+        self,
+        config: RunnableConfig,
+        writes: Sequence[tuple[str, Any]],
+        task_id: str,
+        task_path: str = "",
+    ) -> None:
+        """Store intermediate writes linked to a checkpoint asynchronously.
+
+        This method saves intermediate writes associated with a checkpoint to the database.
+
+        Args:
+            config: Configuration of the related checkpoint.
+            writes: List of writes to store, each as (channel, value) pair.
+            task_id: Identifier for the task creating the writes.
+        """
+        query = (
+            self.UPSERT_CHECKPOINT_WRITES_SQL
+            if all(w[0] in WRITES_IDX_MAP for w in writes)
+            else self.INSERT_CHECKPOINT_WRITES_SQL
+        )
+        params = await asyncio.to_thread(
+            self._dump_writes,
+            config["configurable"]["thread_id"],
+            config["configurable"]["checkpoint_ns"],
+            config["configurable"]["checkpoint_id"],
+            task_id,
+            task_path,
+            writes,
+        )
+        async with self._cursor(pipeline=True) as cur:
+            await cur.executemany(query, params)
+
+    @asynccontextmanager
+    async def _cursor(
+        self, *, pipeline: bool = False
+    ) -> AsyncIterator[AsyncCursor[DictRow]]:
+        """Create a database cursor as a context manager.
+
+        Args:
+            pipeline: whether to use pipeline for the DB operations inside the context manager.
+                Will be applied regardless of whether the AsyncShallowPostgresSaver instance was initialized with a pipeline.
+                If pipeline mode is not supported, will fall back to using transaction context manager.
+        """
+        async with _ainternal.get_connection(self.conn) as conn:
+            if self.pipe:
+                # a connection in pipeline mode can be used concurrently
+                # in multiple threads/coroutines, but only one cursor can be
+                # used at a time
+                try:
+                    async with conn.cursor(binary=True, row_factory=dict_row) as cur:
+                        yield cur
+                finally:
+                    if pipeline:
+                        await self.pipe.sync()
+            elif pipeline:
+                # a connection not in pipeline mode can only be used by one
+                # thread/coroutine at a time, so we acquire a lock
+                if self.supports_pipeline:
+                    async with (
+                        self.lock,
+                        conn.pipeline(),
+                        conn.cursor(binary=True, row_factory=dict_row) as cur,
+                    ):
+                        yield cur
+                else:
+                    # Use connection's transaction context manager when pipeline mode not supported
+                    async with (
+                        self.lock,
+                        conn.transaction(),
+                        conn.cursor(binary=True, row_factory=dict_row) as cur,
+                    ):
+                        yield cur
+            else:
+                async with (
+                    self.lock,
+                    conn.cursor(binary=True, row_factory=dict_row) as cur,
+                ):
+                    yield cur
+
+    def list(
+        self,
+        config: Optional[RunnableConfig],
+        *,
+        filter: Optional[dict[str, Any]] = None,
+        before: Optional[RunnableConfig] = None,
+        limit: Optional[int] = None,
+    ) -> Iterator[CheckpointTuple]:
+        """List checkpoints from the database.
+
+        This method retrieves a list of checkpoint tuples from the Postgres database based
+        on the provided config. For ShallowPostgresSaver, this method returns a list with
+        ONLY the most recent checkpoint.
+        """
+        aiter_ = self.alist(config, filter=filter, before=before, limit=limit)
+        while True:
+            try:
+                yield asyncio.run_coroutine_threadsafe(
+                    anext(aiter_),  # noqa: F821
+                    self.loop,
+                ).result()
+            except StopAsyncIteration:
+                break
+
+    def get_tuple(self, config: RunnableConfig) -> Optional[CheckpointTuple]:
+        """Get a checkpoint tuple from the database.
+
+        This method retrieves a checkpoint tuple from the Postgres database based on the
+        provided config (matching the thread ID in the config).
+
+        Args:
+            config: The config to use for retrieving the checkpoint.
+
+        Returns:
+            Optional[CheckpointTuple]: The retrieved checkpoint tuple, or None if no matching checkpoint was found.
+        """
+        try:
+            # check if we are in the main thread, only bg threads can block
+            # we don't check in other methods to avoid the overhead
+            if asyncio.get_running_loop() is self.loop:
+                raise asyncio.InvalidStateError(
+                    "Synchronous calls to AsyncShallowPostgresSaver are only allowed from a "
+                    "different thread. From the main thread, use the async interface."
+                    "For example, use `await checkpointer.aget_tuple(...)` or `await "
+                    "graph.ainvoke(...)`."
+                )
+        except RuntimeError:
+            pass
+        return asyncio.run_coroutine_threadsafe(
+            self.aget_tuple(config), self.loop
+        ).result()
+
+    def put(
+        self,
+        config: RunnableConfig,
+        checkpoint: Checkpoint,
+        metadata: CheckpointMetadata,
+        new_versions: ChannelVersions,
+    ) -> RunnableConfig:
+        """Save a checkpoint to the database.
+
+        This method saves a checkpoint to the Postgres database. The checkpoint is associated
+        with the provided config. For AsyncShallowPostgresSaver, this method saves ONLY the most recent
+        checkpoint and overwrites a previous checkpoint, if it exists.
+
+        Args:
+            config: The config to associate with the checkpoint.
+            checkpoint: The checkpoint to save.
+            metadata: Additional metadata to save with the checkpoint.
+            new_versions: New channel versions as of this write.
+
+        Returns:
+            RunnableConfig: Updated configuration after storing the checkpoint.
+        """
+        return asyncio.run_coroutine_threadsafe(
+            self.aput(config, checkpoint, metadata, new_versions), self.loop
+        ).result()
+
+    def put_writes(
+        self,
+        config: RunnableConfig,
+        writes: Sequence[tuple[str, Any]],
+        task_id: str,
+        task_path: str = "",
+    ) -> None:
+        """Store intermediate writes linked to a checkpoint.
+
+        This method saves intermediate writes associated with a checkpoint to the database.
+
+        Args:
+            config: Configuration of the related checkpoint.
+            writes: List of writes to store, each as (channel, value) pair.
+            task_id: Identifier for the task creating the writes.
+            task_path: Path of the task creating the writes.
+        """
+        return asyncio.run_coroutine_threadsafe(
+            self.aput_writes(config, writes, task_id, task_path), self.loop
+        ).result()

libs/checkpoint-postgres/tests/checkpoint_utils.py

@@ -1,51 +0,0 @@
-from collections.abc import Mapping
-from datetime import datetime, timezone
-from typing import Any, Optional, Protocol
-
-from langgraph.checkpoint.base import Checkpoint, EmptyChannelError
-from langgraph.checkpoint.base.id import uuid6
-
-
-class ChannelProtocol(Protocol):
-    def checkpoint(self) -> Optional[Any]: ...
-
-
-def empty_checkpoint() -> Checkpoint:
-    return Checkpoint(
-        v=1,
-        id=str(uuid6(clock_seq=-2)),
-        ts=datetime.now(timezone.utc).isoformat(),
-        channel_values={},
-        channel_versions={},
-        versions_seen={},
-    )
-
-
-def create_checkpoint(
-    checkpoint: Checkpoint,
-    channels: Optional[Mapping[str, ChannelProtocol]],
-    step: int,
-    *,
-    id: Optional[str] = None,
-) -> Checkpoint:
-    """Create a checkpoint for the given channels."""
-    ts = datetime.now(timezone.utc).isoformat()
-    if channels is None:
-        values = checkpoint["channel_values"]
-    else:
-        values = {}
-        for k, v in channels.items():
-            if k not in checkpoint["channel_versions"]:
-                continue
-            try:
-                values[k] = v.checkpoint()
-            except EmptyChannelError:
-                pass
-    return Checkpoint(
-        v=1,
-        ts=ts,
-        id=id or str(uuid6(clock_seq=step)),
-        channel_values=values,
-        channel_versions=checkpoint["channel_versions"],
-        versions_seen=checkpoint["versions_seen"],
-    )

libs/checkpoint-postgres/tests/test_async.py

@@ -14,10 +14,13 @@ from langgraph.checkpoint.base import (
     EXCLUDED_METADATA_KEYS,
     Checkpoint,
     CheckpointMetadata,
+    create_checkpoint,
+    empty_checkpoint,
+)
+from langgraph.checkpoint.postgres.aio import (
+    AsyncPostgresSaver,
+    AsyncShallowPostgresSaver,
 )
-from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver
-from langgraph.checkpoint.serde.types import TASKS
-from tests.checkpoint_utils import create_checkpoint, empty_checkpoint
 from tests.conftest import DEFAULT_POSTGRES_URI
 
 
@@ -108,11 +111,41 @@ async def _base_saver():
             await conn.execute(f"DROP DATABASE {database}")
 
 
+@asynccontextmanager
+async def _shallow_saver():
+    """Fixture for shallow connection mode testing."""
+    database = f"test_{uuid4().hex[:16]}"
+    # create unique db
+    async with await AsyncConnection.connect(
+        DEFAULT_POSTGRES_URI, autocommit=True
+    ) as conn:
+        await conn.execute(f"CREATE DATABASE {database}")
+    try:
+        async with await AsyncConnection.connect(
+            DEFAULT_POSTGRES_URI + database,
+            autocommit=True,
+            prepare_threshold=0,
+            row_factory=dict_row,
+        ) as conn:
+            checkpointer = AsyncShallowPostgresSaver(conn)
+            await checkpointer.setup()
+            yield checkpointer
+    finally:
+        # drop unique db
+        async with await AsyncConnection.connect(
+            DEFAULT_POSTGRES_URI, autocommit=True
+        ) as conn:
+            await conn.execute(f"DROP DATABASE {database}")
+
+
 @asynccontextmanager
 async def _saver(name: str):
     if name == "base":
         async with _base_saver() as saver:
             yield saver
+    elif name == "shallow":
+        async with _shallow_saver() as saver:
+            yield saver
     elif name == "pool":
         async with _pool_saver() as saver:
             yield saver
@@ -172,7 +205,7 @@ def test_data():
     }
 
 
-@pytest.mark.parametrize("saver_name", ["base", "pool", "pipe"])
+@pytest.mark.parametrize("saver_name", ["base", "pool", "pipe", "shallow"])
 async def test_combined_metadata(saver_name: str, test_data) -> None:
     async with _saver(saver_name) as saver:
         config = {
@@ -199,7 +232,7 @@ async def test_combined_metadata(saver_name: str, test_data) -> None:
         }
 
 
-@pytest.mark.parametrize("saver_name", ["base", "pool", "pipe"])
+@pytest.mark.parametrize("saver_name", ["base", "pool", "pipe", "shallow"])
 async def test_asearch(saver_name: str, test_data) -> None:
     async with _saver(saver_name) as saver:
         configs = test_data["configs"]
@@ -250,7 +283,7 @@ async def test_asearch(saver_name: str, test_data) -> None:
         } == {"", "inner"}
 
 
-@pytest.mark.parametrize("saver_name", ["base", "pool", "pipe"])
+@pytest.mark.parametrize("saver_name", ["base", "pool", "pipe", "shallow"])
 async def test_null_chars(saver_name: str, test_data) -> None:
     async with _saver(saver_name) as saver:
         config = await saver.aput(
@@ -263,52 +296,3 @@ async def test_null_chars(saver_name: str, test_data) -> None:
         assert [c async for c in saver.alist(None, filter={"my_key": "abc"})][
             0
         ].metadata["my_key"] == "abc"
-
-
-@pytest.mark.parametrize("saver_name", ["base", "pool", "pipe"])
-async def test_pending_sends_migration(saver_name: str) -> None:
-    async with _saver(saver_name) as saver:
-        config = {
-            "configurable": {
-                "thread_id": "thread-1",
-                "checkpoint_ns": "",
-            }
-        }
-
-        # create the first checkpoint
-        # and put some pending sends
-        checkpoint_0 = empty_checkpoint()
-        config = await saver.aput(config, checkpoint_0, {}, {})
-        await saver.aput_writes(
-            config, [(TASKS, "send-1"), (TASKS, "send-2")], task_id="task-1"
-        )
-        await saver.aput_writes(config, [(TASKS, "send-3")], task_id="task-2")
-
-        # check that fetching checkpoint_0 doesn't attach pending sends
-        # (they should be attached to the next checkpoint)
-        tuple_0 = await saver.aget_tuple(config)
-        assert tuple_0.checkpoint["channel_values"] == {}
-        assert tuple_0.checkpoint["channel_versions"] == {}
-
-        # create the second checkpoint
-        checkpoint_1 = create_checkpoint(checkpoint_0, {}, 1)
-        config = await saver.aput(config, checkpoint_1, {}, {})
-
-        # check that pending sends are attached to checkpoint_1
-        tuple_1 = await saver.aget_tuple(config)
-        assert tuple_1.checkpoint["channel_values"] == {
-            TASKS: ["send-1", "send-2", "send-3"]
-        }
-        assert TASKS in tuple_1.checkpoint["channel_versions"]
-
-        # check that list also applies the migration
-        search_results = [
-            c async for c in saver.alist({"configurable": {"thread_id": "thread-1"}})
-        ]
-        assert len(search_results) == 2
-        assert search_results[-1].checkpoint["channel_values"] == {}
-        assert search_results[-1].checkpoint["channel_versions"] == {}
-        assert search_results[0].checkpoint["channel_values"] == {
-            TASKS: ["send-1", "send-2", "send-3"]
-        }
-        assert TASKS in search_results[0].checkpoint["channel_versions"]

libs/checkpoint-postgres/tests/test_sync.py

@@ -15,10 +15,10 @@ from langgraph.checkpoint.base import (
     EXCLUDED_METADATA_KEYS,
     Checkpoint,
     CheckpointMetadata,
+    create_checkpoint,
+    empty_checkpoint,
 )
-from langgraph.checkpoint.postgres import PostgresSaver
-from langgraph.checkpoint.serde.types import TASKS
-from tests.checkpoint_utils import create_checkpoint, empty_checkpoint
+from langgraph.checkpoint.postgres import PostgresSaver, ShallowPostgresSaver
 from tests.conftest import DEFAULT_POSTGRES_URI
 
 
@@ -97,11 +97,37 @@ def _base_saver():
             conn.execute(f"DROP DATABASE {database}")
 
 
+@contextmanager
+def _shallow_saver():
+    """Fixture for regular connection mode testing with a shallow checkpointer."""
+    database = f"test_{uuid4().hex[:16]}"
+    # create unique db
+    with Connection.connect(DEFAULT_POSTGRES_URI, autocommit=True) as conn:
+        conn.execute(f"CREATE DATABASE {database}")
+    try:
+        with Connection.connect(
+            DEFAULT_POSTGRES_URI + database,
+            autocommit=True,
+            prepare_threshold=0,
+            row_factory=dict_row,
+        ) as conn:
+            checkpointer = ShallowPostgresSaver(conn)
+            checkpointer.setup()
+            yield checkpointer
+    finally:
+        # drop unique db
+        with Connection.connect(DEFAULT_POSTGRES_URI, autocommit=True) as conn:
+            conn.execute(f"DROP DATABASE {database}")
+
+
 @contextmanager
 def _saver(name: str):
     if name == "base":
         with _base_saver() as saver:
             yield saver
+    elif name == "shallow":
+        with _shallow_saver() as saver:
+            yield saver
     elif name == "pool":
         with _pool_saver() as saver:
             yield saver
@@ -161,7 +187,7 @@ def test_data():
     }
 
 
-@pytest.mark.parametrize("saver_name", ["base", "pool", "pipe"])
+@pytest.mark.parametrize("saver_name", ["base", "pool", "pipe", "shallow"])
 def test_combined_metadata(saver_name: str, test_data) -> None:
     with _saver(saver_name) as saver:
         config = {
@@ -188,7 +214,7 @@ def test_combined_metadata(saver_name: str, test_data) -> None:
         }
 
 
-@pytest.mark.parametrize("saver_name", ["base", "pool", "pipe"])
+@pytest.mark.parametrize("saver_name", ["base", "pool", "pipe", "shallow"])
 def test_search(saver_name: str, test_data) -> None:
     with _saver(saver_name) as saver:
         configs = test_data["configs"]
@@ -237,7 +263,7 @@ def test_search(saver_name: str, test_data) -> None:
         } == {"", "inner"}
 
 
-@pytest.mark.parametrize("saver_name", ["base", "pool", "pipe"])
+@pytest.mark.parametrize("saver_name", ["base", "pool", "pipe", "shallow"])
 def test_null_chars(saver_name: str, test_data) -> None:
     with _saver(saver_name) as saver:
         config = saver.put(
@@ -258,52 +284,3 @@ def test_nonnull_migrations() -> None:
     for migration in PostgresSaver.MIGRATIONS:
         statement = _leading_comment_remover.sub("", migration).split()[0]
         assert statement.strip()
-
-
-@pytest.mark.parametrize("saver_name", ["base", "pool", "pipe"])
-def test_pending_sends_migration(saver_name: str) -> None:
-    with _saver(saver_name) as saver:
-        config = {
-            "configurable": {
-                "thread_id": "thread-1",
-                "checkpoint_ns": "",
-            }
-        }
-
-        # create the first checkpoint
-        # and put some pending sends
-        checkpoint_0 = empty_checkpoint()
-        config = saver.put(config, checkpoint_0, {}, {})
-        saver.put_writes(
-            config, [(TASKS, "send-1"), (TASKS, "send-2")], task_id="task-1"
-        )
-        saver.put_writes(config, [(TASKS, "send-3")], task_id="task-2")
-
-        # check that fetching checkpoint_0 doesn't attach pending sends
-        # (they should be attached to the next checkpoint)
-        tuple_0 = saver.get_tuple(config)
-        assert tuple_0.checkpoint["channel_values"] == {}
-        assert tuple_0.checkpoint["channel_versions"] == {}
-
-        # create the second checkpoint
-        checkpoint_1 = create_checkpoint(checkpoint_0, {}, 1)
-        config = saver.put(config, checkpoint_1, {}, {})
-
-        # check that pending sends are attached to checkpoint_1
-        checkpoint_1 = saver.get_tuple(config)
-        assert checkpoint_1.checkpoint["channel_values"] == {
-            TASKS: ["send-1", "send-2", "send-3"]
-        }
-        assert TASKS in checkpoint_1.checkpoint["channel_versions"]
-
-        # check that list also applies the migration
-        search_results = [
-            c for c in saver.list({"configurable": {"thread_id": "thread-1"}})
-        ]
-        assert len(search_results) == 2
-        assert search_results[-1].checkpoint["channel_values"] == {}
-        assert search_results[-1].checkpoint["channel_versions"] == {}
-        assert search_results[0].checkpoint["channel_values"] == {
-            TASKS: ["send-1", "send-2", "send-3"]
-        }
-        assert TASKS in search_results[0].checkpoint["channel_versions"]

libs/checkpoint-sqlite/README.md

@@ -12,7 +12,7 @@ read_config = {"configurable": {"thread_id": "1"}}
 
 with SqliteSaver.from_conn_string(":memory:") as checkpointer:
     checkpoint = {
-        "v": 4,
+        "v": 2,
         "ts": "2024-07-31T20:14:19.804150+00:00",
         "id": "1ef4f797-8335-6428-8001-8a1503f9b875",
         "channel_values": {
@@ -34,6 +34,7 @@ with SqliteSaver.from_conn_string(":memory:") as checkpointer:
                 "start:node": 2
             }
         },
+        "pending_sends": [],
     }
 
     # store checkpoint
@@ -53,7 +54,7 @@ from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
 
 async with AsyncSqliteSaver.from_conn_string(":memory:") as checkpointer:
     checkpoint = {
-        "v": 4,
+        "v": 2,
         "ts": "2024-07-31T20:14:19.804150+00:00",
         "id": "1ef4f797-8335-6428-8001-8a1503f9b875",
         "channel_values": {
@@ -75,6 +76,7 @@ async with AsyncSqliteSaver.from_conn_string(":memory:") as checkpointer:
                 "start:node": 2
             }
         },
+        "pending_sends": [],
     }
 
     # store checkpoint

libs/checkpoint-sqlite/langgraph/checkpoint/sqlite/__init__.py

@@ -19,6 +19,7 @@ from langgraph.checkpoint.base import (
     get_checkpoint_metadata,
 )
 from langgraph.checkpoint.serde.jsonplus import JsonPlusSerializer
+from langgraph.checkpoint.serde.types import ChannelProtocol
 from langgraph.checkpoint.sqlite.utils import search_where
 
 _AIO_ERROR_MSG = (
@@ -534,13 +535,14 @@ class SqliteSaver(BaseCheckpointSaver[str]):
         """
         raise NotImplementedError(_AIO_ERROR_MSG)
 
-    def get_next_version(self, current: Optional[str]) -> str:
+    def get_next_version(self, current: Optional[str], channel: ChannelProtocol) -> str:
         """Generate the next version ID for a channel.
 
         This method creates a new version identifier for a channel based on its current version.
 
         Args:
             current (Optional[str]): The current version identifier of the channel.
+            channel (BaseChannel): The channel being versioned.
 
         Returns:
             str: The next version identifier, which is guaranteed to be monotonically increasing.

libs/checkpoint-sqlite/langgraph/checkpoint/sqlite/aio.py

@@ -19,6 +19,7 @@ from langgraph.checkpoint.base import (
     get_checkpoint_metadata,
 )
 from langgraph.checkpoint.serde.jsonplus import JsonPlusSerializer
+from langgraph.checkpoint.serde.types import ChannelProtocol
 from langgraph.checkpoint.sqlite.utils import search_where
 
 T = TypeVar("T", bound=Callable)
@@ -589,13 +590,14 @@ class AsyncSqliteSaver(BaseCheckpointSaver[str]):
             )
             await self.conn.commit()
 
-    def get_next_version(self, current: Optional[str]) -> str:
+    def get_next_version(self, current: Optional[str], channel: ChannelProtocol) -> str:
         """Generate the next version ID for a channel.
 
         This method creates a new version identifier for a channel based on its current version.
 
         Args:
             current (Optional[str]): The current version identifier of the channel.
+            channel (BaseChannel): The channel being versioned.
 
         Returns:
             str: The next version identifier, which is guaranteed to be monotonically increasing.

libs/checkpoint-sqlite/tests/checkpoint_utils.py

@@ -1,51 +0,0 @@
-from collections.abc import Mapping
-from datetime import datetime, timezone
-from typing import Any, Optional, Protocol
-
-from langgraph.checkpoint.base import Checkpoint, EmptyChannelError
-from langgraph.checkpoint.base.id import uuid6
-
-
-class ChannelProtocol(Protocol):
-    def checkpoint(self) -> Optional[Any]: ...
-
-
-def empty_checkpoint() -> Checkpoint:
-    return Checkpoint(
-        v=1,
-        id=str(uuid6(clock_seq=-2)),
-        ts=datetime.now(timezone.utc).isoformat(),
-        channel_values={},
-        channel_versions={},
-        versions_seen={},
-    )
-
-
-def create_checkpoint(
-    checkpoint: Checkpoint,
-    channels: Optional[Mapping[str, ChannelProtocol]],
-    step: int,
-    *,
-    id: Optional[str] = None,
-) -> Checkpoint:
-    """Create a checkpoint for the given channels."""
-    ts = datetime.now(timezone.utc).isoformat()
-    if channels is None:
-        values = checkpoint["channel_values"]
-    else:
-        values = {}
-        for k, v in channels.items():
-            if k not in checkpoint["channel_versions"]:
-                continue
-            try:
-                values[k] = v.checkpoint()
-            except EmptyChannelError:
-                pass
-    return Checkpoint(
-        v=1,
-        ts=ts,
-        id=id or str(uuid6(clock_seq=step)),
-        channel_values=values,
-        channel_versions=checkpoint["channel_versions"],
-        versions_seen=checkpoint["versions_seen"],
-    )

libs/checkpoint-sqlite/tests/test_aiosqlite.py

@@ -6,9 +6,10 @@ from langchain_core.runnables import RunnableConfig
 from langgraph.checkpoint.base import (
     Checkpoint,
     CheckpointMetadata,
+    create_checkpoint,
+    empty_checkpoint,
 )
 from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
-from tests.checkpoint_utils import create_checkpoint, empty_checkpoint
 
 
 class TestAsyncSqliteSaver:

libs/checkpoint-sqlite/tests/test_sqlite.py

@@ -6,10 +6,11 @@ from langchain_core.runnables import RunnableConfig
 from langgraph.checkpoint.base import (
     Checkpoint,
     CheckpointMetadata,
+    create_checkpoint,
+    empty_checkpoint,
 )
 from langgraph.checkpoint.sqlite import SqliteSaver
 from langgraph.checkpoint.sqlite.utils import _metadata_predicate, search_where
-from tests.checkpoint_utils import create_checkpoint, empty_checkpoint
 
 
 class TestSqliteSaver:

libs/checkpoint/README.md

@@ -51,7 +51,7 @@ read_config = {"configurable": {"thread_id": "1"}}
 
 checkpointer = MemorySaver()
 checkpoint = {
-    "v": 4,
+    "v": 2,
     "ts": "2024-07-31T20:14:19.804150+00:00",
     "id": "1ef4f797-8335-6428-8001-8a1503f9b875",
     "channel_values": {
@@ -73,6 +73,7 @@ checkpoint = {
         "start:node": 2
       }
     },
+    "pending_sends": [],
 }
 
 # store checkpoint

libs/checkpoint/langgraph/checkpoint/base/__init__.py

@@ -1,18 +1,22 @@
-from collections.abc import AsyncIterator, Iterator, Sequence
+from collections.abc import AsyncIterator, Iterator, Mapping, Sequence
+from datetime import datetime, timezone
 from typing import (  # noqa: UP035
     Any,
+    Dict,
     Generic,
     List,
     Literal,
     NamedTuple,
     Optional,
+    Tuple,
     TypedDict,
     TypeVar,
     Union,
 )
 
-from langchain_core.runnables import RunnableConfig
+from langchain_core.runnables import ConfigurableFieldSpec, RunnableConfig
 
+from langgraph.checkpoint.base.id import uuid6
 from langgraph.checkpoint.serde.base import SerializerProtocol, maybe_add_typed_methods
 from langgraph.checkpoint.serde.jsonplus import JsonPlusSerializer
 from langgraph.checkpoint.serde.types import (
@@ -20,10 +24,14 @@ from langgraph.checkpoint.serde.types import (
     INTERRUPT,
     RESUME,
     SCHEDULED,
+    ChannelProtocol,
+    SendProtocol,
 )
 
 V = TypeVar("V", int, float, str)
-PendingWrite = tuple[str, str, Any]
+PendingWrite = Tuple[str, str, Any]
+# Kept for backwards compat, newer versions of LangGraph no longer use this.
+LATEST_VERSION = 2
 
 
 # Marked as total=False to allow for future expansion.
@@ -45,6 +53,11 @@ class CheckpointMetadata(TypedDict, total=False):
     0 for the first "loop" checkpoint.
     ... for the nth checkpoint afterwards.
     """
+    writes: dict[str, Any]
+    """The writes that were made between the previous checkpoint and this one.
+
+    Mapping from node name to writes emitted by that node.
+    """
     parents: dict[str, str]
     """The IDs of the parent checkpoints.
 
@@ -52,6 +65,10 @@ class CheckpointMetadata(TypedDict, total=False):
     """
 
 
+class TaskInfo(TypedDict):
+    status: Literal["scheduled", "success", "error"]
+
+
 ChannelVersions = dict[str, Union[str, int, float]]
 
 
@@ -79,6 +96,22 @@ class Checkpoint(TypedDict):
     This keeps track of the versions of the channels that each node has seen.
     Used to determine which nodes to execute next.
     """
+    pending_sends: List[SendProtocol]
+    """List of inputs pushed to nodes but not yet processed.
+    Cleared by the next checkpoint."""
+
+
+# Kept for backwards compat, newer versions of LangGraph no longer use this.
+def empty_checkpoint() -> Checkpoint:
+    return Checkpoint(
+        v=LATEST_VERSION,
+        id=str(uuid6(clock_seq=-2)),
+        ts=datetime.now(timezone.utc).isoformat(),
+        channel_values={},
+        channel_versions={},
+        versions_seen={},
+        pending_sends=[],
+    )
 
 
 def copy_checkpoint(checkpoint: Checkpoint) -> Checkpoint:
@@ -89,6 +122,39 @@ def copy_checkpoint(checkpoint: Checkpoint) -> Checkpoint:
         channel_values=checkpoint["channel_values"].copy(),
         channel_versions=checkpoint["channel_versions"].copy(),
         versions_seen={k: v.copy() for k, v in checkpoint["versions_seen"].items()},
+        pending_sends=checkpoint.get("pending_sends", []).copy(),
+    )
+
+
+# Kept for backwards compat, newer versions of LangGraph no longer use this.
+def create_checkpoint(
+    checkpoint: Checkpoint,
+    channels: Optional[Mapping[str, ChannelProtocol]],
+    step: int,
+    *,
+    id: Optional[str] = None,
+) -> Checkpoint:
+    """Create a checkpoint for the given channels."""
+    ts = datetime.now(timezone.utc).isoformat()
+    if channels is None:
+        values = checkpoint["channel_values"]
+    else:
+        values = {}
+        for k, v in channels.items():
+            if k not in checkpoint["channel_versions"]:
+                continue
+            try:
+                values[k] = v.checkpoint()
+            except EmptyChannelError:
+                pass
+    return Checkpoint(
+        v=LATEST_VERSION,
+        ts=ts,
+        id=id or str(uuid6(clock_seq=step)),
+        channel_values=values,
+        channel_versions=checkpoint["channel_versions"],
+        versions_seen=checkpoint["versions_seen"],
+        pending_sends=checkpoint.get("pending_sends", []),
     )
 
 
@@ -102,6 +168,34 @@ class CheckpointTuple(NamedTuple):
     pending_writes: Optional[List[PendingWrite]] = None
 
 
+CheckpointThreadId = ConfigurableFieldSpec(
+    id="thread_id",
+    annotation=str,
+    name="Thread ID",
+    description=None,
+    default="",
+    is_shared=True,
+)
+
+CheckpointNS = ConfigurableFieldSpec(
+    id="checkpoint_ns",
+    annotation=str,
+    name="Checkpoint NS",
+    description='Checkpoint namespace. Denotes the path to the subgraph node the checkpoint originates from, separated by `|` character, e.g. `"child|grandchild"`. Defaults to "" (root graph).',
+    default="",
+    is_shared=True,
+)
+
+CheckpointId = ConfigurableFieldSpec(
+    id="checkpoint_id",
+    annotation=Optional[str],
+    name="Checkpoint ID",
+    description="Pass to fetch a past checkpoint. If None, fetches the latest checkpoint.",
+    default=None,
+    is_shared=True,
+)
+
+
 class BaseCheckpointSaver(Generic[V]):
     """Base class for creating a graph checkpointer.
 
@@ -125,6 +219,15 @@ class BaseCheckpointSaver(Generic[V]):
     ) -> None:
         self.serde = maybe_add_typed_methods(serde or self.serde)
 
+    @property
+    def config_specs(self) -> list[ConfigurableFieldSpec]:
+        """Define the configuration options for the checkpoint saver.
+
+        Returns:
+            list[ConfigurableFieldSpec]: List of configuration field specs.
+        """
+        return [CheckpointThreadId, CheckpointNS, CheckpointId]
+
     def get(self, config: RunnableConfig) -> Optional[Checkpoint]:
         """Fetch a checkpoint using the given configuration.
 
@@ -155,7 +258,7 @@ class BaseCheckpointSaver(Generic[V]):
         self,
         config: Optional[RunnableConfig],
         *,
-        filter: Optional[dict[str, Any]] = None,
+        filter: Optional[Dict[str, Any]] = None,
         before: Optional[RunnableConfig] = None,
         limit: Optional[int] = None,
     ) -> Iterator[CheckpointTuple]:
@@ -201,7 +304,7 @@ class BaseCheckpointSaver(Generic[V]):
     def put_writes(
         self,
         config: RunnableConfig,
-        writes: Sequence[tuple[str, Any]],
+        writes: Sequence[Tuple[str, Any]],
         task_id: str,
         task_path: str = "",
     ) -> None:
@@ -259,7 +362,7 @@ class BaseCheckpointSaver(Generic[V]):
         self,
         config: Optional[RunnableConfig],
         *,
-        filter: Optional[dict[str, Any]] = None,
+        filter: Optional[Dict[str, Any]] = None,
         before: Optional[RunnableConfig] = None,
         limit: Optional[int] = None,
     ) -> AsyncIterator[CheckpointTuple]:
@@ -306,7 +409,7 @@ class BaseCheckpointSaver(Generic[V]):
     async def aput_writes(
         self,
         config: RunnableConfig,
-        writes: Sequence[tuple[str, Any]],
+        writes: Sequence[Tuple[str, Any]],
         task_id: str,
         task_path: str = "",
     ) -> None:
@@ -334,7 +437,7 @@ class BaseCheckpointSaver(Generic[V]):
         """
         raise NotImplementedError
 
-    def get_next_version(self, current: Optional[V]) -> V:
+    def get_next_version(self, current: Optional[V], channel: ChannelProtocol) -> V:
         """Generate the next version ID for a channel.
 
         Default is to use integer versions, incrementing by 1. If you override, you can use str/int/float versions,
@@ -342,6 +445,7 @@ class BaseCheckpointSaver(Generic[V]):
 
         Args:
             current: The current version identifier (int, float, or str).
+            channel: The channel being versioned.
 
         Returns:
             V: The next version identifier, which must be increasing.
@@ -372,10 +476,7 @@ def get_checkpoint_metadata(
     config: RunnableConfig, metadata: CheckpointMetadata
 ) -> CheckpointMetadata:
     """Get checkpoint metadata in a backwards-compatible manner."""
-    metadata = {
-        k: v.replace("\u0000", "") if isinstance(v, str) else v
-        for k, v in metadata.items()
-    }
+    metadata = metadata.copy()
     for obj in (config.get("metadata"), config.get("configurable")):
         if not obj:
             continue
@@ -383,10 +484,8 @@ def get_checkpoint_metadata(
             if key in metadata or key in EXCLUDED_METADATA_KEYS or key.startswith("__"):
                 continue
             v = obj[key]
-            if isinstance(v, str):
-                metadata[key] = v.replace("\u0000", "")
-            elif isinstance(v, (int, bool, float)):
-                metadata[key] = v
+            if isinstance(v, (str, int, bool, float)):
+                metadata[key] = v  # type: ignore[literal-required]
     return metadata
 
 

libs/checkpoint/langgraph/checkpoint/memory/__init__.py

@@ -22,6 +22,7 @@ from langgraph.checkpoint.base import (
     get_checkpoint_id,
     get_checkpoint_metadata,
 )
+from langgraph.checkpoint.serde.types import TASKS, ChannelProtocol
 
 logger = logging.getLogger(__name__)
 
@@ -149,6 +150,19 @@ class InMemorySaver(
             if saved := self.storage[thread_id][checkpoint_ns].get(checkpoint_id):
                 checkpoint, metadata, parent_checkpoint_id = saved
                 writes = self.writes[(thread_id, checkpoint_ns, checkpoint_id)].values()
+                if parent_checkpoint_id:
+                    sends = sorted(
+                        (
+                            (*w, k[1])
+                            for k, w in self.writes[
+                                (thread_id, checkpoint_ns, parent_checkpoint_id)
+                            ].items()
+                            if w[1] == TASKS
+                        ),
+                        key=lambda w: (w[3], w[0], w[4]),
+                    )
+                else:
+                    sends = []
                 checkpoint_: Checkpoint = self.serde.loads_typed(checkpoint)
                 return CheckpointTuple(
                     config=config,
@@ -157,6 +171,7 @@ class InMemorySaver(
                         "channel_values": self._load_blobs(
                             thread_id, checkpoint_ns, checkpoint_["channel_versions"]
                         ),
+                        "pending_sends": [self.serde.loads_typed(s[2]) for s in sends],
                     },
                     metadata=self.serde.loads_typed(metadata),
                     pending_writes=[
@@ -179,7 +194,22 @@ class InMemorySaver(
                 checkpoint_id = max(checkpoints.keys())
                 checkpoint, metadata, parent_checkpoint_id = checkpoints[checkpoint_id]
                 writes = self.writes[(thread_id, checkpoint_ns, checkpoint_id)].values()
+                if parent_checkpoint_id:
+                    sends = sorted(
+                        (
+                            (*w, k[1])
+                            for k, w in self.writes[
+                                (thread_id, checkpoint_ns, parent_checkpoint_id)
+                            ].items()
+                            if w[1] == TASKS
+                        ),
+                        key=lambda w: (w[3], w[0], w[4]),
+                    )
+                else:
+                    sends = []
+
                 checkpoint_ = self.serde.loads_typed(checkpoint)
+
                 return CheckpointTuple(
                     config={
                         "configurable": {
@@ -193,6 +223,7 @@ class InMemorySaver(
                         "channel_values": self._load_blobs(
                             thread_id, checkpoint_ns, checkpoint_["channel_versions"]
                         ),
+                        "pending_sends": [self.serde.loads_typed(s[2]) for s in sends],
                     },
                     metadata=self.serde.loads_typed(metadata),
                     pending_writes=[
@@ -285,6 +316,20 @@ class InMemorySaver(
                         (thread_id, checkpoint_ns, checkpoint_id)
                     ].values()
 
+                    if parent_checkpoint_id:
+                        sends = sorted(
+                            (
+                                (*w, k[1])
+                                for k, w in self.writes[
+                                    (thread_id, checkpoint_ns, parent_checkpoint_id)
+                                ].items()
+                                if w[1] == TASKS
+                            ),
+                            key=lambda w: (w[3], w[0], w[4]),
+                        )
+                    else:
+                        sends = []
+
                     checkpoint_: Checkpoint = self.serde.loads_typed(checkpoint)
 
                     yield CheckpointTuple(
@@ -302,6 +347,9 @@ class InMemorySaver(
                                 checkpoint_ns,
                                 checkpoint_["channel_versions"],
                             ),
+                            "pending_sends": [
+                                self.serde.loads_typed(s[2]) for s in sends
+                            ],
                         },
                         metadata=metadata,
                         parent_config=(
@@ -342,6 +390,7 @@ class InMemorySaver(
             RunnableConfig: The updated config containing the saved checkpoint's timestamp.
         """
         c = checkpoint.copy()
+        c.pop("pending_sends")  # type: ignore[misc]
         thread_id = config["configurable"]["thread_id"]
         checkpoint_ns = config["configurable"]["checkpoint_ns"]
         values: dict[str, Any] = c.pop("channel_values")  # type: ignore[misc]
@@ -512,7 +561,7 @@ class InMemorySaver(
         """
         return self.delete_thread(thread_id)
 
-    def get_next_version(self, current: Optional[str]) -> str:
+    def get_next_version(self, current: Optional[str], channel: ChannelProtocol) -> str:
         if current is None:
             current_v = 0
         elif isinstance(current, int):

libs/checkpoint/langgraph/checkpoint/serde/types.py

@@ -1,4 +1,13 @@
-from typing import Any, Protocol, TypeVar, runtime_checkable
+from collections.abc import Sequence
+from typing import (
+    Any,
+    Optional,
+    Protocol,
+    TypeVar,
+    runtime_checkable,
+)
+
+from typing_extensions import Self
 
 ERROR = "__error__"
 SCHEDULED = "__scheduled__"
@@ -11,6 +20,25 @@ Update = TypeVar("Update", contravariant=True)
 C = TypeVar("C")
 
 
+class ChannelProtocol(Protocol[Value, Update, C]):
+    # Mirrors langgraph.channels.base.BaseChannel
+    @property
+    def ValueType(self) -> Any: ...
+
+    @property
+    def UpdateType(self) -> Any: ...
+
+    def checkpoint(self) -> Optional[C]: ...
+
+    def from_checkpoint(self, checkpoint: Optional[C]) -> Self: ...
+
+    def update(self, values: Sequence[Update]) -> bool: ...
+
+    def get(self) -> Value: ...
+
+    def consume(self) -> bool: ...
+
+
 @runtime_checkable
 class SendProtocol(Protocol):
     # Mirrors langgraph.constants.Send

libs/checkpoint/tests/checkpoint_utils.py

@@ -1,51 +0,0 @@
-from collections.abc import Mapping
-from datetime import datetime, timezone
-from typing import Any, Optional, Protocol
-
-from langgraph.checkpoint.base import Checkpoint, EmptyChannelError
-from langgraph.checkpoint.base.id import uuid6
-
-
-class ChannelProtocol(Protocol):
-    def checkpoint(self) -> Optional[Any]: ...
-
-
-def empty_checkpoint() -> Checkpoint:
-    return Checkpoint(
-        v=1,
-        id=str(uuid6(clock_seq=-2)),
-        ts=datetime.now(timezone.utc).isoformat(),
-        channel_values={},
-        channel_versions={},
-        versions_seen={},
-    )
-
-
-def create_checkpoint(
-    checkpoint: Checkpoint,
-    channels: Optional[Mapping[str, ChannelProtocol]],
-    step: int,
-    *,
-    id: Optional[str] = None,
-) -> Checkpoint:
-    """Create a checkpoint for the given channels."""
-    ts = datetime.now(timezone.utc).isoformat()
-    if channels is None:
-        values = checkpoint["channel_values"]
-    else:
-        values = {}
-        for k, v in channels.items():
-            if k not in checkpoint["channel_versions"]:
-                continue
-            try:
-                values[k] = v.checkpoint()
-            except EmptyChannelError:
-                pass
-    return Checkpoint(
-        v=1,
-        ts=ts,
-        id=id or str(uuid6(clock_seq=step)),
-        channel_values=values,
-        channel_versions=checkpoint["channel_versions"],
-        versions_seen=checkpoint["versions_seen"],
-    )

libs/checkpoint/tests/test_memory.py

@@ -6,12 +6,10 @@ from langchain_core.runnables import RunnableConfig
 from langgraph.checkpoint.base import (
     Checkpoint,
     CheckpointMetadata,
-)
-from langgraph.checkpoint.memory import InMemorySaver
-from tests.checkpoint_utils import (
     create_checkpoint,
     empty_checkpoint,
 )
+from langgraph.checkpoint.memory import InMemorySaver
 
 
 class TestMemorySaver:

libs/cli/generate_schema.py

@@ -165,13 +165,6 @@ def generate_schema():
     if "python_version" in python_schema["properties"]:
         python_schema["properties"]["python_version"]["enum"] = ["3.11", "3.12"]
 
-    # Add enum constraint for image_distro
-    if "image_distro" in python_schema["properties"]:
-        python_schema["properties"]["image_distro"]["anyOf"] = [
-            {"type": "string", "enum": ["debian", "wolfi"]},
-            {"type": "null"},
-        ]
-
     # Create Node.js schema with node_version
     node_schema = {
         "type": "object",
@@ -191,13 +184,6 @@ def generate_schema():
             {"type": "null"},
         ]
 
-    # Add enum constraint for image_distro
-    if "image_distro" in node_schema["properties"]:
-        node_schema["properties"]["image_distro"]["anyOf"] = [
-            {"type": "string", "enum": ["debian", "wolfi"]},
-            {"type": "null"},
-        ]
-
     # Replace the Config schema with a oneOf constraint
     config_schema["oneOf"] = [python_schema, node_schema]
 

libs/cli/langgraph_cli/cli.py

@@ -20,7 +20,6 @@ from langgraph_cli.docker import DockerCapabilities
 from langgraph_cli.exec import Runner, subp_exec
 from langgraph_cli.progress import Progress
 from langgraph_cli.templates import TEMPLATE_HELP_STRING, create_new
-from langgraph_cli.util import warn_non_wolfi_distro
 from langgraph_cli.version import __version__
 
 OPT_DOCKER_COMPOSE = click.option(
@@ -318,8 +317,10 @@ def _build(
     )
     # add additional_contexts
     if additional_contexts:
-        for k, v in additional_contexts.items():
-            args.extend(["--build-context", f"{k}={v}"])
+        additional_contexts_str = ",".join(
+            f"{k}={v}" for k, v in additional_contexts.items()
+        )
+        args.extend(["--build-context", additional_contexts_str])
     # run docker build
     runner.run(
         subp_exec(
@@ -374,7 +375,6 @@ def build(
         if shutil.which("docker") is None:
             raise click.UsageError("Docker not installed") from None
         config_json = langgraph_cli.config.validate_config_file(config)
-        warn_non_wolfi_distro(config_json)
         _build(
             runner, set, config, config_json, base_image, pull, tag, docker_build_args
         )
@@ -466,7 +466,6 @@ def dockerfile(
     save_path = pathlib.Path(save_path).absolute()
     secho(f"🔍 Validating configuration at path: {config}", fg="yellow")
     config_json = langgraph_cli.config.validate_config_file(config)
-    warn_non_wolfi_distro(config_json)
     secho("✅ Configuration validated!", fg="green")
 
     secho(f"📝 Generating Dockerfile at {save_path}", fg="yellow")
@@ -792,7 +791,6 @@ def prepare(
 ) -> tuple[list[str], str]:
     """Prepare the arguments and stdin for running the LangGraph API server."""
     config_json = langgraph_cli.config.validate_config_file(config_path)
-    warn_non_wolfi_distro(config_json)
     # pull latest images
     if pull:
         runner.run(

libs/cli/langgraph_cli/config.py

@@ -13,8 +13,6 @@ DEFAULT_NODE_VERSION = "20"
 MIN_PYTHON_VERSION = "3.11"
 DEFAULT_PYTHON_VERSION = "3.11"
 
-DEFAULT_IMAGE_DISTRO = "debian"
-
 
 class TTLConfig(TypedDict, total=False):
     """Configuration for TTL (time-to-live) behavior in the store."""
@@ -369,12 +367,6 @@ class Config(TypedDict, total=False):
     
     Defaults to langchain/langgraph-api or langchain/langgraphjs-api."""
 
-    image_distro: Optional[str]
-    """Optional. Linux distribution for the base image.
-    
-    Must be either 'debian' or 'wolfi'. If omitted, defaults to 'debian'.
-    """
-
     pip_config_file: Optional[str]
     """Optional. Path to a pip config file (e.g., "/etc/pip.conf" or "pip.ini") for controlling
     package installation (custom indices, credentials, etc.).
@@ -466,10 +458,7 @@ RUN PYTHONDONTWRITEBYTECODE=1 pip install --no-cache-dir --no-deps -e /api
 # -- Removing pip from the final image ~<:===~~~ --
 RUN pip uninstall -y pip setuptools wheel && \
     rm -rf /usr/local/lib/python*/site-packages/pip* /usr/local/lib/python*/site-packages/setuptools* /usr/local/lib/python*/site-packages/wheel* && \
-    find /usr/local/bin -name "pip*" -delete || true
-# pip removal for wolfi
-RUN rm -rf /usr/lib/python*/site-packages/pip* /usr/lib/python*/site-packages/setuptools* /usr/lib/python*/site-packages/wheel* && \
-    find /usr/bin -name "pip*" -delete || true
+    find /usr/local/bin -name "pip*" -delete
 # -- End of pip removal --"""
 
 
@@ -528,15 +517,12 @@ def validate_config(config: Config) -> Config:
         "python_version", DEFAULT_PYTHON_VERSION if some_python else None
     )
 
-    image_distro = config.get("image_distro", DEFAULT_IMAGE_DISTRO)
-
     config = {
         "node_version": node_version,
         "python_version": python_version,
         "pip_config_file": config.get("pip_config_file"),
         "_INTERNAL_docker_tag": config.get("_INTERNAL_docker_tag"),
         "base_image": config.get("base_image"),
-        "image_distro": image_distro,
         "dependencies": config.get("dependencies", []),
         "dockerfile_lines": config.get("dockerfile_lines", []),
         "graphs": config.get("graphs", {}),
@@ -590,14 +576,6 @@ def validate_config(config: Config) -> Config:
             "Add at least one graph to 'graphs' dictionary."
         )
 
-    # Validate image_distro config
-    if image_distro := config.get("image_distro"):
-        if image_distro not in ["debian", "wolfi"]:
-            raise click.UsageError(
-                f"Invalid image_distro: '{image_distro}'. "
-                "Must be either 'debian' or 'wolfi'."
-            )
-
     # Validate auth config
     if auth_conf := config.get("auth"):
         if "path" in auth_conf:
@@ -1107,6 +1085,8 @@ def python_config_to_docker(
         else ""
     )
 
+    docker_tag = config.get("_INTERNAL_docker_tag") or config["python_version"]
+
     # collect dependencies
     pypi_deps = [dep for dep in config["dependencies"] if not dep.startswith(".")]
     local_deps = _assemble_local_deps(config_path, config)
@@ -1225,7 +1205,10 @@ ADD {relpath} /deps/{name}
                 "# -- End of JS dependencies install --",
             ]
         )
-    image_str = docker_tag(config, base_image)
+    if "/langgraph-server" in base_image:
+        image_str = f"{base_image}-py{docker_tag}"
+    else:
+        image_str = f"{base_image}:{docker_tag}"
     docker_file_contents = [
         f"FROM {image_str}",
         "",
@@ -1265,7 +1248,7 @@ def node_config_to_docker(
 ) -> tuple[str, dict[str, str]]:
     faux_path = f"/deps/{config_path.parent.name}"
     install_cmd = _get_node_pm_install_cmd(config_path, config)
-    image_str = docker_tag(config, base_image)
+    docker_tag = config.get("_INTERNAL_docker_tag") or config["node_version"]
 
     env_vars: list[str] = []
 
@@ -1292,7 +1275,7 @@ def node_config_to_docker(
     env_vars.append(f"ENV LANGSERVE_GRAPHS='{json.dumps(config['graphs'])}'")
 
     docker_file_contents = [
-        f"FROM {image_str}",
+        f"FROM {base_image}:{docker_tag}",
         "",
         os.linesep.join(config["dockerfile_lines"]),
         "",
@@ -1323,10 +1306,6 @@ def docker_tag(
     base_image: Optional[str] = None,
 ) -> str:
     base_image = base_image or default_base_image(config)
-
-    image_distro = config.get("image_distro")
-    distro_tag = "" if image_distro == DEFAULT_IMAGE_DISTRO else f"-{image_distro}"
-
     if config.get("_INTERNAL_docker_tag"):
         return f"{base_image}:{config['_INTERNAL_docker_tag']}"
 
@@ -1334,8 +1313,8 @@ def docker_tag(
         return f"{base_image}-py{config['python_version']}"
 
     if config.get("node_version") and not config.get("python_version"):
-        return f"{base_image}:{config['node_version']}{distro_tag}"
-    return f"{base_image}:{config['python_version']}{distro_tag}"
+        return f"{base_image}:{config['node_version']}"
+    return f"{base_image}:{config['python_version']}"
 
 
 def config_to_docker(

libs/cli/langgraph_cli/util.py

@@ -1,25 +1,2 @@
-import click
-
-
 def clean_empty_lines(input_str: str):
     return "\n".join(filter(None, input_str.splitlines()))
-
-
-def warn_non_wolfi_distro(config_json: dict) -> None:
-    """Show warning if image_distro is not set to 'wolfi'."""
-    image_distro = config_json.get("image_distro", "debian")  # Default is debian
-    if image_distro != "wolfi":
-        click.secho(
-            "⚠️  Security Recommendation: Consider switching to Wolfi Linux for enhanced security.",
-            fg="yellow",
-            bold=True,
-        )
-        click.secho(
-            "   Wolfi is a security-oriented, minimal Linux distribution designed for containers.",
-            fg="yellow",
-        )
-        click.secho(
-            '   To switch, add \'"image_distro": "wolfi"\' to your langgraph.json config file.',
-            fg="yellow",
-        )
-        click.secho("")  # Empty line for better readability

libs/cli/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "langgraph-cli"
-version = "0.2.12"
+version = "0.2.10"
 description = "CLI for interacting with LangGraph API"
 authors = []
 requires-python = ">=3.9"

libs/cli/schemas/schema.json

@@ -119,21 +119,6 @@
               ],
               "description": "Optional. Configuration for the built-in HTTP server, controlling which custom routes are exposed\nand how cross-origin requests are handled.\n"
             },
-            "image_distro": {
-              "anyOf": [
-                {
-                  "type": "string",
-                  "enum": [
-                    "debian",
-                    "wolfi"
-                  ]
-                },
-                {
-                  "type": "null"
-                }
-              ],
-              "description": "Optional. Linux distribution for the base image.\n\nMust be either 'debian' or 'wolfi'. If omitted, defaults to 'debian'.\n"
-            },
             "store": {
               "anyOf": [
                 {
@@ -272,21 +257,6 @@
               ],
               "description": "Optional. Configuration for the built-in HTTP server, controlling which custom routes are exposed\nand how cross-origin requests are handled.\n"
             },
-            "image_distro": {
-              "anyOf": [
-                {
-                  "type": "string",
-                  "enum": [
-                    "debian",
-                    "wolfi"
-                  ]
-                },
-                {
-                  "type": "null"
-                }
-              ],
-              "description": "Optional. Linux distribution for the base image.\n\nMust be either 'debian' or 'wolfi'. If omitted, defaults to 'debian'.\n"
-            },
             "store": {
               "anyOf": [
                 {

libs/cli/schemas/schema.v0.json

@@ -119,21 +119,6 @@
               ],
               "description": "Optional. Configuration for the built-in HTTP server, controlling which custom routes are exposed\nand how cross-origin requests are handled.\n"
             },
-            "image_distro": {
-              "anyOf": [
-                {
-                  "type": "string",
-                  "enum": [
-                    "debian",
-                    "wolfi"
-                  ]
-                },
-                {
-                  "type": "null"
-                }
-              ],
-              "description": "Optional. Linux distribution for the base image.\n\nMust be either 'debian' or 'wolfi'. If omitted, defaults to 'debian'.\n"
-            },
             "store": {
               "anyOf": [
                 {
@@ -272,21 +257,6 @@
               ],
               "description": "Optional. Configuration for the built-in HTTP server, controlling which custom routes are exposed\nand how cross-origin requests are handled.\n"
             },
-            "image_distro": {
-              "anyOf": [
-                {
-                  "type": "string",
-                  "enum": [
-                    "debian",
-                    "wolfi"
-                  ]
-                },
-                {
-                  "type": "null"
-                }
-              ],
-              "description": "Optional. Linux distribution for the base image.\n\nMust be either 'debian' or 'wolfi'. If omitted, defaults to 'debian'.\n"
-            },
             "store": {
               "anyOf": [
                 {

libs/cli/tests/unit_tests/cli/test_cli.py

@@ -22,14 +22,12 @@ DEFAULT_DOCKER_CAPABILITIES = DockerCapabilities(
 
 
 @contextmanager
-def temporary_config_folder(config_content: dict, levels: int = 0):
+def temporary_config_folder(config_content: dict):
     # Create a temporary directory
     temp_dir = tempfile.mkdtemp()
     try:
         # Define the path for the config.json file
-        config_path = Path(temp_dir) / f"{'a/' * levels}config.json"
-        # Ensure the parent directory exists
-        config_path.parent.mkdir(parents=True, exist_ok=True)
+        config_path = Path(temp_dir) / "config.json"
 
         # Write the provided dictionary content to config.json
         with open(config_path, "w", encoding="utf-8") as config_file:
@@ -440,132 +438,3 @@ def test_dockerfile_command_with_bad_config() -> None:
         # Assert command was successful
         assert result.exit_code == 2
         assert "conf.json' does not exist" in result.output
-
-
-def test_dockerfile_command_shows_wolfi_warning() -> None:
-    """Test the 'dockerfile' command shows warning when image_distro is not wolfi."""
-    runner = CliRunner()
-    config_content = {
-        "python_version": "3.11",
-        "graphs": {"agent": "agent.py:graph"},
-        "dependencies": ["."],
-        # No image_distro specified - should default to debian and show warning
-    }
-
-    with temporary_config_folder(config_content) as temp_dir:
-        save_path = temp_dir / "Dockerfile"
-        agent_path = temp_dir / "agent.py"
-        agent_path.touch()
-
-        result = runner.invoke(
-            cli,
-            ["dockerfile", str(save_path), "--config", str(temp_dir / "config.json")],
-        )
-
-        # Assert command was successful
-        assert result.exit_code == 0, result.output
-
-        # Check that warning is shown
-        assert "Security Recommendation" in result.output
-        assert "Wolfi Linux" in result.output
-        assert "image_distro" in result.output
-        assert "wolfi" in result.output
-
-
-def test_dockerfile_command_no_wolfi_warning_when_wolfi_set() -> None:
-    """Test the 'dockerfile' command does NOT show warning when image_distro is wolfi."""
-    runner = CliRunner()
-    config_content = {
-        "python_version": "3.11",
-        "graphs": {"agent": "agent.py:graph"},
-        "dependencies": ["."],
-        "image_distro": "wolfi",  # Explicitly set to wolfi - should not show warning
-    }
-
-    with temporary_config_folder(config_content) as temp_dir:
-        save_path = temp_dir / "Dockerfile"
-        agent_path = temp_dir / "agent.py"
-        agent_path.touch()
-
-        result = runner.invoke(
-            cli,
-            ["dockerfile", str(save_path), "--config", str(temp_dir / "config.json")],
-        )
-
-        # Assert command was successful
-        assert result.exit_code == 0, result.output
-
-        # Check that warning is NOT shown
-        assert "Security Recommendation" not in result.output
-        assert "Wolfi Linux" not in result.output
-
-
-def test_build_command_shows_wolfi_warning() -> None:
-    """Test the 'build' command shows warning when image_distro is not wolfi."""
-    runner = CliRunner()
-    config_content = {
-        "python_version": "3.11",
-        "graphs": {"agent": "agent.py:graph"},
-        "dependencies": ["."],
-        # No image_distro specified - should default to debian and show warning
-    }
-
-    with temporary_config_folder(config_content) as temp_dir:
-        agent_path = temp_dir / "agent.py"
-        agent_path.touch()
-
-        # Mock docker command since we don't want to actually build
-        with runner.isolated_filesystem():
-            result = runner.invoke(
-                cli,
-                [
-                    "build",
-                    "--tag",
-                    "test-image",
-                    "--config",
-                    str(temp_dir / "config.json"),
-                ],
-                catch_exceptions=True,
-            )
-
-        # The command will fail because docker isn't available or we're mocking,
-        # but we should still see the warning before it fails
-        assert "Security Recommendation" in result.output
-        assert "Wolfi Linux" in result.output
-        assert "image_distro" in result.output
-        assert "wolfi" in result.output
-
-
-def test_build_generate_proper_build_context():
-    runner = CliRunner()
-    config_content = {
-        "python_version": "3.11",
-        "graphs": {"agent": "agent.py:graph"},
-        "dependencies": [".", "../../..", "../.."],
-        "image_distro": "wolfi",
-    }
-
-    with temporary_config_folder(config_content, levels=3) as temp_dir:
-        agent_path = temp_dir / "agent.py"
-        agent_path.touch()
-
-        # Mock docker command since we don't want to actually build
-        with runner.isolated_filesystem():
-            result = runner.invoke(
-                cli,
-                [
-                    "build",
-                    "--tag",
-                    "test-image",
-                    "--config",
-                    str(temp_dir / "config.json"),
-                ],
-                catch_exceptions=True,
-            )
-
-        build_context_pattern = re.compile(r"--build-context\s+(\w+)=([^\s]+)")
-
-        build_contexts = re.findall(build_context_pattern, result.output)
-        assert (
-            len(build_contexts) == 2
-        ), f"Expected 2 build contexts, but found {len(build_contexts)}"

libs/cli/tests/unit_tests/test_config.py

@@ -11,7 +11,6 @@ from langgraph_cli.config import (
     PIP_CLEANUP_LINES,
     config_to_compose,
     config_to_docker,
-    docker_tag,
     validate_config,
     validate_config_file,
 )
@@ -35,7 +34,6 @@ def test_validate_config():
         "python_version": "3.11",
         "node_version": None,
         "pip_config_file": None,
-        "image_distro": "debian",
         "dockerfile_lines": [],
         "env": {},
         "store": None,
@@ -56,7 +54,6 @@ def test_validate_config():
         "python_version": "3.12",
         "node_version": None,
         "pip_config_file": "pipconfig.txt",
-        "image_distro": "debian",
         "dockerfile_lines": ["ARG meow"],
         "dependencies": [".", "langchain"],
         "graphs": {
@@ -123,7 +120,10 @@ def test_validate_config():
         }
     )
     assert config["python_version"] == "3.12-slim"
-    with pytest.raises(ValueError, match="Invalid http.app format"):
+    with pytest.raises(
+        ValueError,
+        match="Invalid http.app format",
+    ):
         validate_config(
             {
                 "python_version": "3.12",
@@ -134,83 +134,6 @@ def test_validate_config():
         )
 
 
-def test_validate_config_image_distro():
-    """Test validation of image_distro field."""
-    # Valid image_distro values should work
-    config = validate_config(
-        {
-            "python_version": "3.11",
-            "dependencies": ["."],
-            "graphs": {"agent": "./agent.py:graph"},
-            "image_distro": "debian",
-        }
-    )
-    assert config["image_distro"] == "debian"
-
-    config = validate_config(
-        {
-            "python_version": "3.11",
-            "dependencies": ["."],
-            "graphs": {"agent": "./agent.py:graph"},
-            "image_distro": "wolfi",
-        }
-    )
-    assert config["image_distro"] == "wolfi"
-
-    # Missing image_distro should default to 'debian'
-    config = validate_config(
-        {
-            "python_version": "3.11",
-            "dependencies": ["."],
-            "graphs": {"agent": "./agent.py:graph"},
-        }
-    )
-    assert config["image_distro"] == "debian"
-
-    # Invalid image_distro values should raise error
-    with pytest.raises(click.UsageError) as exc_info:
-        validate_config(
-            {
-                "python_version": "3.11",
-                "dependencies": ["."],
-                "graphs": {"agent": "./agent.py:graph"},
-                "image_distro": "ubuntu",
-            }
-        )
-    assert "Invalid image_distro: 'ubuntu'" in str(exc_info.value)
-    assert "Must be either 'debian' or 'wolfi'" in str(exc_info.value)
-
-    with pytest.raises(click.UsageError) as exc_info:
-        validate_config(
-            {
-                "python_version": "3.11",
-                "dependencies": ["."],
-                "graphs": {"agent": "./agent.py:graph"},
-                "image_distro": "alpine",
-            }
-        )
-    assert "Invalid image_distro: 'alpine'" in str(exc_info.value)
-
-    # Test base Node.js config with image distro
-    config = validate_config(
-        {
-            "node_version": "20",
-            "graphs": {"agent": "./agent.js:graph"},
-            "image_distro": "wolfi",
-        }
-    )
-    assert config["image_distro"] == "wolfi"
-
-    # Test Node.js config with no distro specified
-    config = validate_config(
-        {
-            "node_version": "20",
-            "graphs": {"agent": "./agent.js:graph"},
-        }
-    )
-    assert config["image_distro"] == "debian"
-
-
 def test_validate_config_file():
     with tempfile.TemporaryDirectory() as tmpdir:
         tmpdir_path = pathlib.Path(tmpdir)
@@ -968,148 +891,3 @@ def test_config_to_compose_end_to_end():
         watch=True,
     )
     assert clean_empty_lines(actual_compose_stdin) == expected_compose_stdin
-
-
-def test_docker_tag_image_distro():
-    """Test docker_tag function with different image_distro configurations."""
-
-    # Test 1: Default distro (debian) - no suffix
-    config = validate_config(
-        {
-            "python_version": "3.11",
-            "dependencies": ["."],
-            "graphs": {"agent": "./agent.py:graph"},
-        }
-    )
-    tag = docker_tag(config)
-    assert tag == "langchain/langgraph-api:3.11"
-
-    # Test 2: Explicit debian distro - no suffix (same as default)
-    config = validate_config(
-        {
-            "python_version": "3.11",
-            "dependencies": ["."],
-            "graphs": {"agent": "./agent.py:graph"},
-            "image_distro": "debian",
-        }
-    )
-    tag = docker_tag(config)
-    assert tag == "langchain/langgraph-api:3.11"
-
-    # Test 3: Wolfi distro - should add suffix
-    config = validate_config(
-        {
-            "python_version": "3.11",
-            "dependencies": ["."],
-            "graphs": {"agent": "./agent.py:graph"},
-            "image_distro": "wolfi",
-        }
-    )
-    tag = docker_tag(config)
-    assert tag == "langchain/langgraph-api:3.11-wolfi"
-
-    # Test 4: Node.js with default distro
-    config = validate_config(
-        {
-            "node_version": "20",
-            "graphs": {"agent": "./agent.js:graph"},
-        }
-    )
-    tag = docker_tag(config)
-    assert tag == "langchain/langgraphjs-api:20"
-
-    # Test 5: Node.js with wolfi distro
-    config = validate_config(
-        {
-            "node_version": "20",
-            "graphs": {"agent": "./agent.js:graph"},
-            "image_distro": "wolfi",
-        }
-    )
-    tag = docker_tag(config)
-    assert tag == "langchain/langgraphjs-api:20-wolfi"
-
-    # Test 6: Custom base image with wolfi
-    config = validate_config(
-        {
-            "python_version": "3.12",
-            "dependencies": ["."],
-            "graphs": {"agent": "./agent.py:graph"},
-            "image_distro": "wolfi",
-            "base_image": "my-registry/custom-image",
-        }
-    )
-    tag = docker_tag(config, base_image="my-registry/custom-image")
-    assert tag == "my-registry/custom-image:3.12-wolfi"
-
-
-def test_docker_tag_multiplatform_with_distro():
-    """Test docker_tag with multiplatform configs and image_distro."""
-
-    # Test 1: Multiplatform (Python + Node) with wolfi
-    config = validate_config(
-        {
-            "python_version": "3.11",
-            "node_version": "20",
-            "dependencies": ["."],
-            "graphs": {"python": "./agent.py:graph", "js": "./agent.js:graph"},
-            "image_distro": "wolfi",
-        }
-    )
-    tag = docker_tag(config)
-    # Should default to Python when both are present
-    assert tag == "langchain/langgraph-api:3.11-wolfi"
-
-    # Test 2: Node-only multiplatform with wolfi
-    config = validate_config(
-        {
-            "node_version": "20",
-            "graphs": {"js": "./agent.js:graph"},
-            "image_distro": "wolfi",
-        }
-    )
-    tag = docker_tag(config)
-    assert tag == "langchain/langgraphjs-api:20-wolfi"
-
-
-def test_docker_tag_different_python_versions_with_distro():
-    """Test docker_tag with different Python versions and distros."""
-
-    versions_and_expected = [
-        ("3.11", "langchain/langgraph-api:3.11-wolfi"),
-        ("3.12", "langchain/langgraph-api:3.12-wolfi"),
-        ("3.13", "langchain/langgraph-api:3.13-wolfi"),
-    ]
-
-    for python_version, expected_tag in versions_and_expected:
-        config = validate_config(
-            {
-                "python_version": python_version,
-                "dependencies": ["."],
-                "graphs": {"agent": "./agent.py:graph"},
-                "image_distro": "wolfi",
-            }
-        )
-        tag = docker_tag(config)
-        assert tag == expected_tag, f"Failed for Python {python_version}"
-
-
-def test_docker_tag_different_node_versions_with_distro():
-    """Test docker_tag with different Node.js versions and distros."""
-
-    versions_and_expected = [
-        ("20", "langchain/langgraphjs-api:20-wolfi"),
-        ("21", "langchain/langgraphjs-api:21-wolfi"),
-        ("22", "langchain/langgraphjs-api:22-wolfi"),
-    ]
-
-    for node_version, expected_tag in versions_and_expected:
-        config = validate_config(
-            {
-                "node_version": node_version,
-                "graphs": {"agent": "./agent.js:graph"},
-                "image_distro": "wolfi",
-            }
-        )
-        tag = docker_tag(config)
-        assert tag == expected_tag, f"Failed for Node.js {node_version}"

libs/langgraph/.claude/settings.local.json

@@ -1,12 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(rg:*)",
-      "Bash(python:*)",
-      "Bash(grep:*)",
-      "Bash(sed:*)",
-      "Bash(awk:*)"
-    ],
-    "deny": []
-  }
-}

libs/langgraph/Makefile

@@ -44,8 +44,9 @@ stop-postgres:
 	docker compose -f tests/compose-postgres.yml down -v
 
 start-dev-server:
-	LOG_LEVEL=warning uv run langgraph dev --config tests/example_app/langgraph.json --no-browser & echo "$$!" > .devserver.pid
+	uv run langgraph dev --config tests/example_app/langgraph.json --no-browser &
 	@echo "Dev server started."
+	@echo "Dev server PID: $$!" > .devserver.pid
 
 stop-dev-server:
 	@if [ -f .devserver.pid ]; then \
@@ -56,22 +57,15 @@ stop-dev-server:
 	fi
 
 TEST ?= .
-NO_DOCKER ?= $(sh command -v docker >/dev/null 2>&1 && echo "false" || echo "true")
 
 test:
-	if [ "$(NO_DOCKER)" = "false" ]; then \
-		make start-postgres &&\
-		make start-dev-server &&\
-		uv run pytest $(TEST); \
-		EXIT_CODE=$$?; \
-		make stop-postgres; \
-		make stop-dev-server; \
-		exit $$EXIT_CODE; \
-	else \
-		NO_DOCKER=true uv run pytest $(TEST) ; \
-		EXIT_CODE=$$?; \
-		exit $$EXIT_CODE; \
-	fi
+	make start-postgres &&\
+	make start-dev-server &&\
+	uv run pytest $(TEST); \
+	EXIT_CODE=$$?; \
+	make stop-postgres; \
+	make stop-dev-server; \
+	exit $$EXIT_CODE
 
 test_parallel:
 	make start-postgres &&\

libs/langgraph/bench/fanout_to_subgraph.py

@@ -21,8 +21,6 @@ def fanout_to_subgraph() -> StateGraph:
     class JokeOutput(TypedDict):
         jokes: list[str]
 
-    class JokeState(JokeInput, JokeOutput): ...
-
     async def bump(state: JokeOutput):
         return {"jokes": [state["jokes"][0] + " a"]}
 
@@ -37,7 +35,7 @@ def fanout_to_subgraph() -> StateGraph:
         return END if state["jokes"][0].endswith(" a" * 10) else "bump"
 
     # subgraph
-    subgraph = StateGraph(JokeState, input=JokeInput, output=JokeOutput)
+    subgraph = StateGraph(input=JokeInput, output=JokeOutput)
     subgraph.add_node("edit", edit)
     subgraph.add_node("generate", generate)
     subgraph.add_node("bump", bump)
@@ -71,8 +69,6 @@ def fanout_to_subgraph_sync() -> StateGraph:
     class JokeOutput(TypedDict):
         jokes: list[str]
 
-    class JokeState(JokeInput, JokeOutput): ...
-
     def bump(state: JokeOutput):
         return {"jokes": [state["jokes"][0] + " a"]}
 
@@ -87,7 +83,7 @@ def fanout_to_subgraph_sync() -> StateGraph:
         return END if state["jokes"][0].endswith(" a" * 10) else "bump"
 
     # subgraph
-    subgraph = StateGraph(JokeState, input=JokeInput, output=JokeOutput)
+    subgraph = StateGraph(input=JokeInput, output=JokeOutput)
     subgraph.add_node("edit", edit)
     subgraph.add_node("generate", generate)
     subgraph.add_node("bump", bump)

libs/langgraph/langgraph/_api/deprecation.py

@@ -0,0 +1,84 @@
+import functools
+import warnings
+from typing import Any, Callable, TypeVar, Union, cast
+
+
+class LangGraphDeprecationWarning(DeprecationWarning):
+    pass
+
+
+F = TypeVar("F", bound=Callable[..., Any])
+C = TypeVar("C", bound=type[Any])
+
+
+def deprecated(
+    since: str, alternative: str, *, removal: str = "", example: str = ""
+) -> Callable[[F], F]:
+    def decorator(obj: Union[F, C]) -> Union[F, C]:
+        removal_str = removal if removal else "a future version"
+        message = (
+            f"{obj.__name__} is deprecated as of version {since} and will be"
+            f" removed in {removal_str}. Use {alternative} instead.{example}"
+        )
+        if isinstance(obj, type):
+            original_init = obj.__init__  # type: ignore[misc]
+
+            @functools.wraps(original_init)
+            def new_init(self, *args: Any, **kwargs: Any) -> None:  # type: ignore[no-untyped-def]
+                warnings.warn(message, LangGraphDeprecationWarning, stacklevel=2)
+                original_init(self, *args, **kwargs)
+
+            obj.__init__ = new_init  # type: ignore[misc]
+
+            docstring = (
+                f"**Deprecated**: This class is deprecated as of version {since}. "
+                f"Use `{alternative}` instead."
+            )
+            if obj.__doc__:
+                docstring = docstring + f"\n\n{obj.__doc__}"
+            obj.__doc__ = docstring
+
+            return cast(C, obj)
+        elif callable(obj):
+
+            @functools.wraps(obj)
+            def wrapper(*args: Any, **kwargs: Any) -> Any:
+                warnings.warn(message, LangGraphDeprecationWarning, stacklevel=2)
+                return obj(*args, **kwargs)
+
+            docstring = (
+                f"**Deprecated**: This function is deprecated as of version {since}. "
+                f"Use `{alternative}` instead."
+            )
+            if obj.__doc__:
+                docstring = docstring + f"\n\n{obj.__doc__}"
+            wrapper.__doc__ = docstring
+
+            return cast(F, wrapper)
+        else:
+            raise TypeError(
+                f"Can only add deprecation decorator to classes or callables, got '{type(obj)}' instead."
+            )
+
+    return decorator
+
+
+def deprecated_parameter(
+    arg_name: str, since: str, alternative: str, *, removal: str
+) -> Callable[[F], F]:
+    def decorator(func: F) -> F:
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):  # type: ignore[no-untyped-def]
+            if arg_name in kwargs:
+                warnings.warn(
+                    f"Parameter '{arg_name}' in function '{func.__name__}' is "
+                    f"deprecated as of version {since} and will be removed in version {removal}. "
+                    f"Use '{alternative}' parameter instead.",
+                    category=LangGraphDeprecationWarning,
+                    stacklevel=2,
+                )
+            return func(*args, **kwargs)
+
+        return cast(F, wrapper)
+
+    return decorator

libs/langgraph/langgraph/channels/__init__.py

@@ -1,14 +1,17 @@
 from langgraph.channels.any_value import AnyValue
 from langgraph.channels.binop import BinaryOperatorAggregate
+from langgraph.channels.context import Context
 from langgraph.channels.ephemeral_value import EphemeralValue
-from langgraph.channels.last_value import LastValue, LastValueAfterFinish
+from langgraph.channels.last_value import LastValue
 from langgraph.channels.topic import Topic
+from langgraph.channels.untracked_value import UntrackedValue
 
 __all__ = [
     "LastValue",
-    "LastValueAfterFinish",
     "Topic",
+    "Context",
     "BinaryOperatorAggregate",
+    "UntrackedValue",
     "EphemeralValue",
     "AnyValue",
 ]

libs/langgraph/langgraph/channels/context.py

@@ -0,0 +1,5 @@
+from langgraph.managed.context import Context as ContextManagedValue
+
+Context = ContextManagedValue.of
+
+__all__ = ["Context"]

libs/langgraph/langgraph/channels/dynamic_barrier_value.py

@@ -0,0 +1,206 @@
+from collections.abc import Sequence, Set
+from typing import Any, Generic, NamedTuple, Optional, Union
+
+from typing_extensions import Self
+
+from langgraph.channels.base import BaseChannel, Value
+from langgraph.constants import MISSING
+from langgraph.errors import EmptyChannelError, InvalidUpdateError
+
+
+class WaitForNames(NamedTuple):
+    names: Set[Any]
+
+
+class DynamicBarrierValue(
+    Generic[Value], BaseChannel[Value, Union[Value, WaitForNames], Set[Value]]
+):
+    """A channel that switches between two states
+
+    - in the "priming" state it can't be read from.
+        - if it receives a WaitForNames update, it switches to the "waiting" state.
+    - in the "waiting" state it collects named values until all are received.
+        - once all named values are received, it can be read once, and it switches
+          back to the "priming" state.
+    """
+
+    __slots__ = ("names", "seen")
+
+    names: Optional[Set[Value]]
+    seen: set[Value]
+
+    def __init__(self, typ: type[Value]) -> None:
+        super().__init__(typ)
+        self.names = None
+        self.seen = set()
+
+    def __eq__(self, value: object) -> bool:
+        return isinstance(value, DynamicBarrierValue) and value.names == self.names
+
+    @property
+    def ValueType(self) -> type[Value]:
+        """The type of the value stored in the channel."""
+        return self.typ
+
+    @property
+    def UpdateType(self) -> type[Value]:
+        """The type of the update received by the channel."""
+        return self.typ
+
+    def copy(self) -> Self:
+        """Return a copy of the channel."""
+        empty = self.__class__(self.typ)
+        empty.key = self.key
+        empty.names = self.names
+        empty.seen = self.seen.copy()
+        return empty
+
+    def checkpoint(self) -> tuple[Optional[Set[Value]], set[Value]]:
+        return (self.names, self.seen)
+
+    def from_checkpoint(
+        self, checkpoint: tuple[Optional[Set[Value]], set[Value]]
+    ) -> Self:
+        empty = self.__class__(self.typ)
+        empty.key = self.key
+        if checkpoint is not MISSING:
+            names, seen = checkpoint
+            empty.names = names if names is not None else None
+            empty.seen = seen
+        return empty
+
+    def update(self, values: Sequence[Union[Value, WaitForNames]]) -> bool:
+        if wait_for_names := [v for v in values if isinstance(v, WaitForNames)]:
+            if len(wait_for_names) > 1:
+                raise InvalidUpdateError(
+                    f"At key '{self.key}': Received multiple WaitForNames updates in the same step."
+                )
+            self.names = wait_for_names[0].names
+            return True
+        elif self.names is not None:
+            updated = False
+            for value in values:
+                assert not isinstance(value, WaitForNames)
+                if value in self.names and value not in self.seen:
+                    self.seen.add(value)
+                    updated = True
+            return updated
+
+    def get(self) -> Value:
+        if self.seen != self.names:
+            raise EmptyChannelError()
+        return None
+
+    def is_available(self) -> bool:
+        return self.seen == self.names
+
+    def consume(self) -> bool:
+        if self.seen == self.names:
+            self.seen = set()
+            self.names = None
+            return True
+        return False
+
+
+class DynamicBarrierValueAfterFinish(
+    Generic[Value], BaseChannel[Value, Union[Value, WaitForNames], Set[Value]]
+):
+    """A channel that switches between two states
+
+    - in the "priming" state it can't be read from.
+        - if it receives a WaitForNames update, it switches to the "waiting" state.
+    - in the "waiting" state it collects named values until all are received.
+        - once all named values are received, and the finished flag is set, it can be read once, and it switches
+          back to the "priming" state.
+    """
+
+    __slots__ = ("names", "seen", "finished")
+
+    names: Optional[Set[Value]]
+    seen: set[Value]
+    finished: bool
+
+    def __init__(self, typ: type[Value]) -> None:
+        super().__init__(typ)
+        self.names = None
+        self.seen = set()
+        self.finished = False
+
+    def __eq__(self, value: object) -> bool:
+        return (
+            isinstance(value, DynamicBarrierValueAfterFinish)
+            and value.names == self.names
+        )
+
+    @property
+    def ValueType(self) -> type[Value]:
+        """The type of the value stored in the channel."""
+        return self.typ
+
+    @property
+    def UpdateType(self) -> type[Value]:
+        """The type of the update received by the channel."""
+        return self.typ
+
+    def copy(self) -> Self:
+        """Return a copy of the channel."""
+        empty = self.__class__(self.typ)
+        empty.key = self.key
+        empty.names = self.names
+        empty.seen = self.seen.copy()
+        empty.finished = self.finished
+        return empty
+
+    def checkpoint(self) -> tuple[Optional[Set[Value]], set[Value], bool]:
+        return (self.names, self.seen, self.finished)
+
+    def from_checkpoint(
+        self, checkpoint: tuple[Optional[Set[Value]], set[Value], bool]
+    ) -> Self:
+        empty = self.__class__(self.typ)
+        empty.key = self.key
+        if checkpoint is not MISSING:
+            names, seen, finished = checkpoint
+            empty.names = names if names is not None else None
+            empty.seen = seen
+            empty.finished = finished
+        return empty
+
+    def update(self, values: Sequence[Union[Value, WaitForNames]]) -> bool:
+        if wait_for_names := [v for v in values if isinstance(v, WaitForNames)]:
+            if len(wait_for_names) > 1:
+                raise InvalidUpdateError(
+                    f"At key '{self.key}': Received multiple WaitForNames updates in the same step."
+                )
+            self.names = wait_for_names[0].names
+            return True
+        elif self.names is not None:
+            updated = False
+            for value in values:
+                assert not isinstance(value, WaitForNames)
+                if value in self.names and value not in self.seen:
+                    self.seen.add(value)
+                    updated = True
+            return updated
+
+    def get(self) -> Value:
+        if not self.finished and self.seen != self.names:
+            raise EmptyChannelError()
+        return None
+
+    def is_available(self) -> bool:
+        return self.seen == self.names and self.finished
+
+    def consume(self) -> bool:
+        if self.finished and self.seen == self.names:
+            self.seen = set()
+            self.names = None
+            return True
+        return False
+
+    def finish(self) -> bool:
+        if not self.finished and self.seen == self.names:
+            self.finished = True
+            return True
+        else:
+            return False

libs/langgraph/langgraph/channels/topic.py

@@ -71,14 +71,12 @@ class Topic(
         return empty
 
     def update(self, values: Sequence[Union[Value, list[Value]]]) -> bool:
-        updated = False
+        current = list(self.values)
         if not self.accumulate:
-            updated = bool(self.values)
             self.values = list[Value]()
-        if flat_values := tuple(flatten(values)):
-            updated = True
+        if flat_values := flatten(values):
             self.values.extend(flat_values)
-        return updated
+        return self.values != current
 
     def get(self) -> Sequence[Value]:
         if self.values:

libs/langgraph/langgraph/channels/untracked_value.py

@@ -0,0 +1,66 @@
+from collections.abc import Sequence
+from typing import Generic
+
+from typing_extensions import Self
+
+from langgraph.channels.base import BaseChannel, Value
+from langgraph.constants import MISSING
+from langgraph.errors import EmptyChannelError, InvalidUpdateError
+
+
+class UntrackedValue(Generic[Value], BaseChannel[Value, Value, Value]):
+    """Stores the last value received, never checkpointed."""
+
+    __slots__ = ("value", "guard")
+
+    def __init__(self, typ: type[Value], guard: bool = True) -> None:
+        super().__init__(typ)
+        self.guard = guard
+        self.value = MISSING
+
+    def __eq__(self, value: object) -> bool:
+        return isinstance(value, UntrackedValue) and value.guard == self.guard
+
+    @property
+    def ValueType(self) -> type[Value]:
+        """The type of the value stored in the channel."""
+        return self.typ
+
+    @property
+    def UpdateType(self) -> type[Value]:
+        """The type of the update received by the channel."""
+        return self.typ
+
+    def copy(self) -> Self:
+        """Return a copy of the channel."""
+        empty = self.__class__(self.typ, self.guard)
+        empty.key = self.key
+        empty.value = self.value
+        return empty
+
+    def checkpoint(self) -> Value:
+        return MISSING
+
+    def from_checkpoint(self, checkpoint: Value) -> Self:
+        empty = self.__class__(self.typ, self.guard)
+        empty.key = self.key
+        return empty
+
+    def update(self, values: Sequence[Value]) -> bool:
+        if len(values) == 0:
+            return False
+        if len(values) != 1 and self.guard:
+            raise InvalidUpdateError(
+                f"At key '{self.key}': UntrackedValue(guard=True) can receive only one value per step. Use guard=False if you want to store any one of multiple values."
+            )
+
+        self.value = values[-1]
+        return True
+
+    def get(self) -> Value:
+        if self.value is MISSING:
+            raise EmptyChannelError()
+        return self.value
+
+    def is_available(self) -> bool:
+        return self.value is not MISSING

libs/langgraph/langgraph/constants.py

@@ -122,6 +122,7 @@ RESERVED = {
     ERROR,
     NO_WRITES,
     SCHEDULED,
+    TASKS,
     # reserved config.configurable keys
     CONFIG_KEY_SEND,
     CONFIG_KEY_READ,

libs/langgraph/langgraph/func/__init__.py

@@ -2,7 +2,6 @@ import asyncio
 import concurrent.futures
 import functools
 import inspect
-import warnings
 from collections.abc import Awaitable, Sequence
 from dataclasses import dataclass
 from typing import (
@@ -17,8 +16,6 @@ from typing import (
     overload,
 )
 
-from typing_extensions import Unpack
-
 from langgraph.cache.base import BaseCache
 from langgraph.channels.ephemeral_value import EphemeralValue
 from langgraph.channels.last_value import LastValue
@@ -37,8 +34,6 @@ from langgraph.pregel.read import PregelNode
 from langgraph.pregel.write import ChannelWrite, ChannelWriteEntry
 from langgraph.store.base import BaseStore
 from langgraph.types import _DC_KWARGS, CachePolicy, RetryPolicy, StreamMode
-from langgraph.typing import DeprecatedKwargs
-from langgraph.warnings import LangGraphDeprecatedSinceV10
 
 
 class TaskFunction(Generic[P, T]):
@@ -46,7 +41,7 @@ class TaskFunction(Generic[P, T]):
         self,
         func: Callable[P, T],
         *,
-        retry_policy: Sequence[RetryPolicy],
+        retry: Optional[Sequence[RetryPolicy]] = (),
         cache_policy: Optional[CachePolicy[Callable[P, Union[str, bytes]]]] = None,
         name: Optional[str] = None,
     ) -> None:
@@ -62,17 +57,13 @@ class TaskFunction(Generic[P, T]):
                 # handle regular functions / partials / callable classes, etc.
                 func.__name__ = name
         self.func = func
-        self.retry_policy = retry_policy
+        self.retry = retry
         self.cache_policy = cache_policy
         functools.update_wrapper(self, func)
 
     def __call__(self, *args: P.args, **kwargs: P.kwargs) -> SyncAsyncFuture[T]:
         return call(
-            self.func,
-            retry_policy=self.retry_policy,
-            cache_policy=self.cache_policy,
-            *args,
-            **kwargs,
+            self.func, retry=self.retry, cache_policy=self.cache_policy, *args, **kwargs
         )
 
     def clear_cache(self, cache: BaseCache) -> None:
@@ -92,9 +83,8 @@ class TaskFunction(Generic[P, T]):
 def task(
     *,
     name: Optional[str] = None,
-    retry_policy: Optional[Union[RetryPolicy, Sequence[RetryPolicy]]] = None,
+    retry: Optional[Union[RetryPolicy, Sequence[RetryPolicy]]] = None,
     cache_policy: Optional[CachePolicy[Callable[P, Union[str, bytes]]]] = None,
-    **kwargs: Unpack[DeprecatedKwargs],
 ) -> Callable[
     [Union[Callable[P, Awaitable[T]], Callable[P, T]]],
     TaskFunction[P, T],
@@ -111,9 +101,8 @@ def task(
     __func_or_none__: Optional[Union[Callable[P, Awaitable[T]], Callable[P, T]]] = None,
     *,
     name: Optional[str] = None,
-    retry_policy: Optional[Union[RetryPolicy, Sequence[RetryPolicy]]] = None,
+    retry: Optional[Union[RetryPolicy, Sequence[RetryPolicy]]] = None,
     cache_policy: Optional[CachePolicy[Callable[P, Union[str, bytes]]]] = None,
-    **kwargs: Unpack[DeprecatedKwargs],
 ) -> Union[
     Callable[
         [Union[Callable[P, Awaitable[T]], Callable[P, T]]],
@@ -136,9 +125,7 @@ def task(
     - Calling the function produces a future. This makes it easy to parallelize tasks.
 
     Args:
-        name: An optional name for the task. If not provided, the function name will be used.
-        retry_policy: An optional retry policy (or list of policies) to use for the task in case of a failure.
-        cache_policy: An optional cache policy to use for the task. This allows caching of the task results.
+        retry: An optional retry policy to use for the task in case of a failure.
 
     Returns:
         A callable function when used as a decorator.
@@ -179,21 +166,10 @@ def task(
         await add_one.ainvoke([1, 2, 3])  # Returns [2, 3, 4]
         ```
     """
-    if (retry := kwargs.get("retry")) is not None:
-        warnings.warn(
-            "`retry` is deprecated and will be removed. Please use `retry_policy` instead.",
-            category=LangGraphDeprecatedSinceV10,
-        )
-        if retry_policy is None:
-            retry_policy = retry  # type: ignore[assignment]
-
-    retry_policies: Sequence[RetryPolicy] = (
-        ()
-        if retry_policy is None
-        else (retry_policy,)
-        if isinstance(retry_policy, RetryPolicy)
-        else retry_policy
-    )
+    if isinstance(retry, RetryPolicy):
+        retry_policies: Optional[Sequence[RetryPolicy]] = (retry,)
+    else:
+        retry_policies = retry
 
     def decorator(
         func: Union[Callable[P, Awaitable[T]], Callable[P, T]],
@@ -201,7 +177,7 @@ def task(
         Callable[P, concurrent.futures.Future[T]], Callable[P, asyncio.Future[T]]
     ]:
         return TaskFunction(
-            func, retry_policy=retry_policies, cache_policy=cache_policy, name=name
+            func, retry=retry_policies, cache_policy=cache_policy, name=name
         )
 
     if __func_or_none__ is not None:
@@ -256,11 +232,8 @@ class entrypoint:
             its state across runs.
         store: A generalized key-value store. Some implementations may support
             semantic search capabilities through an optional `index` configuration.
-        cache: A cache to use for caching the results of the workflow.
         config_schema: Specifies the schema for the configuration object that will be
             passed to the workflow.
-        cache_policy: A cache policy to use for caching the results of the workflow.
-        retry_policy: A retry policy (or list of policies) to use for the workflow in case of a failure.
 
     Example: Using entrypoint and tasks
         ```python
@@ -381,23 +354,14 @@ class entrypoint:
         cache: Optional[BaseCache] = None,
         config_schema: Optional[type[Any]] = None,
         cache_policy: Optional[CachePolicy] = None,
-        retry_policy: Optional[Union[RetryPolicy, Sequence[RetryPolicy]]] = None,
-        **kwargs: Unpack[DeprecatedKwargs],
+        retry: Union[RetryPolicy, Sequence[RetryPolicy]] = (),
     ) -> None:
         """Initialize the entrypoint decorator."""
-        if (retry := kwargs.get("retry")) is not None:
-            warnings.warn(
-                "`retry` is deprecated and will be removed. Please use `retry_policy` instead.",
-                category=LangGraphDeprecatedSinceV10,
-            )
-            if retry_policy is None:
-                retry_policy = retry  # type: ignore[assignment]
-
         self.checkpointer = checkpointer
         self.store = store
         self.cache = cache
         self.cache_policy = cache_policy
-        self.retry_policy = retry_policy
+        self.retry = retry
         self.config_schema = config_schema
 
     @dataclass(**_DC_KWARGS)
@@ -529,6 +493,6 @@ class entrypoint:
             store=self.store,
             cache=self.cache,
             cache_policy=self.cache_policy,
-            retry_policy=self.retry_policy or (),
+            retry_policy=self.retry,
             config_type=self.config_schema,
         )

libs/langgraph/langgraph/graph/__init__.py

@@ -1,11 +1,13 @@
-from langgraph.constants import END, START
-from langgraph.graph.message import MessagesState, add_messages
+from langgraph.graph.graph import END, START, Graph
+from langgraph.graph.message import MessageGraph, MessagesState, add_messages
 from langgraph.graph.state import StateGraph
 
 __all__ = [
     "END",
     "START",
+    "Graph",
     "StateGraph",
+    "MessageGraph",
     "add_messages",
     "MessagesState",
 ]