Add windows CLI testing

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -7,29 +7,35 @@ body:
       value: >
         Thank you for taking the time to file a bug report. 
         
-        Use this to report BUGS in LangGraph. For usage questions, feature requests and general design questions, please use [GitHub Discussions](https://github.com/langchain-ai/langgraph/discussions).
+        Use this to report bugs in LangChain. 
+        
+        If you're not certain that your issue is due to a bug in LangChain, please use [GitHub Discussions](https://github.com/langchain-ai/langchain/discussions)
+        to ask for help with your issue.
         
         Relevant links to check before filing a bug report to see if your issue has already been reported, fixed or
         if there's another way to solve your problem:
         
-        [LangGraph Github Discussions](https://github.com/langchain-ai/langgraph/discussions),
-        [LangGraph Github Issues](https://github.com/langchain-ai/langgraph/issues),
-        [LangGraph how-to guides](https://langchain-ai.github.io/langgraph/how-tos/).
+        [LangGraph documentation](https://langchain-ai.github.io/langgraph/).
         [LangChain documentation with the integrated search](https://python.langchain.com/docs/get_started/introduction),
         [GitHub search](https://github.com/langchain-ai/langgraph),
+        [LangChain Github Discussions](https://github.com/langchain-ai/langgraph/discussions),
+        [LangChain Github Issues](https://github.com/langchain-ai/langgraph/issues),
+        [LangChain ChatBot](https://chat.langchain.com/)
   - type: checkboxes
     id: checks
     attributes:
       label: Checked other resources
-      description: Before submitting this issue, please confirm that you have completed all the steps below by checking each option. These steps help ensure your issue is well-defined, relevant, and actionable.
+      description: Please confirm and check all the following options.
       options:
-        - label: This is a bug, not a usage question. For questions, please use GitHub Discussions.
+        - label: I added a very descriptive title to this issue.
           required: true
-        - label: I added a clear and detailed title that summarizes the issue.
+        - label: I searched the [LangGraph](https://langchain-ai.github.io/langgraph/)/LangChain documentation with the integrated search.
           required: true
-        - label: I read what a minimal reproducible example is (https://stackoverflow.com/help/minimal-reproducible-example).
+        - label: I used the GitHub search to find a similar question and didn't find it.
           required: true
-        - label: I included a self-contained, minimal example that demonstrates the issue INCLUDING all the relevant imports. The code run AS IS to reproduce the issue.
+        - label: I am sure that this is a bug in LangGraph/LangChain rather than my code.
+          required: true
+        - label: I am sure this is better as an issue [rather than a GitHub discussion](https://github.com/langchain-ai/langgraph/discussions/new/choose), since this is a LangGraph bug and not a design question.
           required: true
   - type: textarea
     id: reproduction
@@ -39,6 +45,14 @@ body:
       label: Example Code
       description: |
         Please add a self-contained, [minimal, reproducible, example](https://stackoverflow.com/help/minimal-reproducible-example) with your use case.
+        
+        If a maintainer can copy it, run it, and see it right away, there's a much higher chance that you'll be able to get help.
+        
+        **Important!** 
+        
+        * Reduce your code to the minimum required to reproduce the issue if possible. This makes it much easier for others to help you.
+        * Avoid screenshots when possible, as they are hard to read and (more importantly) don't allow others to copy-and-paste your code.
+
       placeholder: |
         from langgraph.graph import StateGraph
 
@@ -78,8 +92,25 @@ body:
     attributes:
       label: System Info
       description: |
+        Please share your system info with us. 
+        
+        "pip freeze | grep langchain" 
+        platform (windows / linux / mac)
+        python version
+        
+        OR if you're on a recent version of langchain-core you can paste the output of:
+        
         python -m langchain_core.sys_info
       placeholder: |
+        "pip freeze | grep langgraph"
+        platform
+        python version
+        
+        Alternatively, if you're on a recent version of langchain-core you can paste the output of:
+        
         python -m langchain_core.sys_info
+        
+        These will only surface LangChain packages, don't forget to include any other relevant
+        packages you're using (if you're not sure what's relevant, you can paste the entire output of `pip freeze`).
     validations:
       required: true

.github/workflows/_integration_test.yml

@@ -14,7 +14,7 @@ jobs:
         python-version:
           - "3.10"
           - "3.11"
-    name: "CLI integration test"
+    name: "CLI integration test (Linux)"
     defaults:
       run:
         working-directory: libs/cli
@@ -71,4 +71,62 @@ jobs:
         working-directory: libs/cli/js-examples
         run: |
           langgraph build -t langgraph-test-e
-  
+  
+  windows-build:
+    runs-on: windows-latest
+    name: "CLI integration test (Windows)"
+    defaults:
+      run:
+        working-directory: libs/cli
+        shell: bash
+    steps:
+      - uses: actions/checkout@v4
+      - name: Get changed files
+        id: changed-files
+        uses: Ana06/get-changed-files@v2.3.0
+        with:
+          filter: "libs/cli/**"
+      - name: Set up Python 3.11 + Poetry ${{ env.POETRY_VERSION }}
+        if: steps.changed-files.outputs.all
+        uses: "./.github/actions/poetry_setup"
+        with:
+          python-version: "3.11"
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: integration-test-cli-windows
+      - name: Setup env
+        if: steps.changed-files.outputs.all
+        working-directory: libs/cli/examples
+        run: cp .env.example .env
+      - name: Install cli globally
+        if: steps.changed-files.outputs.all
+        run: pip install -e .
+      - name: Build and test service A
+        if: steps.changed-files.outputs.all
+        working-directory: libs/cli/examples
+        run: |
+          langgraph build -t langgraph-test-a  --base-image "langchain/langgraph-trial"
+          cp .env.example .envg
+          timeout 60 python ../../../.github/scripts/run_langgraph_cli_test.py -c langgraph.json -t langgraph-test-a
+      - name: Build and test service B
+        if: steps.changed-files.outputs.all
+        working-directory: libs/cli/examples/graphs
+        run: |
+          langgraph build -t langgraph-test-b  --base-image "langchain/langgraph-trial"
+          timeout 60 python ../../../../.github/scripts/run_langgraph_cli_test.py -t langgraph-test-b
+      - name: Build and test service C
+        if: steps.changed-files.outputs.all
+        working-directory: libs/cli/examples/graphs_reqs_a
+        run: |
+          langgraph build -t langgraph-test-c  --base-image "langchain/langgraph-trial"
+          timeout 60 python ../../../../.github/scripts/run_langgraph_cli_test.py -t langgraph-test-c
+      - name: Build and test service D
+        if: steps.changed-files.outputs.all
+        working-directory: libs/cli/examples/graphs_reqs_b
+        run: |
+          langgraph build -t langgraph-test-d  --base-image "langchain/langgraph-trial"
+          timeout 60 python ../../../../.github/scripts/run_langgraph_cli_test.py -t langgraph-test-d
+      - name: Build JS service
+        if: steps.changed-files.outputs.all
+        working-directory: libs/cli/js-examples
+        run: |
+          langgraph build -t langgraph-test-e

.github/workflows/_test_langgraph.yml

@@ -60,7 +60,7 @@ jobs:
         env:
           LANGGRAPH_FF_SEND_V2: ${{ matrix.ff-send-v2 }}
         run: |
-          make test_parallel
+          make test
 
       - name: Ensure the tests did not create any additional files
         shell: bash

.github/workflows/deploy_docs.yml

@@ -88,7 +88,6 @@ jobs:
               --check-links-ignore "https://(api|web|docs)\.smith\.langchain\.com/.*" \
               --check-links-ignore "https://x.com/.*" \
               --check-links-ignore "https://github\.com/.*" \
-              --check-links-ignore "http://localhost:8123/.*" \
               --check-links-ignore "/.*\.(ipynb|html)$" \
               --check-links-ignore "https://python\.langchain\.com/.*" \
               --check-links-ignore "https://openai\.com/.*" \
@@ -105,7 +104,6 @@ jobs:
               echo "Running link check on HTML files matching changed notebook files..."
               poetry run pytest -v \
                 --check-links-ignore "https://(api|web|docs)\.smith\.langchain\.com/.*" \
-                --check-links-ignore "http://localhost:8123/.*" \
                 --check-links-ignore "https://x.com/.*" \
                 --check-links-ignore "https://github\.com/.*" \
                 --check-links-ignore "/.*\.(ipynb|html)$" \

CONTRIBUTING.md

@@ -49,7 +49,7 @@ gain understanding of concepts and how they interact by showing one way to achie
 
 They should **avoid** giving
 multiple permutations of ways to achieve that goal in-depth. Choice is burdensome. Instead, they should guide a new user through a recommended path to accomplishing a concrete goal. While the end result of a tutorial does not necessarily need to
-be completely production-ready, it should be useful and practically satisfy the goal that you clearly stated in the tutorial's introduction.
+be completely production-ready, it should be useful and practically satisfy the the goal that you clearly stated in the tutorial's introduction.
 
 To quote the Diataxis website:
 

Makefile

@@ -13,7 +13,7 @@ serve-clean-docs: clean-docs
 	poetry run python -m mkdocs serve -c -f docs/mkdocs.yml --strict -w ./libs/langgraph
 
 serve-docs: build-typedoc
-	poetry run python -m mkdocs serve -f docs/mkdocs.yml -w ./libs/langgraph  -w ./libs/checkpoint --dirty
+	poetry run python -m mkdocs serve -f docs/mkdocs.yml -w ./libs/langgraph --dirty
 
 clean-docs:
 	find ./docs/docs -name "*.ipynb" -type f -delete

README.md

@@ -238,7 +238,7 @@ final_state["messages"][-1].content
 * [How-to Guides](https://langchain-ai.github.io/langgraph/how-tos/): Accomplish specific things within LangGraph, from streaming, to adding memory & persistence, to common design patterns (branching, subgraphs, etc.), these are the place to go if you want to copy and run a specific code snippet.
 * [Conceptual Guides](https://langchain-ai.github.io/langgraph/concepts/high_level/): In-depth explanations of the key concepts and principles behind LangGraph, such as nodes, edges, state and more.
 * [API Reference](https://langchain-ai.github.io/langgraph/reference/graphs/): Review important classes and methods, simple examples of how to use the graph and checkpointing APIs, higher-level prebuilt components and more.
-* [LangGraph Platform](https://langchain-ai.github.io/langgraph/concepts/#langgraph-platform): LangGraph Platform is a commercial solution for deploying agentic applications in production, built on the open-source LangGraph framework.
+* [Cloud (beta)](https://langchain-ai.github.io/langgraph/cloud/): With one click, deploy LangGraph applications to LangGraph Cloud.
 
 ## Contributing
 

docs/docs/cloud/deployment/semantic_search.md

@@ -1,123 +0,0 @@
-# How to add semantic search to your LangGraph deployment
-
-This guide explains how to add semantic search to your LangGraph deployment's cross-thread [store](../../concepts/persistence.md#memory-store), so that your agent can search for memories and other documents by semantic similarity.
-
-## Prerequisites
-
-- A LangGraph deployment (see [how to deploy](setup_pyproject.md))
-- API keys for your embedding provider (in this case, OpenAI)
-- `langchain >= 0.3.8` (if you specify using the string format below)
-
-## Steps
-
-1. Update your `langgraph.json` configuration file to include the store configuration:
-
-```json
-{
-    ...
-    "store": {
-        "index": {
-            "embed": "openai:text-embeddings-3-small",
-            "dims": 1536,
-            "fields": ["$"]
-        }
-    }
-}
-```
-
-This configuration:
-
-- Uses OpenAI's text-embeddings-3-small model for generating embeddings
-- Sets the embedding dimension to 1536 (matching the model's output)
-- Indexes all fields in your stored data (`["$"]` means index everything, or specify specific fields like `["text", "metadata.title"]`)
-
-2. To use the string embedding format above, make sure your dependencies include `langchain >= 0.3.8`:
-
-```toml
-# In pyproject.toml
-[project]
-dependencies = [
-    "langchain>=0.3.8"
-]
-```
-
-Or if using requirements.txt:
-
-```
-langchain>=0.3.8
-```
-
-## Usage
-
-Once configured, you can use semantic search in your LangGraph nodes. The store requires a namespace tuple to organize memories:
-
-```python
-def search_memory(state: State, *, store: BaseStore):
-    # Search the store using semantic similarity
-    # The namespace tuple helps organize different types of memories
-    # e.g., ("user_facts", "preferences") or ("conversation", "summaries")
-    results = store.search(
-        namespace=("memory", "facts"),  # Organize memories by type
-        query="your search query",
-        limit=3  # number of results to return
-    )
-    return results
-```
-
-## Custom Embeddings
-
-If you want to use custom embeddings, you can pass a path to a custom embedding function:
-
-```json
-{
-    ...
-    "store": {
-        "index": {
-            "embed": "path/to/embedding_function.py:embed",
-            "dims": 1536,
-            "fields": ["$"]
-        }
-    }
-}
-```
-
-The deployment will look for the function in the specified path. The function must be async and accept a list of strings:
-
-```python
-# path/to/embedding_function.py
-from openai import AsyncOpenAI
-
-client = AsyncOpenAI()
-
-async def aembed_texts(texts: list[str]) -> list[list[float]]:
-    """Custom embedding function that must:
-    1. Be async
-    2. Accept a list of strings
-    3. Return a list of float arrays (embeddings)
-    """
-    response = await client.embeddings.create(
-        model="text-embedding-3-small",
-        input=texts
-    )
-    return [e.embedding for e in response.data]
-```
-
-## Querying via the API
-
-You can also query the store using the LangGraph SDK. Since the SDK uses async operations:
-
-```python
-from langgraph_sdk import get_client
-
-async def search_store():
-    client = get_client()
-    results = await client.store.search_items(
-        ("memory", "facts"),
-        query="your search query",
-        limit=3  # number of results to return
-    )
-    return results
-
-# Use in an async context
-results = await search_store()
-```

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

@@ -83,7 +83,7 @@ We can now call `.get_schemas` to get schemas associated with this graph:
         assistant_id=assistant["assistant_id"]
     )
     # There are multiple types of schemas
-    # We can get the `config_schema` to look at the configurable parameters
+    # We can get the `config_schema` to look at the the configurable parameters
     print(schemas["config_schema"])
     ```
 
@@ -94,7 +94,7 @@ We can now call `.get_schemas` to get schemas associated with this graph:
       assistant["assistant_id"]
     );
     // There are multiple types of schemas
-    // We can get the `config_schema` to look at the configurable parameters
+    // We can get the `config_schema` to look at the the configurable parameters
     console.log(schemas.config_schema);
     ```
 

docs/docs/cloud/quick_start.md

@@ -8,9 +8,9 @@ If you want to learn how to build an agent like this from scratch, take a look a
 
 This tutorial will use:
 
-- Anthropic for the LLM - sign up and get an API key [here](https://console.anthropic.com/).
-- Tavily for the search engine - sign up and get an API key [here](https://app.tavily.com/).
-- LangSmith for hosting - sign up and get an API key [here](https://smith.langchain.com/).
+- Anthropic for the LLM - sign up and get an API key [here](https://console.anthropic.com/)
+- Tavily for the search engine - sign up and get an API key [here](https://app.tavily.com/)
+- LangSmith for hosting - sign up and get an API key [here](https://smith.langchain.com/)
 
 ## Create and configure your app
 

docs/docs/cloud/reference/api/open_agent_api_ref.html

@@ -0,0 +1,19 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Open Assistants API Specification</title>
+    <meta charset="utf-8" />
+    <meta
+      name="viewport"
+      content="width=device-width, initial-scale=1" />
+  </head>
+  <body>
+    <script id="api-reference" data-url="./open_agent_api.json"></script>
+    <script>
+      var configuration = {}
+      document.getElementById('api-reference').dataset.configuration =
+        JSON.stringify(configuration)
+    </script>
+    <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"></script>
+  </body>
+</html>

docs/docs/cloud/reference/api/openapi.json

@@ -1557,11 +1557,8 @@
           "200": {
             "description": "Success",
             "content": {
-              "text/event-stream": {
-                "schema": {
-                  "type": "string",
-                  "description": "The server will send a stream of events in SSE format.\n\n**Example event**:\n\nid: 1\n\nevent: message\n\ndata: {}"
-                }
+              "application/json": {
+                "schema": {}
               }
             }
           },
@@ -1908,11 +1905,8 @@
           "200": {
             "description": "Success",
             "content": {
-              "text/event-stream": {
-                "schema": {
-                  "type": "string",
-                  "description": "The server will send a stream of events in SSE format.\n\n**Example event**:\n\nid: 1\n\nevent: message\n\ndata: {}"
-                }
+              "application/json": {
+                "schema": {}
               }
             }
           },
@@ -2149,11 +2143,8 @@
           "200": {
             "description": "Success",
             "content": {
-              "text/event-stream": {
-                "schema": {
-                  "type": "string",
-                  "description": "The server will send a stream of events in SSE format.\n\n**Example event**:\n\nid: 1\n\nevent: message\n\ndata: {}"
-                }
+              "application/json": {
+                "schema": {}
               }
             }
           },

docs/docs/cloud/reference/cli.md

@@ -26,11 +26,10 @@ The LangGraph command line interface includes commands to build and run a LangGr
 The LangGraph CLI requires a JSON configuration file with the following keys:
 
 | Key                | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| ------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+|--------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | `dependencies`     | **Required**. Array of dependencies for LangGraph Cloud API server. Dependencies can be one of the following: (1) `"."`, which will look for local Python packages, (2) `pyproject.toml`, `setup.py` or `requirements.txt` in the app directory `"./local_package"`, or (3) a package name.                                                                                                                                                                                                                                                  |
 | `graphs`           | **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 creates an instance of `langgraph.graph.state.StateGraph` / `langgraph.graph.state.CompiledStateGraph`.</li></ul> |
 | `env`              | Path to `.env` file or a mapping from environment variable to its value.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| `store`            | Configuration for adding semantic search to the BaseStore. Contains the following fields: <ul><li>`index`: Configuration for semantic search indexing with fields:<ul><li>`embed`: Embedding provider (e.g., "openai:text-embedding-3-small") or path to custom embedding function</li><li>`dims`: Dimension size of the embedding model. Used to initialize the vector table.</li><li>`fields` (optional): List of fields to index. Defaults to `["$"]`, meaningto index entire documents. Can be specific fields like `["text", "summary", "some.value"]`</li></ul></li></ul>                                                                  |
 | `python_version`   | `3.11` or `3.12`. Defaults to `3.11`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
 | `pip_config_file`  | Path to `pip` config file.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
 | `dockerfile_lines` | Array of additional lines to add to Dockerfile following the import from parent image.                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
@@ -42,84 +41,33 @@ The LangGraph CLI requires a JSON configuration file with the following keys:
     </p>
 </div>
 
-### Examples
-
-#### Basic Configuration
+Example:
 
 ```json
 {
-  "dependencies": ["."],
+  "dependencies": ["langchain_openai", "./your_package"],
   "graphs": {
-    "chat": "./chat/graph.py:graph"
-  }
-}
-```
-
-#### 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.
-
-The `fields` configuration determines which parts of your documents to embed:
-- If omitted or set to `["$"]`, the entire document will be embedded
-- To embed specific fields, use JSON path notation: `["metadata.title", "content.text"]`
-- Documents missing specified fields will still be stored but won't have embeddings for those fields
-- You can still override which fields to embed on a specific item at `put` time using the `index` parameter
-
-```json
-{
-  "dependencies": ["."],
-  "graphs": {
-    "memory_agent": "./agent/graph.py:graph"
+    "my_graph_id": "./your_package/your_file.py:variable"
   },
-  "store": {
-    "index": {
-      "embed": "openai:text-embedding-3-small",
-      "dims": 1536,
-      "fields": ["$"]
-    }
-  }
+  "env": "./.env"
 }
 ```
 
-!!! note "Common model dimensions"
-        - openai:text-embedding-3-large: 3072
-        - openai:text-embedding-3-small: 1536
-        - openai:text-embedding-ada-002: 1536
-        - cohere:embed-english-v3.0: 1024
-        - cohere:embed-english-light-v3.0: 384
-        - cohere:embed-multilingual-v3.0: 1024
-        - cohere:embed-multilingual-light-v3.0: 384
-
-#### Semantic search with a custom embedding function
-
-If you want to use semantic search with a custom embedding function, you can pass a path to a custom embedding function:
+Example with environment variables:
 
 ```json
 {
-  "dependencies": ["."],
+  "python_version": "3.11",
+  "dependencies": ["langchain_openai", "."],
   "graphs": {
-    "memory_agent": "./agent/graph.py:graph"
+    "my_graph_id": "./your_package/your_file.py:make_graph"
   },
-  "store": {
-    "index": {
-      "embed": "./embeddings.py:embed_texts",
-      "dims": 768,
-      "fields": ["text", "summary"]
-    }
+  "env": {
+    "OPENAI_API_KEY": "secret-key"
   }
 }
 ```
 
-The `embed` field in store configuration can reference a custom function that takes a list of strings and returns a list of embeddings. Example implementation:
-
-```python
-# embeddings.py
-def embed_texts(texts: list[str]) -> list[list[float]]:
-    """Custom embedding function for semantic search."""
-    # Implementation using your preferred embedding model
-    return [[0.1, 0.2, ...] for _ in texts]  # dims-dimensional vectors
-```
-
 ## Commands
 
 The base command for the LangGraph CLI is `langgraph`.
@@ -150,16 +98,16 @@ langgraph dev [OPTIONS]
 
 **Options**
 
-| Option                        | Default          | Description                                                                         |
-| ----------------------------- | ---------------- | ----------------------------------------------------------------------------------- |
-| `-c, --config FILE`           | `langgraph.json` | Path to configuration file declaring dependencies, graphs and environment variables |
-| `--host TEXT`                 | `127.0.0.1`      | Host to bind the server to                                                          |
-| `--port INTEGER`              | `2024`           | Port to bind the server to                                                          |
-| `--no-reload`                 |                  | Disable auto-reload                                                                 |
-| `--n-jobs-per-worker INTEGER` |                  | Number of jobs per worker. Default is 10                                            |
-| `--no-browser`                |                  | Disable automatic browser opening                                                   |
-| `--debug-port INTEGER`        |                  | Port for debugger to listen on                                                      |
-| `--help`                      |                  | Display command documentation                                                       |
+| Option                       | Default          | Description                                                                                |
+|----------------------------|------------------|--------------------------------------------------------------------------------------------|
+| `-c, --config FILE`        | `langgraph.json` | Path to configuration file declaring dependencies, graphs and environment variables       |
+| `--host TEXT`              | `127.0.0.1`      | Host to bind the server to                                                                |
+| `--port INTEGER`           | `2024`           | Port to bind the server to                                                                |
+| `--no-reload`              |                  | Disable auto-reload                                                                        |
+| `--n-jobs-per-worker INTEGER` |               | Number of jobs per worker. Default is 10                                                  |
+| `--no-browser`             |                  | Disable automatic browser opening                                                          |
+| `--debug-port INTEGER`     |                  | Port for debugger to listen on                                                            |
+| `--help`                   |                  | Display command documentation                                                              |
 
 ### `build`
 
@@ -174,7 +122,7 @@ langgraph build [OPTIONS]
 **Options**
 
 | Option               | Default          | Description                                                                                                                  |
-| -------------------- | ---------------- | ---------------------------------------------------------------------------------------------------------------------------- |
+|----------------------|------------------|------------------------------------------------------------------------------------------------------------------------------|
 | `--platform TEXT`    |                  | Target platform(s) to build the Docker image for. Example: `langgraph build --platform linux/amd64,linux/arm64`              |
 | `-t, --tag TEXT`     |                  | **Required**. Tag for the Docker image. Example: `langgraph build -t my-image`                                               |
 | `--pull / --no-pull` | `--pull`         | Build with latest remote Docker image. Use `--no-pull` for running the LangGraph Cloud API server with locally built images. |
@@ -193,20 +141,20 @@ langgraph up [OPTIONS]
 
 **Options**
 
-| Option                       | Default                   | Description                                                                                                             |
-| ---------------------------- | ------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
-| `--wait`                     |                           | Wait for services to start before returning. Implies --detach                                                           |
-| `--postgres-uri TEXT`        | Local database            | Postgres URI to use for the database.                                                                                   |
-| `--watch`                    |                           | Restart on file changes                                                                                                 |
-| `--debugger-base-url TEXT`   | `http://127.0.0.1:[PORT]` | URL used by the debugger to access LangGraph API.                                                                       |
-| `--debugger-port INTEGER`    |                           | Pull the debugger image locally and serve the UI on specified port                                                      |
-| `--verbose`                  |                           | Show more output from the server logs.                                                                                  |
-| `-c, --config FILE`          | `langgraph.json`          | Path to configuration file declaring dependencies, graphs and environment variables.                                    |
-| `-d, --docker-compose FILE`  |                           | Path to docker-compose.yml file with additional services to launch.                                                     |
-| `-p, --port INTEGER`         | `8123`                    | Port to expose. Example: `langgraph up --port 8000`                                                                     |
+| Option                       | Default                   | Description                                                                                                           |
+|------------------------------|---------------------------|-----------------------------------------------------------------------------------------------------------------------|
+| `--wait`                     |                           | Wait for services to start before returning. Implies --detach                                                         |
+| `--postgres-uri TEXT`        | Local database            | Postgres URI to use for the database.                                                                                 |
+| `--watch`                    |                           | Restart on file changes                                                                                               |
+| `--debugger-base-url TEXT`   | `http://127.0.0.1:[PORT]` | URL used by the debugger to access LangGraph API.                                                                     |
+| `--debugger-port INTEGER`    |                           | Pull the debugger image locally and serve the UI on specified port                                                    |
+| `--verbose`                  |                           | Show more output from the server logs.                                                                                |
+| `-c, --config FILE`          | `langgraph.json`          | Path to configuration file declaring dependencies, graphs and environment variables.                                  |
+| `-d, --docker-compose FILE`  |                           | Path to docker-compose.yml file with additional services to launch.                                                   |
+| `-p, --port INTEGER`         | `8123`                    | Port to expose. Example: `langgraph up --port 8000`                                                                 |
 | `--pull / --no-pull`         | `pull`                    | Pull latest images. Use `--no-pull` for running the server with locally-built images. Example: `langgraph up --no-pull` |
-| `--recreate / --no-recreate` | `no-recreate`             | Recreate containers even if their configuration and image haven't changed                                               |
-| `--help`                     |                           | Display command documentation.                                                                                          |
+| `--recreate / --no-recreate` | `no-recreate`             | Recreate containers even if their configuration and image haven't changed                                             |
+| `--help`                     |                           | Display command documentation.                                                                                        |
 
 ### `dockerfile`
 
@@ -221,7 +169,7 @@ langgraph dockerfile [OPTIONS] SAVE_PATH
 **Options**
 
 | Option              | Default          | Description                                                                                                     |
-| ------------------- | ---------------- | --------------------------------------------------------------------------------------------------------------- |
+|---------------------|------------------|-----------------------------------------------------------------------------------------------------------------|
 | `-c, --config FILE` | `langgraph.json` | Path to the [configuration file](#configuration-file) declaring dependencies, graphs and environment variables. |
 | `--help`            |                  | Show this message and exit.                                                                                     |
 

docs/docs/concepts/human_in_the_loop.md

@@ -27,8 +27,8 @@ Adding a [breakpoint](./low_level.md#breakpoints) a specific location in the gra
 Here, we compile our graph with a checkpointer and a breakpoint at the node we want to interrupt before, `step_for_human_in_the_loop`. We then perform one of the above interaction patterns, which will create a new checkpoint if a human edits the graph state. The new checkpoint is saved to the `thread` and we can resume the graph execution from there by passing in `None` as the input.
 
 ```python
-# Compile our graph with a checkpointer and a breakpoint before "step_for_human_in_the_loop"
-graph = builder.compile(checkpointer=checkpointer, interrupt_before=["step_for_human_in_the_loop"])
+# Compile our graph with a checkpoitner and a breakpoint before "step_for_human_in_the_loop"
+graph = builder.compile(checkpointer=checkpoitner, interrupt_before=["step_for_human_in_the_loop"])
 
 # Run the graph up to the breakpoint
 thread_config = {"configurable": {"thread_id": "1"}}
@@ -98,8 +98,8 @@ With persistence, we can surface the current agent state as well as the next ste
 If approved, the graph resumes execution from the last saved checkpoint, which is saved to the `thread`:
 
 ```python
-# Compile our graph with a checkpointer and a breakpoint before the step to approve
-graph = builder.compile(checkpointer=checkpointer, interrupt_before=["node_2"])
+# Compile our graph with a checkpoitner and a breakpoint before the step to approve
+graph = builder.compile(checkpointer=checkpoitner, interrupt_before=["node_2"])
 
 # Run the graph up to the breakpoint
 for event in graph.stream(inputs, thread, stream_mode="values"):
@@ -120,7 +120,7 @@ See [our guide](../how-tos/human_in_the_loop/breakpoints.ipynb) for a detailed h
 
 Sometimes we want to review and edit the agent's state. 
  
-As with approval, we can interrupt our agent at a [breakpoint](./low_level.md#breakpoints) prior to the step we want to check. 
+As with approval, we can interrupt our agent at a [breakpoint](./low_level.md#breakpoints) prior the the step we want to check. 
  
 We can surface the current state to a user and allow the user to edit the agent state.
  
@@ -131,8 +131,8 @@ We can edit the graph state by forking the current checkpoint, which is saved to
 We can then proceed with the graph from our forked checkpoint as done before. 
 
 ```python
-# Compile our graph with a checkpointer and a breakpoint before the step to review
-graph = builder.compile(checkpointer=checkpointer, interrupt_before=["node_2"])
+# Compile our graph with a checkpoitner and a breakpoint before the step to review
+graph = builder.compile(checkpointer=checkpoitner, interrupt_before=["node_2"])
 
 # Run the graph up to the breakpoint
 for event in graph.stream(inputs, thread, stream_mode="values"):
@@ -170,11 +170,11 @@ With editing, the user makes a decision about whether or not to edit the graph s
 
 With input, we explicitly define a node in our graph for collecting human input!
 
-The state update with the human input then runs *as this node*.
+The the state update with the human input then runs *as this node*.
 
 ```python
-# Compile our graph with a checkpointer and a breakpoint before the step to to collect human input
-graph = builder.compile(checkpointer=checkpointer, interrupt_before=["human_input"])
+# Compile our graph with a checkpoitner and a breakpoint before the step to to collect human input
+graph = builder.compile(checkpointer=checkpoitner, interrupt_before=["human_input"])
 
 # Run the graph up to the breakpoint
 for event in graph.stream(inputs, thread, stream_mode="values"):
@@ -211,8 +211,8 @@ Even if the tool call is correct, we may also want to apply discretion:
 With these points in mind, we can combine the above ideas to create a human-in-the-loop review of a tool call.
 
 ```python
-# Compile our graph with a checkpointer and a breakpoint before the step to to review the tool call from the LLM 
-graph = builder.compile(checkpointer=checkpointer, interrupt_before=["human_review"])
+# Compile our graph with a checkpoitner and a breakpoint before the step to to review the tool call from the LLM 
+graph = builder.compile(checkpointer=checkpoitner, interrupt_before=["human_review"])
 
 # Run the graph up to the breakpoint
 for event in graph.stream(inputs, thread, stream_mode="values"):
@@ -319,4 +319,4 @@ for event in graph.stream(None, config, stream_mode="values"):
 
 See [this additional conceptual guide](https://langchain-ai.github.io/langgraph/concepts/persistence/#update-state) for related context on forking.
 
-See see [this guide](../how-tos/human_in_the_loop/time-travel.ipynb) for a detailed how-to on doing time-travel!
+See see [this guide](../how-tos/human_in_the_loop/time-travel.ipynb) for a detailed how-to on doing time-travel!

docs/docs/concepts/index.md

@@ -30,7 +30,7 @@ The conceptual guide does not cover step-by-step instructions or specific implem
 - [Streaming](streaming.md): Streaming is crucial for enhancing the responsiveness of applications built on LLMs. By displaying output progressively, even before a complete response is ready, streaming significantly improves user experience (UX), particularly when dealing with the latency of LLMs. 
 - [FAQ](faq.md): Frequently asked questions about LangGraph.
 
-## LangGraph Platform
+## LangGraph Platform 
 
 LangGraph Platform is a commercial solution for deploying agentic applications in production, built on the open-source LangGraph framework.
 

docs/docs/concepts/langgraph_cloud.md

@@ -14,13 +14,6 @@ A **deployment** is an instance of a LangGraph API. A single deployment can have
 
 See the [how-to guide](../cloud/deployment/cloud.md#create-new-deployment) for creating a new deployment.
 
-## Resource Allocation
-
-| **Deployment Type** | **CPU** | **Memory** | **Scaling**         |
-|---------------------|---------|------------|---------------------|
-| Development         | 1 CPU   | 1 GB       | Up to 1 container   |
-| Production          | 1 CPU   | 2 GB       | Up to 10 containers |
-
 ## Revision
 
 A revision is an iteration of a [deployment](#deployment). When a new deployment is created, an initial revision is automatically created. To deploy new code changes or update environment variable configurations for a deployment, a new revision must be created. When a revision is created, a new container image is built automatically.
@@ -40,7 +33,6 @@ A high-level diagram of a Cloud SaaS deployment.
 
 ![diagram](img/langgraph_cloud_architecture.png)
 
-
 ## Related
 
 - [Deployment Options](./deployment_options.md)

docs/docs/concepts/low_level.md

@@ -283,9 +283,6 @@ You can optionally provide a dictionary that maps the `routing_function`'s outpu
 graph.add_conditional_edges("node_a", routing_function, {True: "node_b", False: "node_c"})
 ```
 
-!!! tip
-    Use [`Command`](#command) instead of conditional edges if you want to combine state updates and routing in a single function.
-
 ### Entry Point
 
 The entry point is the first node(s) that are run when the graph starts. You can use the [`add_edge`][langgraph.graph.StateGraph.add_edge] method from the virtual [`START`][langgraph.constants.START] node to the first node to execute to specify where to enter the graph.
@@ -325,65 +322,6 @@ def continue_to_jokes(state: OverallState):
 graph.add_conditional_edges("node_a", continue_to_jokes)
 ```
 
-## `Command`
-
-It can be useful to combine control flow (edges) and state updates (nodes). For example, you might want to BOTH perform state updates AND decide which node to go to next in the SAME node. LangGraph provides a way to do so by returning a [`Command`][langgraph.types.Command] object from node functions:
-
-```python
-def my_node(state: State) -> Command[Literal["my_other_node"]]:
-    return Command(
-        # state update
-        update={"foo": "bar"},
-        # control flow
-        goto="my_other_node"
-    )
-```
-
-`Command` has the following properties:
-
-| Property | Description |
-| --- | --- |
-| `graph` | Graph to send the command to. Supported values:<br>- `None`: the current graph (default)<br>- `Command.PARENT`: closest parent graph |
-| `update` | Update to apply to the graph's state. |
-| `resume` | Value to resume execution with. To be used together with [`interrupt()`][langgraph.types.interrupt]. |
-| `goto` | Can be one of the following:<br>- name of the node to navigate to next (any node that belongs to the specified `graph`)<br>- sequence of node names to navigate to next<br>- `Send` object (to execute a node with the input provided)<br>- sequence of `Send` objects<br>If `goto` is not specified and there are no other tasks left in the graph, the graph will halt after executing the current superstep. |
-
-```python
-from langgraph.graph import StateGraph, START
-from langgraph.types import Command
-from typing_extensions import Literal, TypedDict
-
-class State(TypedDict):
-    foo: str
-
-def my_node(state: State) -> Command[Literal["my_other_node"]]:
-    return Command(update={"foo": "bar"}, goto="my_other_node")
-
-def my_other_node(state: State):
-    return {"foo": state["foo"] + "baz"}
-
-builder = StateGraph(State)
-builder.add_edge(START, "my_node")
-builder.add_node("my_node", my_node)
-builder.add_node("my_other_node", my_other_node)
-
-graph = builder.compile()
-```
-
-With `Command` you can also achieve dynamic control flow behavior (identical to [conditional edges](#conditional-edges)):
-
-```python
-def my_node(state: State) -> Command[Literal["my_other_node"]]:
-    if state["foo"] == "bar":
-        return Command(update={"foo": "baz"}, goto="my_other_node")
-```
-
-!!! important
-
-    When returning `Command` in your node functions, you must add return type annotations with the list of node names the node is routing to, e.g. `Command[Literal["node_b", "node_c"]]`. This is necessary for the graph compilation and rendering, and tells LangGraph that `node_a` can navigate to `node_b` and `node_c`.
-
-Check out this [how-to guide](../how-tos/command.ipynb) for an end-to-end example of how to use `Command`.
-
 ## Persistence
 
 LangGraph provides built-in persistence for your agent's state using [checkpointers][langgraph.checkpoint.base.BaseCheckpointSaver]. Checkpointers save snapshots of the graph state at every superstep, allowing resumption at any time. This enables features like human-in-the-loop interactions, memory management, and fault-tolerance. You can even directly manipulate a graph's state after its execution using the

docs/docs/concepts/memory.md

@@ -171,7 +171,7 @@ trim_messages(
 
 ## Long-term memory
 
-Long-term memory in LangGraph allows systems to retain information across different conversations or sessions. Unlike short-term memory, which is **thread-scoped**, long-term memory is saved within custom "namespaces."
+Long-term memory in LangGraph allows systems to retain information across different conversations or sessions. Unlike short-term memory, which is thread-scoped, long-term memory is saved within custom "namespaces."
 
 ### Storing memories
 
@@ -180,34 +180,16 @@ LangGraph stores long-term memories as JSON documents in a [store](persistence.m
 ```python
 from langgraph.store.memory import InMemoryStore
 
-
-def embed(texts: list[str]) -> list[list[float]]:
-    # Replace with an actual embedding function or LangChain embeddings object
-    return [[1.0, 2.0] * len(texts)]
-
-
 # InMemoryStore saves data to an in-memory dictionary. Use a DB-backed store in production use.
-store = InMemoryStore(index={"embed": embed, "dims": 2})
+store = InMemoryStore()
 user_id = "my-user"
 application_context = "chitchat"
 namespace = (user_id, application_context)
-store.put(
-    namespace,
-    "a-memory",
-    {
-        "rules": [
-            "User likes short, direct language",
-            "User only speaks English & python",
-        ],
-        "my-key": "my-value",
-    },
-)
+store.put(namespace, "a-memory", {"rules": ["User likes short, direct language", "User only speaks English & python"], "my-key": "my-value"})
 # get the "memory" by ID
 item = store.get(namespace, "a-memory")
-# search for "memories" within this namespace, filtering on content equivalence, sorted by vector similarity
-items = store.search(
-    namespace, filter={"my-key": "my-value"}, query="language preferences"
-)
+# list "memories" within this namespace, filtering on content equivalence
+items = store.search(namespace, filter={"my-key": "my-value"})
 ```
 
 ### Framework for thinking about long-term memory
@@ -236,9 +218,6 @@ Different applications require various types of memory. Although the analogy isn
 
 [Semantic memory](https://en.wikipedia.org/wiki/Semantic_memory), both in humans and AI agents, involves the retention of specific facts and concepts. In humans, it can include information learned in school and the understanding of concepts and their relationships. For AI agents, semantic memory is often used to personalize applications by remembering facts or concepts from past interactions. 
 
-> Note: Not to be confused with "semantic search" which is a technique for finding similar content using "meaning" (usually as embeddings). Semantic memory is a term from psychology, referring to storing facts and knowledge, while semantic search is a method for retrieving information based on meaning rather than exact matches.
-
-
 #### Profile
 
 Semantic memories can be managed in different ways. For example, memories can be a single, continuously updated "profile" of well-scoped and specific information about a user, organization, or other entity (including the agent itself). A profile is generally just a JSON document with various key-value pairs you've selected to represent your domain. 
@@ -253,7 +232,7 @@ Alternatively, memories can be a collection of documents that are continuously u
 
 However, this shifts some complexity memory updating. The model must now _delete_ or _update_ existing items in the list, which can be tricky. In addition, some models may default to over-inserting and others may default to over-updating. See the [Trustcall](https://github.com/hinthornw/trustcall) package for one way to manage this and consider evaluation (e.g., with a tool like [LangSmith](https://docs.smith.langchain.com/tutorials/Developers/evaluation)) to help you tune the behavior.
 
-Working with document collections also shifts complexity to memory **search** over the list. The `Store` currently supports both [semantic search](https://langchain-ai.github.io/langgraph/reference/store/#langgraph.store.base.SearchOp.query) and [filtering by content](https://langchain-ai.github.io/langgraph/reference/store/#langgraph.store.base.SearchOp.filter).
+Working with document collections also shifts complexity to memory **search** over the list. The `Store` currently supports [filtering by metadata](https://langchain-ai.github.io/langgraph/reference/store/#storage) and will soon add [semantic search shortly](https://python.langchain.com/docs/concepts/vectorstores/), but selecting the most relevant documents can be tricky as the list grows.
 
 Finally, using a collection of memories can make it challenging to provide comprehensive context to the model. While individual memories may follow a specific schema, this structure might not capture the full context or relationships between memories. As a result, when using these memories to generate responses, the model may lack important contextual information that would be more readily available in a unified profile approach.
 

docs/docs/concepts/multi_agent.md

@@ -28,7 +28,12 @@ There are several ways to connect agents in a multi-agent system:
 
 ### Network
 
-In this architecture, agents are defined as graph nodes. Each agent can communicate with every other agent (many-to-many connections) and can decide which agent to call next. This architecture is good for problems that do not have a clear hierarchy of agents or a specific sequence in which agents should be called.
+In this architecture, agents are defined as graph nodes. Each agent can communicate with every other agent (many-to-many connections) and can decide which agent to call next. While very flexible, this architecture doesn't scale well as the number of agents grows:
+
+- hard to enforce which agent should be called next
+- hard to determine how much [information](#shared-message-list) should be passed between the agents
+
+We recommend avoiding this architecture in production and using one of the below architectures instead.
 
 ### Supervisor
 

docs/docs/concepts/persistence.md

@@ -218,16 +218,13 @@ The final thing you can optionally specify when calling `update_state` is `as_no
 
 ## Memory Store
 
-![Model of shared state](img/persistence/shared_state.png)
+![Update](img/persistence/shared_state.png)
 
 A [state schema](low_level.md#schema) specifies a set of keys that are populated as a graph is executed. As discussed above, state can be written by a checkpointer to a thread at each graph step, enabling state persistence.
 
 But, what if we want to retrain some information *across threads*? Consider the case of a chatbot where we want to retain specific information about the user across *all* chat conversations (e.g., threads) with that user!
 
-With checkpointers alone, we cannot share information across threads. This motivates the need for the [`Store`](../reference/store.md#langgraph.store.base.BaseStore) interface. As an illustration, we can define an `InMemoryStore` to store information about a user across threads. We simply compile our graph with a checkpointer, as before, and with our new `in_memory_store` variable.
-
-### Basic Usage
-
+With checkpointers alone, we cannot share information across threads. This motivates the need for the `Store` interface. As an illustration, we can define an `InMemoryStore` to store information about a user across threads. We simply compile our graph with a checkpointer, as before, and will our new `in_memory_store`.
 First, let's showcase this in isolation without using LangGraph.
 
 ```python
@@ -242,7 +239,7 @@ user_id = "1"
 namespace_for_memory = (user_id, "memories")
 ```
 
-We use the `store.put` method to save memories to our namespace in the store. When we do this, we specify the namespace, as defined above, and a key-value pair for the memory: the key is simply a unique identifier for the memory (`memory_id`) and the value (a dictionary) is the memory itself.
+We use the `store.put` to save memories to our namespace in the store. When we do this, we specify the namespace, as defined above, and a key-value pair for the memory: the key is simply a unique identifier for the memory (`memory_id`) and the value (a dictionary) is the memory itself.
 
 ```python
 memory_id = str(uuid.uuid4())
@@ -250,7 +247,7 @@ memory = {"food_preference" : "I like pizza"}
 in_memory_store.put(namespace_for_memory, memory_id, memory)
 ```
 
-We can read out memories in our namespace using the `store.search` method, which will return all memories for a given user as a list. The most recent memory is the last in the list.
+We can read out memories in our namespace using `store.search`, which will return all memories for a given user as a list. The most recent memory is the last in the list.
 
 ```python
 memories = in_memory_store.search(namespace_for_memory)
@@ -262,69 +259,16 @@ memories[-1].dict()
  'updated_at': '2024-10-02T17:22:31.590605+00:00'}
 ```
 
-Each memory type is a Python class ([`Item`](https://langchain-ai.github.io/langgraph/reference/store/#langgraph.store.base.Item)) with certain attributes. We can access it as a dictionary by converting via `.dict` as above.
+Each memory type is a Python class with certain attributes. We can access it as a dictionary by converting via `.dict` as above.
 The attributes it has are:
 
 - `value`: The value (itself a dictionary) of this memory
-- `key`: A unique key for this memory in this namespace
+- `key`: The UUID for this memory in this namespace
 - `namespace`: A list of strings, the namespace of this memory type
 - `created_at`: Timestamp for when this memory was created
 - `updated_at`: Timestamp for when this memory was updated
 
-### Semantic Search
-
-Beyond simple retrieval, the store also supports semantic search, allowing you to find memories based on meaning rather than exact matches. To enable this, configure the store with an embedding model:
-
-```python
-from langchain.embeddings import init_embeddings
-
-store = InMemoryStore(
-    index={
-        "embed": init_embeddings("openai:text-embedding-3-small"),  # Embedding provider
-        "dims": 1536,                              # Embedding dimensions
-        "fields": ["food_preference", "$"]              # Fields to embed
-    }
-)
-```
-
-Now when searching, you can use natural language queries to find relevant memories:
-
-```python
-# Find memories about food preferences
-# (This can be done after putting memories into the store)
-memories = store.search(
-    namespace_for_memory,
-    query="What does the user like to eat?",
-    limit=3  # Return top 3 matches
-)
-```
-
-You can control which parts of your memories get embedded by configuring the `fields` parameter or by specifying the `index` parameter when storing memories:
-
-```python
-# Store with specific fields to embed
-store.put(
-    namespace_for_memory,
-    str(uuid.uuid4()),
-    {
-        "food_preference": "I love Italian cuisine",
-        "context": "Discussing dinner plans"
-    },
-    index=["food_preference"]  # Only embed "food_preferences" field
-)
-
-# Store without embedding (still retrievable, but not searchable)
-store.put(
-    namespace_for_memory,
-    str(uuid.uuid4()),
-    {"system_info": "Last updated: 2024-01-01"},
-    index=False
-)
-```
-
-### Using in LangGraph
-
-With this all in place, we use the `in_memory_store` in LangGraph. The `in_memory_store` works hand-in-hand with the checkpointer: the checkpointer saves state to threads, as discussed above, and the `in_memory_store` allows us to store arbitrary information for access *across* threads. We compile the graph with both the checkpointer and the `in_memory_store` as follows. 
+With this all in place, we use the `in_memory_store` in LangGraph. The `in_memory_store` works hand-in-hand with the checkpointer: the checkpointer saves state to threads, as discussed above, and the the `in_memory_store` allows us to store arbitrary information for access *across* threads. We compile the graph with both the checkpointer and the `in_memory_store` as follows. 
 
 ```python
 from langgraph.checkpoint.memory import MemorySaver
@@ -352,7 +296,7 @@ for update in graph.stream(
     print(update)
 ```
 
-We can access the `in_memory_store` and the `user_id` in *any node* by passing `store: BaseStore` and `config: RunnableConfig` as node arguments. Here's how we might use semantic search in a node to find relevant memories:
+We can access the `in_memory_store` and the `user_id` in *any node* by passing `store: BaseStore` and `config: RunnableConfig` as node arguments. Just as we saw above, simply use the `put` method to save memories to the store.
 
 ```python
 def update_memory(state: MessagesState, config: RunnableConfig, *, store: BaseStore):
@@ -373,7 +317,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 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 `search` 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()
@@ -388,15 +332,12 @@ We can access the memories and use them in our model call.
 
 ```python
 def call_model(state: MessagesState, config: RunnableConfig, *, store: BaseStore):
+    
     # Get the user id from the config
     user_id = config["configurable"]["user_id"]
     
-    # Search based on the most recent message
-    memories = store.search(
-        namespace,
-        query=state["messages"][-1].content,
-        limit=3
-    )
+    # Get the memories for the user from the store
+    memories = store.search(("memories", user_id))
     info = "\n".join([d.value["memory"] for d in memories])
     
     # ... Use memories in the model call
@@ -415,22 +356,7 @@ for update in graph.stream(
     print(update)
 ```
 
-When we use the LangGraph Platform, either locally (e.g., in LangGraph Studio) or with LangGraph Cloud, the base store is available to use by default and does not need to be specified during graph compilation. To enable semantic search, however, you **do** need to configure the indexing settings in your `langgraph.json` file. For example:
-
-```json
-{
-    ...
-    "store": {
-        "index": {
-            "embed": "openai:text-embeddings-3-small",
-            "dims": 1536,
-            "fields": ["$"]
-        }
-    }
-}
-```
-
-See the [deployment guide](../cloud/deployment/semantic_search.md) for more details and configuration options.
+When we use the LangGraph API, either locally (e.g., in LangGraph Studio) or with LangGraph Cloud, the memory store is available to use by default and does not need to be specified during graph compilation.
 
 ## Checkpointer libraries
 
@@ -479,4 +405,4 @@ Lastly, checkpointing also provides fault-tolerance and error recovery: if one o
 
 #### Pending writes
 
-Additionally, when a graph node fails mid-execution at a given superstep, LangGraph stores pending checkpoint writes from any other nodes that completed successfully at that superstep, so that whenever we resume graph execution from that superstep we don't re-run the successful nodes.
+Additionally, when a graph node fails mid-execution at a given superstep, LangGraph stores pending checkpoint writes from any other nodes that completed successfully at that superstep, so that whenever we resume graph execution from that superstep we don't re-run the successful nodes.

docs/docs/concepts/self_hosted.md

@@ -7,7 +7,7 @@
 
 ## Versions
 
-There are two versions of the self-hosted deployment: [Self-Hosted Enterprise](./deployment_options.md#self-hosted-enterprise) and [Self-Hosted Lite](./deployment_options.md#self-hosted-lite).
+There are two versions of the self hosted deployment: [Self-Hosted Enterprise](./deployment_options.md#self-hosted-enterprise) and [Self-Hosted Lite](./deployment_options.md#self-hosted-lite).
 
 ### Self-Hosted Lite
 
@@ -34,10 +34,6 @@ To use the Self-Hosted Enterprise version, you must acquire a license key that y
 
 For step-by-step instructions, see [How to set up a self-hosted deployment of LangGraph](../how-tos/deploy-self-hosted.md).
 
-## Helm Chart
-
-If you would like to deploy LangGraph Cloud on Kubernetes, you can use this [Helm chart](https://github.com/langchain-ai/helm/blob/main/charts/langgraph-cloud/README.md).
-
 ## Related
 
 - [How to set up a self-hosted deployment of LangGraph](../how-tos/deploy-self-hosted.md).

docs/docs/how-tos/cross-thread-persistence.ipynb

@@ -41,9 +41,6 @@
     "    <p>\n",
     "    Support for the <code><a href=\"https://langchain-ai.github.io/langgraph/reference/store/#langgraph.store.base.BaseStore\">Store</a></code> API that is used in this guide was added in LangGraph <code>v0.2.32</code>.\n",
     "    </p>\n",
-    "    <p>\n",
-    "    Support for <b>index</b> and <b>query</b> arguments of the <code><a href=\"https://langchain-ai.github.io/langgraph/reference/store/#langgraph.store.base.BaseStore\">Store</a></code> API that is used in this guide was added in LangGraph <code>v0.2.54</code>.\n",
-    "    </p>\n",
     "</div>\n",
     "\n",
     "## Setup\n",
@@ -117,7 +114,7 @@
     "\n",
     "Importantly, to determine the user, we will be passing `user_id` via the config keyword argument of the node function.\n",
     "\n",
-    "Let's first define an `InMemoryStore` already populated with some memories about the users."
+    "Let's first define an `InMemoryStore` which is already populated with some memories about the users."
    ]
   },
   {
@@ -128,14 +125,8 @@
    "outputs": [],
    "source": [
     "from langgraph.store.memory import InMemoryStore\n",
-    "from langchain_openai import OpenAIEmbeddings\n",
     "\n",
-    "in_memory_store = InMemoryStore(\n",
-    "    index={\n",
-    "        \"embed\": OpenAIEmbeddings(model=\"text-embedding-3-small\"),\n",
-    "        \"dims\": 1536,\n",
-    "    }\n",
-    ")"
+    "in_memory_store = InMemoryStore()"
    ]
   },
   {
@@ -172,7 +163,7 @@
     "def call_model(state: MessagesState, config: RunnableConfig, *, store: BaseStore):\n",
     "    user_id = config[\"configurable\"][\"user_id\"]\n",
     "    namespace = (\"memories\", user_id)\n",
-    "    memories = store.search(namespace, query=str(state[\"messages\"][-1].content))\n",
+    "    memories = store.search(namespace)\n",
     "    info = \"\\n\".join([d.value[\"data\"] for d in memories])\n",
     "    system_msg = f\"You are a helpful assistant talking to the user. User info: {info}\"\n",
     "\n",

docs/docs/how-tos/deploy-self-hosted.md

@@ -17,10 +17,6 @@ You will need to do the following:
 2. Build a docker image with the [LangGraph Server](../concepts/langgraph_server.md) using the [LangGraph CLI](../concepts/langgraph_cli.md).
 3. Deploy a web server that will run the docker image and pass in the necessary environment variables.
 
-## Helm Chart
-
-If you would like to deploy LangGraph Cloud on Kubernetes, you can use this [Helm chart](https://github.com/langchain-ai/helm/blob/main/charts/langgraph-cloud/README.md).
-
 ## Environment Variables
 
 You will eventually need to pass in the following environment variables to the LangGraph Deploy server:

docs/docs/how-tos/index.md

@@ -20,7 +20,6 @@ These how-to guides show how to achieve that controllability.
 - [How to create branches for parallel execution](branching.ipynb)
 - [How to create map-reduce branches for parallel execution](map-reduce.ipynb)
 - [How to control graph recursion limit](recursion-limit.ipynb)
-- [How to combine control flow and state updates with Command](command.ipynb)
 
 ### Persistence
 
@@ -40,8 +39,6 @@ LangGraph makes it easy to manage conversation [memory](../concepts/memory.md) i
 - [How to manage conversation history](memory/manage-conversation-history.ipynb)
 - [How to delete messages](memory/delete-messages.ipynb)
 - [How to add summary conversation memory](memory/add-summary-conversation-history.ipynb)
-- [How to add long-term memory (cross-thread)](cross-thread-persistence.ipynb)
-- [How to use semantic search for long-term memory](memory/semantic-search.ipynb)
 
 ### Human-in-the-loop
 
@@ -73,7 +70,7 @@ you to involve humans in the decision-making process of your graph. These how-to
 
 ### Tool calling
 
-[Tool calling](https://python.langchain.com/docs/concepts/tool_calling/) is a type of chat model API that accepts tool schemas, along with messages, as input and returns invocations of those tools as part of the output message.
+[Tool calling](https://python.langchain.com/docs/concepts/tool_calling/) is a type of chat model API that accepts tool schemas, along with messages, as input and returns invocations of those tools as part of the output message. 
 
 These how-to guides show common patterns for tool calling with LangGraph:
 
@@ -121,13 +118,12 @@ These guides show how to use the prebuilt ReAct agent:
 - [How to add a custom system prompt to a ReAct agent](create-react-agent-system-prompt.ipynb)
 - [How to add human-in-the-loop processes to a ReAct agent](create-react-agent-hitl.ipynb)
 - [How to create prebuilt ReAct agent from scratch](react-agent-from-scratch.ipynb)
-- [How to add semantic search for long-term memory to a ReAct agent](memory/semantic-search.ipynb#using-in-create-react-agent)
 
 ## LangGraph Platform
 
 This section includes how-to guides for LangGraph Platform.
 
-LangGraph Platform is a commercial solution for deploying agentic applications in production, built on the open-source LangGraph framework.
+LangGraph Platform is a commercial solution for deploying agentic applications in production, built on the open-source LangGraph framework. 
 
 The LangGraph Platform offers a few different deployment options described in the [deployment options guide](../concepts/deployment_options.md).
 
@@ -143,7 +139,6 @@ Learn how to set up your app for deployment to LangGraph Platform:
 - [How to set up app for deployment (requirements.txt)](../cloud/deployment/setup.md)
 - [How to set up app for deployment (pyproject.toml)](../cloud/deployment/setup_pyproject.md)
 - [How to set up app for deployment (JavaScript)](../cloud/deployment/setup_javascript.md)
-- [How to add semantic search](../cloud/deployment/semantic_search.md)
 - [How to customize Dockerfile](../cloud/deployment/custom_docker.md)
 - [How to test locally](../cloud/deployment/test_locally.md)
 - [How to rebuild graph at runtime](../cloud/deployment/graph_rebuild.md)
@@ -155,8 +150,8 @@ LangGraph applications can be deployed using LangGraph Cloud, which provides a r
 
 - [How to deploy to LangGraph cloud](../cloud/deployment/cloud.md)
 - [How to deploy to a self-hosted environment](./deploy-self-hosted.md)
-- [How to interact with the deployment using RemoteGraph](./use-remote-graph.md)
-
+- [How to interact with the deployment using RemoteGraph](./use-remote-graph.md) 
+ 
 ### Assistants
 
 [Assistants](../concepts/assistants.md) is a configured instance of a template.
@@ -201,7 +196,7 @@ When designing complex graphs, relying entirely on the LLM for decision-making c
 
 ### Double-texting
 
-Graph execution can take a while, and sometimes users may change their mind about the input they wanted to send before their original input has finished running. For example, a user might notice a typo in their original request and will edit the prompt and resend it. Deciding what to do in these cases is important for ensuring a smooth user experience and preventing your graphs from behaving in unexpected ways.
+Graph execution can take a while, and sometimes users may change their mind about the input they wanted to send before their original input has finished running. For example, a user might notice a typo in their original request and will edit the prompt and resend it. Deciding what to do in these cases is important for ensuring a smooth user experience and preventing your graphs from behaving in unexpected ways. 
 
 - [How to use the interrupt option](../cloud/how-tos/interrupt_concurrent.md)
 - [How to use the rollback option](../cloud/how-tos/rollback_concurrent.md)
@@ -221,9 +216,8 @@ Graph execution can take a while, and sometimes users may change their mind abou
 LangGraph Studio is a built-in UI for visualizing, testing, and debugging your agents.
 
 - [How to connect to a LangGraph Cloud deployment](../cloud/how-tos/test_deployment.md)
-- [How to connect to a local dev server](../how-tos/local-studio.md)
-- [How to connect to a local deployment (Docker)](../cloud/how-tos/test_local_deployment.md)
-- [How to test your graph in LangGraph Studio (MacOS only)](../cloud/how-tos/invoke_studio.md)
+- [How to connect to a local deployment](../cloud/how-tos/test_local_deployment.md)
+- [How to test your graph in LangGraph Studio](../cloud/how-tos/invoke_studio.md)
 - [How to interact with threads in LangGraph Studio](../cloud/how-tos/threads_studio.md)
 
 ## Troubleshooting
@@ -235,3 +229,5 @@ These are the guides for resolving common errors you may find while building wit
 - [INVALID_GRAPH_NODE_RETURN_VALUE](../troubleshooting/errors/INVALID_GRAPH_NODE_RETURN_VALUE.md)
 - [MULTIPLE_SUBGRAPHS](../troubleshooting/errors/MULTIPLE_SUBGRAPHS.md)
 - [INVALID_CHAT_HISTORY](../troubleshooting/errors/INVALID_CHAT_HISTORY.md)
+
+

docs/docs/how-tos/memory/semantic-search.ipynb

@@ -1,532 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# How to add semantic search to your agent's memory\n",
-    "\n",
-    "This guide shows how to enable semantic search in your agent's memory store. This lets search for items in the store by semantic similarity.\n",
-    "\n",
-    "!!! tip Prerequisites\n",
-    "    This guide assumes familiarity with the [memory in LangGraph](https://langchain-ai.github.io/langgraph/concepts/memory/).\n",
-    "\n",
-    "First, install this guide's prerequisites."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%%capture --no-stderr\n",
-    "%pip install -U langgraph langchain-openai langchain"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import getpass\n",
-    "import os\n",
-    "\n",
-    "\n",
-    "def _set_env(var: str):\n",
-    "    if not os.environ.get(var):\n",
-    "        os.environ[var] = getpass.getpass(f\"{var}: \")\n",
-    "\n",
-    "\n",
-    "_set_env(\"OPENAI_API_KEY\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Next, create the store with an [index configuration](https://langchain-ai.github.io/langgraph/reference/store/#langgraph.store.base.IndexConfig). By default, stores are configured without semantic/vector search. You can opt in to indexing items when creating the store by providing an [IndexConfig](https://langchain-ai.github.io/langgraph/reference/store/#langgraph.store.base.IndexConfig) to the store's constructor. If your store class does not implement this interface, or if you do not pass in an index configuration, semantic search is disabled, and all `index` arguments passed to `put` or `aput` will have no effect. Below is an example."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/var/folders/gf/6rnp_mbx5914kx7qmmh7xzmw0000gn/T/ipykernel_83572/2318027494.py:5: LangChainBetaWarning: The function `init_embeddings` is in beta. It is actively being worked on, so the API may change.\n",
-      "  embeddings = init_embeddings(\"openai:text-embedding-3-small\")\n"
-     ]
-    }
-   ],
-   "source": [
-    "from langchain.embeddings import init_embeddings\n",
-    "from langgraph.store.memory import InMemoryStore\n",
-    "\n",
-    "# Create store with semantic search enabled\n",
-    "embeddings = init_embeddings(\"openai:text-embedding-3-small\")\n",
-    "store = InMemoryStore(\n",
-    "    index={\n",
-    "        \"embed\": embeddings,\n",
-    "        \"dims\": 1536,\n",
-    "    }\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Now let's store some memories:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Store some memories\n",
-    "store.put((\"user_123\", \"memories\"), \"1\", {\"text\": \"I love pizza\"})\n",
-    "store.put((\"user_123\", \"memories\"), \"2\", {\"text\": \"I prefer Italian food\"})\n",
-    "store.put((\"user_123\", \"memories\"), \"3\", {\"text\": \"I don't like spicy food\"})\n",
-    "store.put((\"user_123\", \"memories\"), \"3\", {\"text\": \"I am studying econometrics\"})\n",
-    "store.put((\"user_123\", \"memories\"), \"3\", {\"text\": \"I am a plumber\"})"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Search memories using natural language:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Memory: I prefer Italian food (similarity: 0.46482669521168163)\n",
-      "Memory: I love pizza (similarity: 0.35514845174380766)\n",
-      "Memory: I am a plumber (similarity: 0.155698702336571)\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Find memories about food preferences\n",
-    "memories = store.search((\"user_123\", \"memories\"), query=\"I like food?\", limit=5)\n",
-    "\n",
-    "for memory in memories:\n",
-    "    print(f'Memory: {memory.value[\"text\"]} (similarity: {memory.score})')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Using in your agent\n",
-    "\n",
-    "Add semantic search to any node by injecting the store."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "What are you in the mood for? Since you love Italian food and pizza, would you like to order a pizza or try making one at home?"
-     ]
-    }
-   ],
-   "source": [
-    "from typing import Optional\n",
-    "\n",
-    "from langchain.chat_models import init_chat_model\n",
-    "from langgraph.store.base import BaseStore\n",
-    "\n",
-    "from langgraph.graph import START, MessagesState, StateGraph\n",
-    "\n",
-    "llm = init_chat_model(\"openai:gpt-4o-mini\")\n",
-    "\n",
-    "\n",
-    "def chat(state, *, store: BaseStore):\n",
-    "    # Search based on user's last message\n",
-    "    items = store.search(\n",
-    "        (\"user_123\", \"memories\"), query=state[\"messages\"][-1].content, limit=2\n",
-    "    )\n",
-    "    memories = \"\\n\".join(item.value[\"text\"] for item in items)\n",
-    "    memories = f\"## Memories of user\\n{memories}\" if memories else \"\"\n",
-    "    response = llm.invoke(\n",
-    "        [\n",
-    "            {\"role\": \"system\", \"content\": f\"You are a helpful assistant.\\n{memories}\"},\n",
-    "            *state[\"messages\"],\n",
-    "        ]\n",
-    "    )\n",
-    "    return {\"messages\": [response]}\n",
-    "\n",
-    "\n",
-    "builder = StateGraph(MessagesState)\n",
-    "builder.add_node(chat)\n",
-    "builder.add_edge(START, \"chat\")\n",
-    "graph = builder.compile(store=store)\n",
-    "\n",
-    "for message, metadata in graph.stream(\n",
-    "    input={\"messages\": [{\"role\": \"user\", \"content\": \"I'm hungry\"}]},\n",
-    "    stream_mode=\"messages\",\n",
-    "):\n",
-    "    print(message.content, end=\"\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Using in `create_react_agent`\n",
-    "\n",
-    "Add semantic search to your tool calling agent by injecting the store in the `state_modifier`. You can also use the store in a tool to let your agent manually store or search for memories."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import uuid\n",
-    "from typing import Optional\n",
-    "\n",
-    "from langchain.chat_models import init_chat_model\n",
-    "from langchain_core.tools import InjectedToolArg\n",
-    "from langgraph.store.base import BaseStore\n",
-    "from typing_extensions import Annotated\n",
-    "\n",
-    "from langgraph.prebuilt import create_react_agent\n",
-    "\n",
-    "\n",
-    "def prepare_messages(state, *, store: BaseStore):\n",
-    "    # Search based on user's last message\n",
-    "    items = store.search(\n",
-    "        (\"user_123\", \"memories\"), query=state[\"messages\"][-1].content, limit=2\n",
-    "    )\n",
-    "    memories = \"\\n\".join(item.value[\"text\"] for item in items)\n",
-    "    memories = f\"## Memories of user\\n{memories}\" if memories else \"\"\n",
-    "    return [\n",
-    "        {\"role\": \"system\", \"content\": f\"You are a helpful assistant.\\n{memories}\"}\n",
-    "    ] + state[\"messages\"]\n",
-    "\n",
-    "\n",
-    "# You can also use the store directly within a tool!\n",
-    "def upsert_memory(\n",
-    "    content: str,\n",
-    "    *,\n",
-    "    memory_id: Optional[uuid.UUID] = None,\n",
-    "    store: Annotated[BaseStore, InjectedToolArg],\n",
-    "):\n",
-    "    \"\"\"Upsert a memory in the database.\"\"\"\n",
-    "    # The LLM can use this tool to store a new memory\n",
-    "    mem_id = memory_id or uuid.uuid4()\n",
-    "    store.put(\n",
-    "        (\"user_123\", \"memories\"),\n",
-    "        key=str(mem_id),\n",
-    "        value={\"text\": content},\n",
-    "    )\n",
-    "    return f\"Stored memory {mem_id}\"\n",
-    "\n",
-    "\n",
-    "agent = create_react_agent(\n",
-    "    init_chat_model(\"openai:gpt-4o-mini\"),\n",
-    "    tools=[upsert_memory],\n",
-    "    # The state_modifier is run to prepare the messages for the LLM. It is called\n",
-    "    # right before each LLM call\n",
-    "    state_modifier=prepare_messages,\n",
-    "    store=store,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "What are you in the mood for? Since you love Italian food and pizza, maybe something in that realm would be great! Would you like suggestions for a specific dish or restaurant?"
-     ]
-    }
-   ],
-   "source": [
-    "for message, metadata in agent.stream(\n",
-    "    input={\"messages\": [{\"role\": \"user\", \"content\": \"I'm hungry\"}]},\n",
-    "    stream_mode=\"messages\",\n",
-    "):\n",
-    "    print(message.content, end=\"\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Advanced Usage\n",
-    "\n",
-    "#### Multi-vector indexing\n",
-    "\n",
-    "Store and search different aspects of memories separately to improve recall or omit certain fields from being indexed."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Expect mem 2\n",
-      "Item: mem2; Score (0.5895009051396596)\n",
-      "Memory: Ate alone at home\n",
-      "Emotion: felt a bit lonely\n",
-      "\n",
-      "Expect mem1\n",
-      "Item: mem1; Score (0.6207546534134083)\n",
-      "Memory: Had pizza with friends at Mario's\n",
-      "Emotion: felt happy and connected\n",
-      "\n",
-      "Expect random lower score (ravioli not indexed)\n",
-      "Item: mem1; Score (0.2686278787315685)\n",
-      "Memory: Had pizza with friends at Mario's\n",
-      "Emotion: felt happy and connected\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Configure store to embed both memory content and emotional context\n",
-    "store = InMemoryStore(\n",
-    "    index={\"embed\": embeddings, \"dims\": 1536, \"fields\": [\"memory\", \"emotional_context\"]}\n",
-    ")\n",
-    "# Store memories with different content/emotion pairs\n",
-    "store.put(\n",
-    "    (\"user_123\", \"memories\"),\n",
-    "    \"mem1\",\n",
-    "    {\n",
-    "        \"memory\": \"Had pizza with friends at Mario's\",\n",
-    "        \"emotional_context\": \"felt happy and connected\",\n",
-    "        \"this_isnt_indexed\": \"I prefer ravioli though\",\n",
-    "    },\n",
-    ")\n",
-    "store.put(\n",
-    "    (\"user_123\", \"memories\"),\n",
-    "    \"mem2\",\n",
-    "    {\n",
-    "        \"memory\": \"Ate alone at home\",\n",
-    "        \"emotional_context\": \"felt a bit lonely\",\n",
-    "        \"this_isnt_indexed\": \"I like pie\",\n",
-    "    },\n",
-    ")\n",
-    "\n",
-    "# Search focusing on emotional state - matches mem2\n",
-    "results = store.search(\n",
-    "    (\"user_123\", \"memories\"), query=\"times they felt isolated\", limit=1\n",
-    ")\n",
-    "print(\"Expect mem 2\")\n",
-    "for r in results:\n",
-    "    print(f\"Item: {r.key}; Score ({r.score})\")\n",
-    "    print(f\"Memory: {r.value['memory']}\")\n",
-    "    print(f\"Emotion: {r.value['emotional_context']}\\n\")\n",
-    "\n",
-    "# Search focusing on social eating - matches mem1\n",
-    "print(\"Expect mem1\")\n",
-    "results = store.search((\"user_123\", \"memories\"), query=\"fun pizza\", limit=1)\n",
-    "for r in results:\n",
-    "    print(f\"Item: {r.key}; Score ({r.score})\")\n",
-    "    print(f\"Memory: {r.value['memory']}\")\n",
-    "    print(f\"Emotion: {r.value['emotional_context']}\\n\")\n",
-    "\n",
-    "print(\"Expect random lower score (ravioli not indexed)\")\n",
-    "results = store.search((\"user_123\", \"memories\"), query=\"ravioli\", limit=1)\n",
-    "for r in results:\n",
-    "    print(f\"Item: {r.key}; Score ({r.score})\")\n",
-    "    print(f\"Memory: {r.value['memory']}\")\n",
-    "    print(f\"Emotion: {r.value['emotional_context']}\\n\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### Override fields at storage time\n",
-    "You can override which fields to embed when storing a specific memory using `put(..., index=[...fields])`, regardless of the store's default configuration."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Expect mem1\n",
-      "Item: mem1; Score (0.3374968677940555)\n",
-      "Memory: I love spicy food\n",
-      "Context: At a Thai restaurant\n",
-      "\n",
-      "Expect mem2\n",
-      "Item: mem2; Score (0.36784461593247436)\n",
-      "Memory: The restaurant was too loud\n",
-      "Context: Dinner at an Italian place\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "store = InMemoryStore(\n",
-    "    index={\n",
-    "        \"embed\": embeddings,\n",
-    "        \"dims\": 1536,\n",
-    "        \"fields\": [\"memory\"],\n",
-    "    }  # Default to embed memory field\n",
-    ")\n",
-    "\n",
-    "# Store one memory with default indexing\n",
-    "store.put(\n",
-    "    (\"user_123\", \"memories\"),\n",
-    "    \"mem1\",\n",
-    "    {\"memory\": \"I love spicy food\", \"context\": \"At a Thai restaurant\"},\n",
-    ")\n",
-    "\n",
-    "# Store another overriding which fields to embed\n",
-    "store.put(\n",
-    "    (\"user_123\", \"memories\"),\n",
-    "    \"mem2\",\n",
-    "    {\"memory\": \"The restaurant was too loud\", \"context\": \"Dinner at an Italian place\"},\n",
-    "    index=[\"context\"],  # Override: only embed the context\n",
-    ")\n",
-    "\n",
-    "# Search about food - matches mem1 (using default field)\n",
-    "print(\"Expect mem1\")\n",
-    "results = store.search(\n",
-    "    (\"user_123\", \"memories\"), query=\"what food do they like\", limit=1\n",
-    ")\n",
-    "for r in results:\n",
-    "    print(f\"Item: {r.key}; Score ({r.score})\")\n",
-    "    print(f\"Memory: {r.value['memory']}\")\n",
-    "    print(f\"Context: {r.value['context']}\\n\")\n",
-    "\n",
-    "# Search about restaurant atmosphere - matches mem2 (using overridden field)\n",
-    "print(\"Expect mem2\")\n",
-    "results = store.search(\n",
-    "    (\"user_123\", \"memories\"), query=\"restaurant environment\", limit=1\n",
-    ")\n",
-    "for r in results:\n",
-    "    print(f\"Item: {r.key}; Score ({r.score})\")\n",
-    "    print(f\"Memory: {r.value['memory']}\")\n",
-    "    print(f\"Context: {r.value['context']}\\n\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "#### Disable Indexing for Specific Memories\n",
-    "\n",
-    "Some memories shouldn't be searchable by content. You can disable indexing for these while still storing them using \n",
-    "`put(..., index=False)`. Example:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Expect mem1\n",
-      "Item: mem1; Score (0.32269984224327286)\n",
-      "Memory: I love chocolate ice cream\n",
-      "Type: preference\n",
-      "\n",
-      "Expect low score (mem2 not indexed)\n",
-      "Item: mem1; Score (0.010241633698527089)\n",
-      "Memory: I love chocolate ice cream\n",
-      "Type: preference\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "store = InMemoryStore(index={\"embed\": embeddings, \"dims\": 1536, \"fields\": [\"memory\"]})\n",
-    "\n",
-    "# Store a normal indexed memory\n",
-    "store.put(\n",
-    "    (\"user_123\", \"memories\"),\n",
-    "    \"mem1\",\n",
-    "    {\"memory\": \"I love chocolate ice cream\", \"type\": \"preference\"},\n",
-    ")\n",
-    "\n",
-    "# Store a system memory without indexing\n",
-    "store.put(\n",
-    "    (\"user_123\", \"memories\"),\n",
-    "    \"mem2\",\n",
-    "    {\"memory\": \"User completed onboarding\", \"type\": \"system\"},\n",
-    "    index=False,  # Disable indexing entirely\n",
-    ")\n",
-    "\n",
-    "# Search about food preferences - finds mem1\n",
-    "print(\"Expect mem1\")\n",
-    "results = store.search((\"user_123\", \"memories\"), query=\"what food preferences\", limit=1)\n",
-    "for r in results:\n",
-    "    print(f\"Item: {r.key}; Score ({r.score})\")\n",
-    "    print(f\"Memory: {r.value['memory']}\")\n",
-    "    print(f\"Type: {r.value['type']}\\n\")\n",
-    "\n",
-    "# Search about onboarding - won't find mem2 (not indexed)\n",
-    "print(\"Expect low score (mem2 not indexed)\")\n",
-    "results = store.search((\"user_123\", \"memories\"), query=\"onboarding status\", limit=1)\n",
-    "for r in results:\n",
-    "    print(f\"Item: {r.key}; Score ({r.score})\")\n",
-    "    print(f\"Memory: {r.value['memory']}\")\n",
-    "    print(f\"Type: {r.value['type']}\\n\")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}

docs/docs/reference/types.md

@@ -13,5 +13,3 @@
         - PregelExecutableTask
         - StateSnapshot
         - Send
-        - Command
-        - interrupt

docs/docs/tutorials/index.md

@@ -6,23 +6,25 @@ title: Tutorials
 
 # Tutorials
 
-New to LangGraph or LLM app development? Read this material to get up and running building your first applications.
+Welcome to the LangGraph Tutorials! These notebooks introduce LangGraph through building various language agents and applications.
 
-## Get Started 🚀 {#quick-start}
+## Quick Start
 
-- [LangGraph Quickstart](introduction.ipynb): Build a chatbot that can use tools and keep track of conversation history. Add human-in-the-loop capabilities and explore how time-travel works.
-- [LangGraph Server Quickstart](langgraph-platform/local-server.md): Launch a LangGraph server locally and interact with it using the REST API and LangGraph Studio Web UI.
-- [LangGraph Cloud QuickStart](../cloud/quick_start.md): Deploy a LangGraph app using LangGraph Cloud.
+Learn the basics of LangGraph through a comprehensive quick start in which you will build an agent from scratch.
 
-## Use cases 🛠️
+- [Quick Start](introduction.ipynb): In this tutorial, you will build a support chatbot using LangGraph.
+- [LangGraph Cloud Quick Start](../cloud/quick_start.md): In this tutorial, you will build and deploy an agent to LangGraph Cloud.
 
-Explore practical implementations tailored for specific scenarios:
+## Use cases
+
+Learn from example implementations of graphs designed for specific scenarios and that implement common design patterns.
 
 ### Chatbots
 
-- [Customer Support](customer-support/customer-support.ipynb): Build a multi-functional support bot for flights, hotels, and car rentals.
-- [Prompt Generation from User Requirements](chatbots/information-gather-prompting.ipynb): Build an information gathering chatbot.
-- [Code Assistant](code_assistant/langgraph_code_assistant.ipynb): Build a code analysis and generation assistant.
+- [Customer Support](customer-support/customer-support.ipynb): Build a customer support chatbot to manage flights, hotel reservations, car rentals, and other tasks
+- [Prompt Generation from User Requirements](chatbots/information-gather-prompting.ipynb): Build an information gathering chatbot
+- [Code Assistant](code_assistant/langgraph_code_assistant.ipynb): Build a code analysis and generation assistant
+
 
 ### RAG
 

docs/docs/tutorials/introduction.ipynb

@@ -5,21 +5,21 @@
    "id": "4a1aae78-88a6-4133-b905-7e46c8e3772f",
    "metadata": {},
    "source": [
-    "# 🚀 LangGraph Quick Start\n",
+    "# LangGraph Quick Start\n",
     "\n",
-    "In this tutorial, we will build a support chatbot in LangGraph that can:\n",
+    "In this comprehensive quick start, we will build a support chatbot in LangGraph that can:\n",
     "\n",
-    "✅ **Answer common questions** by searching the web  \n",
-    "✅ **Maintain conversation state** across calls  \n",
-    "✅ **Route complex queries** to a human for review  \n",
-    "✅ **Use custom state** to control its behavior  \n",
-    "✅ **Rewind and explore** alternative conversation paths  \n",
+    "- Answer common questions by searching the web\n",
+    "- Maintain conversation state across calls\n",
+    "- Route complex queries to a human for review\n",
+    "- Use custom state to control its behavior\n",
+    "- Rewind and explore alternative conversation paths\n",
     "\n",
-    "We'll start with a **basic chatbot** and progressively add more sophisticated capabilities, introducing key LangGraph concepts along the way. Let’s dive in! 🌟\n",
+    "We'll start with a basic chatbot and progressively add more sophisticated capabilities, introducing key LangGraph concepts along the way.\n",
     "\n",
     "## Setup\n",
     "\n",
-    "First, install the required packages and configure your environment:"
+    "First, install the required packages:"
    ]
   },
   {
@@ -33,6 +33,14 @@
     "%pip install -U langgraph langsmith langchain_anthropic"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "a6d1e870-1bc0-4d44-86c0-96681ccf6113",
+   "metadata": {},
+   "source": [
+    "Next, set your API keys:"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 2,
@@ -112,24 +120,27 @@
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
-   "id": "c08c41da-0855-49d3-9a3d-b7eb94413367",
+   "id": "31c755cd-8994-4867-bdff-96a55d7beae7",
    "metadata": {},
    "source": [
-    "Our graph can now handle two key tasks:\n",
-    "\n",
-    "1. Each `node` can receive the current `State` as input and output an update to the state.\n",
-    "2. Updates to `messages` will be appended to the existing list rather than overwriting it, thanks to the prebuilt [`add_messages`](https://langchain-ai.github.io/langgraph/reference/graphs/?h=add+messages#add_messages) function used with the `Annotated` syntax.\n",
-    "\n",
-    "------\n",
-    "\n",
-    "!!! tip \"Concept\"\n",
-    "\n",
-    "    When defining a graph, the first step is to define its `State`. The `State` includes the graph's schema and [reducer functions](https://langchain-ai.github.io/langgraph/concepts/low_level/#reducers) that handle state updates. In our example, `State` is a `TypedDict` with one key: `messages`. The [`add_messages`](https://langchain-ai.github.io/langgraph/reference/graphs/#langgraph.graph.message.add_messages) reducer function is used to append new messages to the list instead of overwriting it. Keys without a reducer annotation will overwrite previous values. Learn more about state, reducers, and related concepts in [this guide](https://langchain-ai.github.io/langgraph/reference/graphs/#langgraph.graph.message.add_messages).\n",
-    "\n",
-    "---------\n",
+    "<div class=\"admonition tip\">\n",
+    "    <p class=\"admonition-title\">Note</p>\n",
+    "    <p>\n",
+    "    The first thing you do when you define a graph is define the <code>State</code> of the graph. The <code>State</code> consists of the schema of the graph as well as <a href=\"https://langchain-ai.github.io/langgraph/concepts/low_level/#reducers\">reducer functions</a> which specify how to apply updates to the state. In our example <code>State</code> is a <code>TypedDict</code> with a single key: <code>messages</code>. The <code>messages</code> key is annotated with the <a href=\"https://langchain-ai.github.io/langgraph/reference/graphs/#langgraph.graph.message.add_messages\"><code>add_messages</code></a> reducer function, which tells LangGraph to append new messages to the existing list, rather than overwriting it. State keys without an annotation will be overwritten by each update, storing the most recent value. Check out <a href=\"https://langchain-ai.github.io/langgraph/reference/graphs/#langgraph.graph.message.add_messages\">this conceptual guide</a> to learn more about state, reducers and other low-level concepts.\n",
+    "    </p>\n",
+    "</div>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4137feed-746e-4c72-a34a-f7a699ad5dcf",
+   "metadata": {},
+   "source": [
+    "So now our graph knows two things:\n",
     "\n",
+    "1. Every `node` we define will receive the current `State` as input and return a value that updates that state.\n",
+    "2. `messages` will be _appended_ to the current list, rather than directly overwritten. This is communicated via the prebuilt [`add_messages`](https://langchain-ai.github.io/langgraph/reference/graphs/?h=add+messages#add_messages) function in the `Annotated` syntax.\n",
     "\n",
     "Next, add a \"`chatbot`\" node. Nodes represent units of work. They are typically regular python functions."
    ]
@@ -354,7 +365,7 @@
    "id": "f22c5d4a-3134-413c-81fe-dd9752fbeb66",
    "metadata": {},
    "source": [
-    "## Part 2: 🛠️ Enhancing the Chatbot with Tools\n",
+    "## Part 2: Enhancing the Chatbot with Tools\n",
     "\n",
     "To handle queries our chatbot can't answer \"from memory\", we'll integrate a web search tool. Our bot can use this tool to find relevant information and provide better responses.\n",
     "\n",
@@ -2035,7 +2046,7 @@
     "\n",
     "So far, we've relied on a simple state (it's just a list of messages!). You can go far with this simple state, but if you want to define complex behavior without relying on the message list, you can add additional fields to the state. In this section, we will extend our chat bot with a new node to illustrate this.\n",
     "\n",
-    "In the examples above, we involved a human deterministically: the graph __always__ interrupted whenever a tool was invoked. Suppose we wanted our chat bot to have the choice of relying on a human.\n",
+    "In the examples above, we involved a human deterministically: the graph __always__ interrupted whenever an tool was invoked. Suppose we wanted our chat bot to have the choice of relying on a human.\n",
     "\n",
     "One way to do this is to create a passthrough \"human\" node, before which the graph will always stop. We will only execute this node if the LLM invokes a \"human\" tool. For our convenience, we will include an \"ask_human\" flag in our graph state that we will flip if the LLM calls this tool.\n",
     "\n",
@@ -3125,29 +3136,11 @@
    "id": "e584d57f-5aad-4507-815f-0b2e4b64b791",
    "metadata": {},
    "source": [
-    "## Next Steps\n",
+    "## Conclusion\n",
     "\n",
-    "Take your journey further by exploring deployment and advanced features:\n",
+    "Congrats! You've completed the intro tutorial and built a chat bot in LangGraph that supports tool calling, persistent memory, human-in-the-loop interactivity, and even time-travel!\n",
     "\n",
-    "### Server Quickstart\n",
-    "\n",
-    "- **[LangGraph Server Quickstart](../langgraph-platform/local-server)**: Launch a LangGraph server locally and interact with it using the REST API and LangGraph Studio Web UI.\n",
-    "\n",
-    "### LangGraph Cloud\n",
-    "\n",
-    "- **[LangGraph Cloud QuickStart](../../cloud/quick_start)**: Deploy your LangGraph app using LangGraph Cloud.\n",
-    "\n",
-    "### LangGraph Framework\n",
-    "\n",
-    "- **[LangGraph Concepts](../../concepts)**: Learn the foundational concepts of LangGraph.  \n",
-    "- **[LangGraph How-to Guides](../../how-tos)**: Guides for common tasks with LangGraph.\n",
-    "\n",
-    "### LangGraph Platform\n",
-    "\n",
-    "Expand your knowledge with these resources:\n",
-    "\n",
-    "- **[LangGraph Platform Concepts](../../concepts#langgraph-platform)**: Understand the foundational concepts of the LangGraph Platform.  \n",
-    "- **[LangGraph Platform How-to Guides](../../how-tos#langgraph-platform)**: Guides for common tasks with LangGraph Platform. "
+    "The [LangGraph documentation](https://langchain-ai.github.io/langgraph/) is a great resource for diving deeper into the library's capabilities."
    ]
   }
  ],
@@ -3167,7 +3160,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.4"
+   "version": "3.11.9"
   }
  },
  "nbformat": 4,

docs/docs/tutorials/langgraph-platform/local-server.md

@@ -1,253 +0,0 @@
-# Quick Start: Launch Local LangGraph Server
-
-This is a quick start guide to help you get a LangGraph app up and running locally.
-
-!!! info "Requirements"
-
-    - Python >= 3.11
-    - [LangGraph CLI](https://langchain-ai.github.io/langgraph/cloud/reference/cli/): Requires langchain-cli[inmem] >= 0.1.58
-
-## Install the LangGraph CLI
-
-```bash
-pip install "langgraph-cli[inmem]==0.1.58" python-dotenv
-```
-
-## 🌱 Create a LangGraph App
-
-Create a new app from the `react-agent` template. This template is a simple agent that can be flexibly extended to many tools.
-
-=== "Python Server"
-
-    ```shell
-    langgraph new path/to/your/app --template react-agent-python 
-    ```
-
-=== "Node Server"
-
-    ```shell
-    langgraph new path/to/your/app --template react-agent-js
-    ```
-
-!!! tip "Additional Templates"
-
-    If you use `langgraph new` without specifying a template, you will be presented with an interactive menu that will allow you to choose from a list of available templates.
-
-## Install Dependencies
-
-In the root of your new LangGraph app, install the dependencies in `edit` mode so your local changes are used by the server:
-
-```shell
-pip install -e .
-```
-
-## Create a `.env` file
-
-You will find a `.env.example` in the root of your new LangGraph app. Create
-a `.env` file in the root of your new LangGraph app and copy the contents of the `.env.example` file into it, filling in the necessary API keys:
-
-```bash
-LANGSMITH_API_KEY=lsv2...
-TAVILY_API_KEY=tvly-...
-ANTHROPIC_API_KEY=sk-
-OPENAI_API_KEY=sk-...
-```
-
-<details><summary>Get API Keys</summary>
-    <ul>
-        <li> <b>LANGSMITH_API_KEY</b>: Go to the <a href="https://smith.langchain.com/settings">LangSmith Settings page</a>. Then clck <b>Create API Key</b>.
-        </li>
-        <li>
-            <b>ANTHROPIC_API_KEY</b>: Get an API key from <a href="https://console.anthropic.com/">Anthropic</a>.
-        </li>
-        <li>
-            <b>OPENAI_API_KEY</b>: Get an API key from <a href="https://openai.com/">OpenAI</a>.
-        </li>
-        <li>
-            <b>TAVILY_API_KEY</b>: Get an API key on the <a href="https://app.tavily.com/">Tavily website</a>.
-        </li>
-    </ul>
-</details>
-
-## 🚀 Launch LangGraph Server
-
-```shell
-langgraph dev
-```
-
-This will start up the LangGraph API server locally. If this runs successfully, you should see something like:
-
->    Ready!
-> 
->    - API: [http://localhost:8123](http://localhost:8123/)
->     
->    - Docs: http://localhost:8123/docs
->     
->    - LangGraph Studio Web UI: https://smith.langchain.com/studio/?baseUrl=http://127.0.0.1:8123
-
-
-!!! note "In-Memory Mode"
-
-    The `langgraph dev` command starts LangGraph Server in an in-memory mode. This mode is suitable for development and testing purposes. For production use, you should deploy LangGraph Server with access to a persistent storage backend.
-
-    If you want to test your application with a persistent storage backend, you can use the `langgraph up` command instead of `langgraph dev`. You will
-    need to have `docker` installed on your machine to use this command.
-
-## LangGraph Studio Web UI
-
-Test your graph in the LangGraph Studio Web UI by visiting the URL provided in the output of the `langgraph up` command.
-
->    - LangGraph Studio Web UI: https://smith.langchain.com/studio/?baseUrl=http://127.0.0.1:8123
-
-!!! warning "Safari Compatibility"
-    
-    Currently, LangGraph Studio Web does not support Safari when running a server locally.
-
-## Test the API
-
-=== "Python SDK (Async)"
-
-    **Install the LangGraph Python SDK**
-
-    ```shell
-    pip install langgraph-sdk
-    ```
-
-    **Send a message to the assistant (threadless run)**
-
-    ```python
-    from langgraph_sdk import get_client
-
-    client = get_client(url="http://localhost:8123")
-
-    async for chunk in client.runs.stream(
-        None,  # Threadless run
-        "agent", # Name of assistant. Defined in langgraph.json.
-        input={
-            "messages": [{
-                "role": "human",
-                "content": "What is LangGraph?",
-            }],
-        },
-        stream_mode="updates",
-    ):
-        print(f"Receiving new event of type: {chunk.event}...")
-        print(chunk.data)
-        print("\n\n")
-    ```
-
-=== "Python SDK (Sync)"
-
-    **Install the LangGraph Python SDK**
-
-    ```shell
-    pip install langgraph-sdk
-    ```
-
-    **Send a message to the assistant (threadless run)**
-
-    ```python
-    from langgraph_sdk import get_sync_client
-
-    client = get_sync_client(url="http://localhost:8123")
-
-    for chunk in client.runs.stream(
-        None,  # Threadless run
-        "agent", # Name of assistant. Defined in langgraph.json.
-        input={
-            "messages": [{
-                "role": "human",
-                "content": "What is LangGraph?",
-            }],
-        },
-        stream_mode="updates",
-    ):
-        print(f"Receiving new event of type: {chunk.event}...")
-        print(chunk.data)
-        print("\n\n")
-    ```
-
-=== "Javascript SDK"
-
-    **Install the LangGraph JS SDK**
-
-    ```shell
-    npm install @langchain/langgraph-sdk
-    ```
-
-    **Send a message to the assistant (threadless run)**
-
-    ```js
-    const { Client } = await import("@langchain/langgraph-sdk");
-
-    // only set the apiUrl if you changed the default port when calling langgraph up
-    const client = new Client({ apiUrl: "http://localhost:8123"});
-
-    const streamResponse = client.runs.stream(
-        null, // Threadless run
-        "agent", // Assistant ID
-        {
-            input: {
-                "messages": [
-                    { "role": "user", "content": "What is LangGraph?"}
-                ]
-            },
-            streamMode: "messages",
-        }
-    );
-
-    for await (const chunk of streamResponse) {
-        console.log(`Receiving new event of type: ${chunk.event}...`);
-        console.log(JSON.stringify(chunk.data));
-        console.log("\n\n");
-    }
-    ```
-
-=== "Rest API"
-
-    ```bash
-    curl -s --request POST \
-        --url "http://localhost:8123/runs/stream" \
-        --header 'Content-Type: application/json' \
-        --data "{
-            \"assistant_id\": \"agent\",
-            \"input\": {
-                \"messages\": [
-                    {
-                        \"role\": \"human\",
-                        \"content\": \"What is LangGraph?\"
-                    }
-                ]
-            },
-            \"stream_mode\": \"updates\"
-        }" 
-    ```
-
-!!! tip "Auth"
-
-    If you're connecting to a remote server, you will need to provide a LangSmith
-    API Key for authorization. Please see the API Reference for the clients
-    for more information.
-
-## Next Steps
-
-Now that you have a LangGraph app running locally, take your journey further by exploring deployment and advanced features:
-
-### 🌐 Deploy to LangGraph Cloud
-
-- **[LangGraph Cloud QuickStart](../../cloud/quick_start.md)**: Deploy your LangGraph app using LangGraph Cloud.
-
-### 📚 Learn More about LangGraph Platform
-
-Expand your knowledge with these resources:
-
-- **[LangGraph Platform Concepts](../../concepts/index.md#langgraph-platform)**: Understand the foundational concepts of the LangGraph Platform.  
-- **[LangGraph Platform How-to Guides](../../how-tos/index.md#langgraph-platform)**: Discover step-by-step guides to build and deploy applications.
-
-### 🛠️ Developer References
-
-Access detailed documentation for development and API usage:
-
-- **[LangGraph Server API Reference](../../cloud/reference/api/api_ref.html)**: Explore the LangGraph Server API documentation.  
-- **[Python SDK Reference](../../cloud/reference/sdk/python_sdk_ref.md)**: Explore the Python SDK API Reference.
-- **[JS/TS SDK Reference](../../cloud/reference/sdk/js_ts_sdk_ref.md)**: Explore the Python SDK API Reference.

docs/docs/tutorials/rag/langgraph_adaptive_rag.ipynb

@@ -934,7 +934,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.4"
+   "version": "3.11.9"
   }
  },
  "nbformat": 4,

docs/docs/tutorials/tnt-llm/tnt-llm.ipynb

@@ -43,7 +43,7 @@
    "outputs": [],
    "source": [
     "%%capture --no-stderr\n",
-    "%pip install -U langgraph langchain_anthropic langsmith langchain-community\n",
+    "%pip install -U langgraph langchain_anthropic langsmith\n",
     "%pip install -U sklearn langchain_openai"
    ]
   },
@@ -632,7 +632,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain_community.cache import InMemoryCache\n",
+    "from langchain.cache import InMemoryCache\n",
     "from langchain.globals import set_llm_cache\n",
     "\n",
     "# Optional. If you are running into errors or rate limits and want to avoid repeated computation,\n",

docs/mkdocs.yml

@@ -94,7 +94,6 @@ nav:
       - Quick Start:
         - Quick Start: tutorials#quick-start
         - tutorials/introduction.ipynb
-        - tutorials/langgraph-platform/local-server.md
         - cloud/quick_start.md
       - Chatbots:
           - Chatbots: tutorials#chatbots
@@ -151,7 +150,6 @@ nav:
             - how-tos/branching.ipynb
             - how-tos/map-reduce.ipynb
             - how-tos/recursion-limit.ipynb
-            - how-tos/command.ipynb
         - Persistence:
             - Persistence: how-tos#persistence
             - how-tos/persistence.ipynb
@@ -165,7 +163,6 @@ nav:
             - how-tos/memory/manage-conversation-history.ipynb
             - how-tos/memory/delete-messages.ipynb
             - how-tos/memory/add-summary-conversation-history.ipynb
-            - how-tos/memory/semantic-search.ipynb
         - Human-in-the-loop:
             - Human-in-the-loop: how-tos#human-in-the-loop
             - how-tos/human_in_the_loop/breakpoints.ipynb
@@ -227,7 +224,6 @@ nav:
               - cloud/deployment/setup.md
               - cloud/deployment/setup_pyproject.md
               - cloud/deployment/setup_javascript.md
-              - cloud/deployment/semantic_search.md
               - cloud/deployment/custom_docker.md
               - cloud/deployment/test_locally.md
               - cloud/deployment/graph_rebuild.md
@@ -442,4 +438,4 @@ validation:
   # and those anchors are not available in the actual doc
   anchors: info
   # this is needed to handle headers with anchors for nav
-  not_found: info
+  not_found: info

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

@@ -42,7 +42,7 @@ class DuckDBSaver(BaseDuckDBSaver):
             DuckDBSaver: A new DuckDBSaver instance.
         """
         with duckdb.connect(conn_string) as conn:
-            yield cls(conn)
+            yield DuckDBSaver(conn)
 
     def setup(self) -> None:
         """Set up the checkpoint database asynchronously.

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

@@ -45,7 +45,7 @@ class AsyncDuckDBSaver(BaseDuckDBSaver):
             AsyncDuckDBSaver: A new AsyncDuckDBSaver instance.
         """
         with duckdb.connect(conn_string) as conn:
-            yield cls(conn)
+            yield AsyncDuckDBSaver(conn)
 
     async def setup(self) -> None:
         """Set up the checkpoint database asynchronously.

libs/checkpoint-duckdb/langgraph/store/duckdb/aio.py

@@ -156,7 +156,7 @@ class AsyncDuckDBStore(AsyncBatchedBaseStore, BaseDuckDBStore):
             AsyncDuckDBStore: A new AsyncDuckDBStore instance.
         """
         with duckdb.connect(conn_string) as conn:
-            yield cls(conn)
+            yield AsyncDuckDBStore(conn)
 
     async def setup(self) -> None:
         """Set up the store database asynchronously.

libs/checkpoint-duckdb/langgraph/store/duckdb/base.py

@@ -23,7 +23,6 @@ from langgraph.store.base import (
     Op,
     PutOp,
     Result,
-    SearchItem,
     SearchOp,
 )
 
@@ -284,7 +283,7 @@ class DuckDBStore(BaseStore, BaseDuckDBStore[duckdb.DuckDBPyConnection]):
 
         for cur, idx in cursors:
             rows = cur.fetchall()
-            items = [_row_to_search_item(_convert_ns(row[0]), row) for row in rows]
+            items = [_row_to_item(_convert_ns(row[0]), row) for row in rows]
             results[idx] = items
 
     def _batch_list_namespaces_ops(
@@ -377,22 +376,6 @@ def _row_to_item(
     )
 
 
-def _row_to_search_item(
-    namespace: tuple[str, ...],
-    row: tuple,
-) -> SearchItem:
-    """Convert a row from the database into an SearchItem."""
-    # TODO: Add support for search
-    _, key, val, created_at, updated_at = row
-    return SearchItem(
-        value=val if isinstance(val, dict) else json.loads(val),
-        key=key,
-        namespace=namespace,
-        created_at=created_at,
-        updated_at=updated_at,
-    )
-
-
 def _group_ops(ops: Iterable[Op]) -> tuple[dict[type, list[tuple[int, Op]]], int]:
     grouped_ops: dict[type, list[tuple[int, Op]]] = defaultdict(list)
     tot = 0

libs/checkpoint-postgres/Makefile

@@ -5,11 +5,7 @@
 ######################
 
 start-postgres:
-	POSTGRES_VERSION=${POSTGRES_VERSION:-16} docker compose -f tests/compose-postgres.yml up -V --force-recreate --wait || ( \
-		echo "Failed to start PostgreSQL, printing logs..."; \
-		docker compose -f tests/compose-postgres.yml logs; \
-		exit 1 \
-	)
+	POSTGRES_VERSION=${POSTGRES_VERSION:-16} docker compose -f tests/compose-postgres.yml up -V --force-recreate --wait
 
 stop-postgres:
 	docker compose -f tests/compose-postgres.yml down

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

@@ -1,10 +1,10 @@
 import threading
-from collections.abc import Iterator, Sequence
 from contextlib import contextmanager
-from typing import Any, Optional
+from typing import Any, Iterator, Optional, Sequence, Union
 
 from langchain_core.runnables import RunnableConfig
 from psycopg import Capabilities, Connection, Cursor, Pipeline
+from psycopg.errors import UndefinedTable
 from psycopg.rows import DictRow, dict_row
 from psycopg.types.json import Jsonb
 from psycopg_pool import ConnectionPool
@@ -17,11 +17,21 @@ from langgraph.checkpoint.base import (
     CheckpointTuple,
     get_checkpoint_id,
 )
-from langgraph.checkpoint.postgres import _internal
 from langgraph.checkpoint.postgres.base import BasePostgresSaver
 from langgraph.checkpoint.serde.base import SerializerProtocol
 
-Conn = _internal.Conn  # For backward compatibility
+Conn = Union[Connection[DictRow], ConnectionPool[Connection[DictRow]]]
+
+
+@contextmanager
+def _get_connection(conn: Conn) -> Iterator[Connection[DictRow]]:
+    if isinstance(conn, Connection):
+        yield conn
+    elif isinstance(conn, ConnectionPool):
+        with conn.connection() as conn:
+            yield conn
+    else:
+        raise TypeError(f"Invalid connection type: {type(conn)}")
 
 
 class PostgresSaver(BasePostgresSaver):
@@ -29,7 +39,7 @@ class PostgresSaver(BasePostgresSaver):
 
     def __init__(
         self,
-        conn: _internal.Conn,
+        conn: Conn,
         pipe: Optional[Pipeline] = None,
         serde: Optional[SerializerProtocol] = None,
     ) -> None:
@@ -63,9 +73,9 @@ class PostgresSaver(BasePostgresSaver):
         ) as conn:
             if pipeline:
                 with conn.pipeline() as pipe:
-                    yield cls(conn, pipe)
+                    yield PostgresSaver(conn, pipe)
             else:
-                yield cls(conn)
+                yield PostgresSaver(conn)
 
     def setup(self) -> None:
         """Set up the checkpoint database asynchronously.
@@ -75,15 +85,16 @@ class PostgresSaver(BasePostgresSaver):
         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:
+            try:
+                row = cur.execute(
+                    "SELECT v FROM checkpoint_migrations ORDER BY v DESC LIMIT 1"
+                ).fetchone()
+                if row is None:
+                    version = -1
+                else:
+                    version = row["v"]
+            except UndefinedTable:
                 version = -1
-            else:
-                version = row["v"]
             for v, migration in zip(
                 range(version + 1, len(self.MIGRATIONS)),
                 self.MIGRATIONS[version + 1 :],
@@ -362,7 +373,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 _internal.get_connection(self.conn) as conn:
+        with _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
@@ -377,23 +388,19 @@ class PostgresSaver(BasePostgresSaver):
                 # 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,
-                    ):
+                    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,
-                    ):
+                    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
 
 
-__all__ = ["PostgresSaver", "BasePostgresSaver", "Conn"]
+__all__ = ["PostgresSaver", "Conn"]

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

@@ -1,24 +0,0 @@
-"""Shared async utility functions for the Postgres checkpoint & storage classes."""
-
-from collections.abc import AsyncIterator
-from contextlib import asynccontextmanager
-from typing import Union
-
-from psycopg import AsyncConnection
-from psycopg.rows import DictRow
-from psycopg_pool import AsyncConnectionPool
-
-Conn = Union[AsyncConnection[DictRow], AsyncConnectionPool[AsyncConnection[DictRow]]]
-
-
-@asynccontextmanager
-async def get_connection(
-    conn: Conn,
-) -> AsyncIterator[AsyncConnection[DictRow]]:
-    if isinstance(conn, AsyncConnection):
-        yield conn
-    elif isinstance(conn, AsyncConnectionPool):
-        async with conn.connection() as conn:
-            yield conn
-    else:
-        raise TypeError(f"Invalid connection type: {type(conn)}")

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

@@ -1,22 +0,0 @@
-"""Shared utility functions for the Postgres checkpoint & storage classes."""
-
-from collections.abc import Iterator
-from contextlib import contextmanager
-from typing import Union
-
-from psycopg import Connection
-from psycopg.rows import DictRow
-from psycopg_pool import ConnectionPool
-
-Conn = Union[Connection[DictRow], ConnectionPool[Connection[DictRow]]]
-
-
-@contextmanager
-def get_connection(conn: Conn) -> Iterator[Connection[DictRow]]:
-    if isinstance(conn, Connection):
-        yield conn
-    elif isinstance(conn, ConnectionPool):
-        with conn.connection() as conn:
-            yield conn
-    else:
-        raise TypeError(f"Invalid connection type: {type(conn)}")

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

@@ -1,10 +1,10 @@
 import asyncio
-from collections.abc import AsyncIterator, Iterator, Sequence
 from contextlib import asynccontextmanager
-from typing import Any, Optional
+from typing import Any, AsyncIterator, Iterator, Optional, Sequence, Union
 
 from langchain_core.runnables import RunnableConfig
 from psycopg import AsyncConnection, AsyncCursor, AsyncPipeline, Capabilities
+from psycopg.errors import UndefinedTable
 from psycopg.rows import DictRow, dict_row
 from psycopg.types.json import Jsonb
 from psycopg_pool import AsyncConnectionPool
@@ -17,11 +17,23 @@ from langgraph.checkpoint.base import (
     CheckpointTuple,
     get_checkpoint_id,
 )
-from langgraph.checkpoint.postgres import _ainternal
 from langgraph.checkpoint.postgres.base import BasePostgresSaver
 from langgraph.checkpoint.serde.base import SerializerProtocol
 
-Conn = _ainternal.Conn  # For backward compatibility
+Conn = Union[AsyncConnection[DictRow], AsyncConnectionPool[AsyncConnection[DictRow]]]
+
+
+@asynccontextmanager
+async def _get_connection(
+    conn: Conn,
+) -> AsyncIterator[AsyncConnection[DictRow]]:
+    if isinstance(conn, AsyncConnection):
+        yield conn
+    elif isinstance(conn, AsyncConnectionPool):
+        async with conn.connection() as conn:
+            yield conn
+    else:
+        raise TypeError(f"Invalid connection type: {type(conn)}")
 
 
 class AsyncPostgresSaver(BasePostgresSaver):
@@ -29,7 +41,7 @@ class AsyncPostgresSaver(BasePostgresSaver):
 
     def __init__(
         self,
-        conn: _ainternal.Conn,
+        conn: Conn,
         pipe: Optional[AsyncPipeline] = None,
         serde: Optional[SerializerProtocol] = None,
     ) -> None:
@@ -54,7 +66,7 @@ class AsyncPostgresSaver(BasePostgresSaver):
         pipeline: bool = False,
         serde: Optional[SerializerProtocol] = None,
     ) -> AsyncIterator["AsyncPostgresSaver"]:
-        """Create a new AsyncPostgresSaver instance from a connection string.
+        """Create a new PostgresSaver instance from a connection string.
 
         Args:
             conn_string (str): The Postgres connection info string.
@@ -68,9 +80,9 @@ class AsyncPostgresSaver(BasePostgresSaver):
         ) as conn:
             if pipeline:
                 async with conn.pipeline() as pipe:
-                    yield cls(conn=conn, pipe=pipe, serde=serde)
+                    yield AsyncPostgresSaver(conn=conn, pipe=pipe, serde=serde)
             else:
-                yield cls(conn=conn, serde=serde)
+                yield AsyncPostgresSaver(conn=conn, serde=serde)
 
     async def setup(self) -> None:
         """Set up the checkpoint database asynchronously.
@@ -80,15 +92,17 @@ class AsyncPostgresSaver(BasePostgresSaver):
         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:
+            try:
+                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"]
+            except UndefinedTable:
                 version = -1
-            else:
-                version = row["v"]
             for v, migration in zip(
                 range(version + 1, len(self.MIGRATIONS)),
                 self.MIGRATIONS[version + 1 :],
@@ -143,17 +157,15 @@ class AsyncPostgresSaver(BasePostgresSaver):
                         value["pending_sends"],
                     ),
                     self._load_metadata(value["metadata"]),
-                    (
-                        {
-                            "configurable": {
-                                "thread_id": value["thread_id"],
-                                "checkpoint_ns": value["checkpoint_ns"],
-                                "checkpoint_id": value["parent_checkpoint_id"],
-                            }
+                    {
+                        "configurable": {
+                            "thread_id": value["thread_id"],
+                            "checkpoint_ns": value["checkpoint_ns"],
+                            "checkpoint_id": value["parent_checkpoint_id"],
                         }
-                        if value["parent_checkpoint_id"]
-                        else None
-                    ),
+                    }
+                    if value["parent_checkpoint_id"]
+                    else None,
                     await asyncio.to_thread(self._load_writes, value["pending_writes"]),
                 )
 
@@ -204,17 +216,15 @@ class AsyncPostgresSaver(BasePostgresSaver):
                         value["pending_sends"],
                     ),
                     self._load_metadata(value["metadata"]),
-                    (
-                        {
-                            "configurable": {
-                                "thread_id": thread_id,
-                                "checkpoint_ns": checkpoint_ns,
-                                "checkpoint_id": value["parent_checkpoint_id"],
-                            }
+                    {
+                        "configurable": {
+                            "thread_id": thread_id,
+                            "checkpoint_ns": checkpoint_ns,
+                            "checkpoint_id": value["parent_checkpoint_id"],
                         }
-                        if value["parent_checkpoint_id"]
-                        else None
-                    ),
+                    }
+                    if value["parent_checkpoint_id"]
+                    else None,
                     await asyncio.to_thread(self._load_writes, value["pending_writes"]),
                 )
 
@@ -321,7 +331,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 _ainternal.get_connection(self.conn) as conn:
+        async with _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
@@ -336,25 +346,20 @@ class AsyncPostgresSaver(BasePostgresSaver):
                 # 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,
-                    ):
+                    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,
-                    ):
+                    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,
-                ):
+                async with self.lock, conn.cursor(
+                    binary=True, row_factory=dict_row
+                ) as cur:
                     yield cur
 
     def list(
@@ -383,7 +388,7 @@ class AsyncPostgresSaver(BasePostgresSaver):
         while True:
             try:
                 yield asyncio.run_coroutine_threadsafe(
-                    anext(aiter_),  # noqa: F821
+                    anext(aiter_),
                     self.loop,
                 ).result()
             except StopAsyncIteration:
@@ -462,6 +467,3 @@ class AsyncPostgresSaver(BasePostgresSaver):
         return asyncio.run_coroutine_threadsafe(
             self.aput_writes(config, writes, task_id), self.loop
         ).result()
-
-
-__all__ = ["AsyncPostgresSaver", "Conn"]

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

@@ -1,6 +1,5 @@
 import random
-from collections.abc import Sequence
-from typing import Any, Optional, cast
+from typing import Any, List, Optional, Sequence, Tuple, cast
 
 from langchain_core.runnables import RunnableConfig
 from psycopg.types.json import Jsonb
@@ -250,7 +249,7 @@ class BasePostgresSaver(BaseCheckpointSaver[str]):
         config: Optional[RunnableConfig],
         filter: MetadataInput,
         before: Optional[RunnableConfig] = None,
-    ) -> tuple[str, list[Any]]:
+    ) -> Tuple[str, List[Any]]:
         """Return WHERE clause predicates for alist() given config, filter, before.
 
         This method returns a tuple of a string and a tuple of values. The string

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

@@ -1,310 +1,110 @@
 import asyncio
 import logging
-from collections.abc import AsyncIterator, Iterable, Sequence
 from contextlib import asynccontextmanager
-from typing import Any, Callable, Optional, Union, cast
+from typing import (
+    Any,
+    AsyncIterator,
+    Callable,
+    Iterable,
+    Optional,
+    Sequence,
+    Union,
+    cast,
+)
 
 import orjson
-from psycopg import AsyncConnection, AsyncCursor, AsyncPipeline, Capabilities
+from psycopg import AsyncConnection, AsyncCursor
 from psycopg.errors import UndefinedTable
-from psycopg.rows import DictRow, dict_row
-from psycopg_pool import AsyncConnectionPool
+from psycopg.rows import dict_row
 
-from langgraph.checkpoint.postgres import _ainternal
-from langgraph.store.base import (
-    GetOp,
-    ListNamespacesOp,
-    Op,
-    PutOp,
-    Result,
-    SearchOp,
-)
+from langgraph.store.base import GetOp, ListNamespacesOp, Op, PutOp, Result, SearchOp
 from langgraph.store.base.batch import AsyncBatchedBaseStore
 from langgraph.store.postgres.base import (
-    _PLACEHOLDER,
     BasePostgresStore,
-    PoolConfig,
-    PostgresIndexConfig,
     Row,
     _decode_ns_bytes,
-    _ensure_index_config,
     _group_ops,
     _row_to_item,
-    _row_to_search_item,
 )
 
 logger = logging.getLogger(__name__)
 
 
-class AsyncPostgresStore(AsyncBatchedBaseStore, BasePostgresStore[_ainternal.Conn]):
-    """Asynchronous Postgres-backed store with optional vector search using pgvector.
-
-    !!! example "Examples"
-        Basic setup and key-value storage:
-        ```python
-        from langgraph.store.postgres import AsyncPostgresStore
-
-        async with AsyncPostgresStore.from_conn_string(
-            "postgresql://user:pass@localhost:5432/dbname"
-        ) as store:
-            await store.setup()
-
-            # Store and retrieve data
-            await store.aput(("users", "123"), "prefs", {"theme": "dark"})
-            item = await store.aget(("users", "123"), "prefs")
-        ```
-
-        Vector search using LangChain embeddings:
-        ```python
-        from langchain.embeddings import init_embeddings
-        from langgraph.store.postgres import AsyncPostgresStore
-
-        async with AsyncPostgresStore.from_conn_string(
-            "postgresql://user:pass@localhost:5432/dbname",
-            index={
-                "dims": 1536,
-                "embed": init_embeddings("openai:text-embedding-3-small"),
-                "fields": ["text"]  # specify which fields to embed. Default is the whole serialized value
-            }
-        ) as store:
-            await store.setup()  # Do this once to run migrations
-
-            # Store documents
-            await store.aput(("docs",), "doc1", {"text": "Python tutorial"})
-            await store.aput(("docs",), "doc2", {"text": "TypeScript guide"})
-            # Don't index the following
-            await store.aput(("docs",), "doc3", {"text": "Other guide"}, index=False)
-
-            # Search by similarity
-            results = await store.asearch(("docs",), query="python programming")
-        ```
-
-        Using connection pooling for better performance:
-        ```python
-        from langgraph.store.postgres import AsyncPostgresStore, PoolConfig
-
-        async with AsyncPostgresStore.from_conn_string(
-            "postgresql://user:pass@localhost:5432/dbname",
-            pool_config=PoolConfig(
-                min_size=5,
-                max_size=20
-            )
-        ) as store:
-            await store.setup()
-            # Use store with connection pooling...
-        ```
-
-    Warning:
-        Make sure to:
-        1. Call `setup()` before first use to create necessary tables and indexes
-        2. Have the pgvector extension available to use vector search
-        3. Use Python 3.10+ for async functionality
-
-    Note:
-        Semantic search is disabled by default. You can enable it by providing an `index` configuration
-        when creating the store. Without this configuration, all `index` arguments passed to
-        `put` or `aput`will have no effect.
-    """
-
-    __slots__ = (
-        "_deserializer",
-        "pipe",
-        "lock",
-        "supports_pipeline",
-        "index_config",
-        "embeddings",
-    )
+class AsyncPostgresStore(AsyncBatchedBaseStore, BasePostgresStore[AsyncConnection]):
+    __slots__ = ("_deserializer",)
 
     def __init__(
         self,
-        conn: _ainternal.Conn,
+        conn: AsyncConnection[Any],
         *,
-        pipe: Optional[AsyncPipeline] = None,
         deserializer: Optional[
             Callable[[Union[bytes, orjson.Fragment]], dict[str, Any]]
         ] = None,
-        index: Optional[PostgresIndexConfig] = None,
     ) -> None:
-        if isinstance(conn, AsyncConnectionPool) and pipe is not None:
-            raise ValueError(
-                "Pipeline should be used only with a single AsyncConnection, not AsyncConnectionPool."
-            )
         super().__init__()
         self._deserializer = deserializer
         self.conn = conn
-        self.pipe = pipe
-        self.lock = asyncio.Lock()
         self.loop = asyncio.get_running_loop()
-        self.supports_pipeline = Capabilities().has_pipeline()
-        self.index_config = index
-        if self.index_config:
-            self.embeddings, self.index_config = _ensure_index_config(self.index_config)
-
-        else:
-            self.embeddings = None
 
     async def abatch(self, ops: Iterable[Op]) -> list[Result]:
         grouped_ops, num_ops = _group_ops(ops)
         results: list[Result] = [None] * num_ops
 
-        async with _ainternal.get_connection(self.conn) as conn:
-            if self.pipe:
-                async with self.pipe:
-                    await self._execute_batch(grouped_ops, results, conn)
-            else:
-                await self._execute_batch(grouped_ops, results, conn)
+        async with self.conn.pipeline():
+            tasks = []
+
+            if GetOp in grouped_ops:
+                tasks.append(
+                    self._batch_get_ops(
+                        cast(Sequence[tuple[int, GetOp]], grouped_ops[GetOp]), results
+                    )
+                )
+
+            if PutOp in grouped_ops:
+                tasks.append(
+                    self._batch_put_ops(
+                        cast(Sequence[tuple[int, PutOp]], grouped_ops[PutOp])
+                    )
+                )
+
+            if SearchOp in grouped_ops:
+                tasks.append(
+                    self._batch_search_ops(
+                        cast(Sequence[tuple[int, SearchOp]], grouped_ops[SearchOp]),
+                        results,
+                    )
+                )
+
+            if ListNamespacesOp in grouped_ops:
+                tasks.append(
+                    self._batch_list_namespaces_ops(
+                        cast(
+                            Sequence[tuple[int, ListNamespacesOp]],
+                            grouped_ops[ListNamespacesOp],
+                        ),
+                        results,
+                    )
+                )
+
+            await asyncio.gather(*tasks)
 
         return results
 
     def batch(self, ops: Iterable[Op]) -> list[Result]:
         return asyncio.run_coroutine_threadsafe(self.abatch(ops), self.loop).result()
 
-    @classmethod
-    @asynccontextmanager
-    async def from_conn_string(
-        cls,
-        conn_string: str,
-        *,
-        pipeline: bool = False,
-        pool_config: Optional[PoolConfig] = None,
-        index: Optional[PostgresIndexConfig] = None,
-    ) -> AsyncIterator["AsyncPostgresStore"]:
-        """Create a new AsyncPostgresStore instance from a connection string.
-
-        Args:
-            conn_string (str): The Postgres connection info string.
-            pipeline (bool): Whether to use AsyncPipeline (only for single connections)
-            pool_config (Optional[PoolConfig]): Configuration for the connection pool.
-                If provided, will create a connection pool and use it instead of a single connection.
-                This overrides the `pipeline` argument.
-            index (Optional[PostgresIndexConfig]): The embedding config.
-
-        Returns:
-            AsyncPostgresStore: A new AsyncPostgresStore instance.
-        """
-        if pool_config is not None:
-            pc = pool_config.copy()
-            async with cast(
-                AsyncConnectionPool[AsyncConnection[DictRow]],
-                AsyncConnectionPool(
-                    conn_string,
-                    min_size=pc.pop("min_size", 1),
-                    max_size=pc.pop("max_size", None),
-                    kwargs={
-                        "autocommit": True,
-                        "prepare_threshold": 0,
-                        "row_factory": dict_row,
-                        **(pc.pop("kwargs", None) or {}),
-                    },
-                    **cast(dict, pc),
-                ),
-            ) as pool:
-                yield cls(conn=pool, index=index)
-        else:
-            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, index=index)
-                else:
-                    yield cls(conn=conn, index=index)
-
-    async def setup(self) -> None:
-        """Set up the store 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 the store is used.
-        """
-
-        async def _get_version(cur: AsyncCursor[DictRow], table: str) -> int:
-            try:
-                await cur.execute(f"SELECT v FROM {table} ORDER BY v DESC LIMIT 1")
-                row = await cur.fetchone()
-                if row is None:
-                    version = -1
-                else:
-                    version = row["v"]
-            except UndefinedTable:
-                version = -1
-                await cur.execute(
-                    f"""
-                    CREATE TABLE IF NOT EXISTS {table} (
-                        v INTEGER PRIMARY KEY
-                    )
-                """
-                )
-            return version
-
-        async with self._cursor() as cur:
-            version = await _get_version(cur, table="store_migrations")
-            for v, sql in enumerate(self.MIGRATIONS[version + 1 :], start=version + 1):
-                await cur.execute(sql)
-                await cur.execute("INSERT INTO store_migrations (v) VALUES (%s)", (v,))
-
-            if self.index_config:
-                version = await _get_version(cur, table="vector_migrations")
-                for v, migration in enumerate(
-                    self.VECTOR_MIGRATIONS[version + 1 :], start=version + 1
-                ):
-                    sql = migration.sql
-                    if migration.params:
-                        params = {
-                            k: v(self) if v is not None and callable(v) else v
-                            for k, v in migration.params.items()
-                        }
-                        sql = sql % params
-                    await cur.execute(sql)
-                    await cur.execute(
-                        "INSERT INTO vector_migrations (v) VALUES (%s)", (v,)
-                    )
-
-    async def _execute_batch(
-        self,
-        grouped_ops: dict,
-        results: list[Result],
-        conn: AsyncConnection[DictRow],
-    ) -> None:
-        async with self._cursor(pipeline=True) as cur:
-            if GetOp in grouped_ops:
-                await self._batch_get_ops(
-                    cast(Sequence[tuple[int, GetOp]], grouped_ops[GetOp]),
-                    results,
-                    cur,
-                )
-
-            if SearchOp in grouped_ops:
-                await self._batch_search_ops(
-                    cast(Sequence[tuple[int, SearchOp]], grouped_ops[SearchOp]),
-                    results,
-                    cur,
-                )
-
-            if ListNamespacesOp in grouped_ops:
-                await self._batch_list_namespaces_ops(
-                    cast(
-                        Sequence[tuple[int, ListNamespacesOp]],
-                        grouped_ops[ListNamespacesOp],
-                    ),
-                    results,
-                    cur,
-                )
-
-            if PutOp in grouped_ops:
-                await self._batch_put_ops(
-                    cast(Sequence[tuple[int, PutOp]], grouped_ops[PutOp]),
-                    cur,
-                )
-
     async def _batch_get_ops(
         self,
         get_ops: Sequence[tuple[int, GetOp]],
         results: list[Result],
-        cur: AsyncCursor[DictRow],
     ) -> None:
+        cursors = []
         for query, params, namespace, items in self._get_batch_GET_ops_queries(get_ops):
+            cur = self.conn.cursor(binary=True)
             await cur.execute(query, params)
+            cursors.append((cur, namespace, items))
+
+        for cur, namespace, items in cursors:
             rows = cast(list[Row], await cur.fetchall())
             key_to_row = {row["key"]: row for row in rows}
             for idx, key in items:
@@ -319,59 +119,29 @@ class AsyncPostgresStore(AsyncBatchedBaseStore, BasePostgresStore[_ainternal.Con
     async def _batch_put_ops(
         self,
         put_ops: Sequence[tuple[int, PutOp]],
-        cur: AsyncCursor[DictRow],
     ) -> None:
-        queries, embedding_request = self._prepare_batch_PUT_queries(put_ops)
-        if embedding_request:
-            if self.embeddings is None:
-                # Should not get here since the embedding config is required
-                # to return an embedding_request above
-                raise ValueError(
-                    "Embedding configuration is required for vector operations "
-                    f"(for semantic search). "
-                    f"Please provide an EmbeddingConfig when initializing the {self.__class__.__name__}."
-                )
-            query, txt_params = embedding_request
-            vectors = await self.embeddings.aembed_documents(
-                [param[-1] for param in txt_params]
-            )
-            queries.append(
-                (
-                    query,
-                    [
-                        p
-                        for (ns, k, pathname, _), vector in zip(txt_params, vectors)
-                        for p in (ns, k, pathname, vector)
-                    ],
-                )
-            )
-
+        queries = self._get_batch_PUT_queries(put_ops)
         for query, params in queries:
+            cur = self.conn.cursor(binary=True)
             await cur.execute(query, params)
 
     async def _batch_search_ops(
         self,
         search_ops: Sequence[tuple[int, SearchOp]],
         results: list[Result],
-        cur: AsyncCursor[DictRow],
     ) -> None:
-        queries, embedding_requests = self._prepare_batch_search_queries(search_ops)
+        queries = self._get_batch_search_queries(search_ops)
+        cursors: list[tuple[AsyncCursor[Any], int]] = []
 
-        if embedding_requests and self.embeddings:
-            vectors = await self.embeddings.aembed_documents(
-                [query for _, query in embedding_requests]
-            )
-            for (idx, _), vector in zip(embedding_requests, vectors):
-                _paramslist = queries[idx][1]
-                for i in range(len(_paramslist)):
-                    if _paramslist[i] is _PLACEHOLDER:
-                        _paramslist[i] = vector
-
-        for (idx, _), (query, params) in zip(search_ops, queries):
+        for (query, params), (idx, _) in zip(queries, search_ops):
+            cur = self.conn.cursor(binary=True)
             await cur.execute(query, params)
+            cursors.append((cur, idx))
+
+        for cur, idx in cursors:
             rows = cast(list[Row], await cur.fetchall())
             items = [
-                _row_to_search_item(
+                _row_to_item(
                     _decode_ns_bytes(row["prefix"]), row, loader=self._deserializer
                 )
                 for row in rows
@@ -382,57 +152,67 @@ class AsyncPostgresStore(AsyncBatchedBaseStore, BasePostgresStore[_ainternal.Con
         self,
         list_ops: Sequence[tuple[int, ListNamespacesOp]],
         results: list[Result],
-        cur: AsyncCursor[DictRow],
     ) -> None:
         queries = self._get_batch_list_namespaces_queries(list_ops)
+        cursors: list[tuple[AsyncCursor[Any], int]] = []
         for (query, params), (idx, _) in zip(queries, list_ops):
+            cur = self.conn.cursor(binary=True)
             await cur.execute(query, params)
+            cursors.append((cur, idx))
+
+        for cur, idx in cursors:
             rows = cast(list[dict], await cur.fetchall())
             namespaces = [_decode_ns_bytes(row["truncated_prefix"]) for row in rows]
             results[idx] = namespaces
 
+    @classmethod
     @asynccontextmanager
-    async def _cursor(
-        self, *, pipeline: bool = False
-    ) -> AsyncIterator[AsyncCursor[DictRow]]:
-        """Create a database cursor as a context manager.
+    async def from_conn_string(
+        cls,
+        conn_string: str,
+    ) -> AsyncIterator["AsyncPostgresStore"]:
+        """Create a new AsyncPostgresStore instance from a connection string.
 
         Args:
-            pipeline: whether to use pipeline for the DB operations inside the context manager.
-                Will be applied regardless of whether the PostgresStore instance was initialized with a pipeline.
-                If pipeline mode is not supported, will fall back to using transaction context manager.
+            conn_string (str): The Postgres connection info string.
+
+        Returns:
+            AsyncPostgresStore: A new AsyncPostgresStore instance.
         """
-        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
+        async with await AsyncConnection.connect(
+            conn_string, autocommit=True, prepare_threshold=0, row_factory=dict_row
+        ) as conn:
+            yield cls(conn=conn)
+
+    async def setup(self) -> None:
+        """Set up the store 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 the store is used.
+        """
+        async with self.conn.cursor() as cur:
+            try:
+                await cur.execute(
+                    "SELECT v FROM store_migrations ORDER BY v DESC LIMIT 1"
+                )
+                row = cast(dict, await cur.fetchone())
+                if row is None:
+                    version = -1
                 else:
-                    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) as cur,
-                ):
-                    yield cur
+                    version = row["v"]
+            except UndefinedTable:
+                version = -1
+                # Create store_migrations table if it doesn't exist
+                await cur.execute(
+                    """
+                    CREATE TABLE IF NOT EXISTS store_migrations (
+                        v INTEGER PRIMARY KEY
+                    )
+                    """
+                )
+            for v, migration in enumerate(
+                self.MIGRATIONS[version + 1 :], start=version + 1
+            ):
+                await cur.execute(migration)
+                await cur.execute("INSERT INTO store_migrations (v) VALUES (%s)", (v,))

libs/checkpoint-postgres/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langgraph-checkpoint-postgres"
-version = "2.0.7"
+version = "2.0.3"
 description = "Library with a Postgres implementation of LangGraph checkpoint saver."
 authors = []
 license = "MIT"
@@ -10,10 +10,10 @@ packages = [{ include = "langgraph" }]
 
 [tool.poetry.dependencies]
 python = "^3.9.0,<4.0"
-langgraph-checkpoint = "^2.0.7"
+langgraph-checkpoint = "^2.0.2"
 orjson = ">=3.10.1"
-psycopg = "^3.2.0"
-psycopg-pool = "^3.2.0"
+psycopg = "^3.0.0"
+psycopg-pool = "^3.0.0"
 
 [tool.poetry.group.dev.dependencies]
 ruff = "^0.6.2"

libs/checkpoint-postgres/tests/compose-postgres.yml

@@ -1,13 +1,12 @@
 services:
   postgres-test:
-    image: pgvector/pgvector:pg${POSTGRES_VERSION:-16}
+    image: postgres:${POSTGRES_VERSION:-16}
     ports:
       - "5441:5432"
     environment:
       POSTGRES_DB: postgres
       POSTGRES_USER: postgres
       POSTGRES_PASSWORD: postgres
-    command: ["postgres", "-c", "shared_preload_libraries=vector"]
     healthcheck:
       test: pg_isready -U postgres
       start_period: 10s

libs/checkpoint-postgres/tests/conftest.py

@@ -1,13 +1,10 @@
-from collections.abc import AsyncIterator
+from typing import AsyncIterator
 
 import pytest
 from psycopg import AsyncConnection
 from psycopg.errors import UndefinedTable
 from psycopg.rows import DictRow, dict_row
 
-from tests.embed_test_utils import CharacterEmbeddings
-
-DEFAULT_POSTGRES_URI = "postgres://postgres:postgres@localhost:5441/"
 DEFAULT_URI = "postgres://postgres:postgres@localhost:5441/postgres?sslmode=disable"
 
 
@@ -27,18 +24,6 @@ async def clear_test_db(conn: AsyncConnection[DictRow]) -> None:
         await conn.execute("DELETE FROM checkpoint_blobs")
         await conn.execute("DELETE FROM checkpoint_writes")
         await conn.execute("DELETE FROM checkpoint_migrations")
-    except UndefinedTable:
-        pass
-    try:
         await conn.execute("DELETE FROM store_migrations")
-        await conn.execute("DELETE FROM store")
     except UndefinedTable:
         pass
-
-
-@pytest.fixture
-def fake_embeddings() -> CharacterEmbeddings:
-    return CharacterEmbeddings(dims=500)
-
-
-VECTOR_TYPES = ["vector", "halfvec"]

libs/checkpoint-postgres/tests/embed_test_utils.py

@@ -1,55 +0,0 @@
-"""Embedding utilities for testing."""
-
-import math
-import random
-from collections import Counter, defaultdict
-from typing import Any
-
-from langchain_core.embeddings import Embeddings
-
-
-class CharacterEmbeddings(Embeddings):
-    """Simple character-frequency based embeddings using random projections."""
-
-    def __init__(self, dims: int = 50, seed: int = 42):
-        """Initialize with embedding dimensions and random seed."""
-        self._rng = random.Random(seed)
-        self.dims = dims
-        # Create projection vector for each character lazily
-        self._char_projections: defaultdict[str, list[float]] = defaultdict(
-            lambda: [
-                self._rng.gauss(0, 1 / math.sqrt(self.dims)) for _ in range(self.dims)
-            ]
-        )
-
-    def _embed_one(self, text: str) -> list[float]:
-        """Embed a single text."""
-        counts = Counter(text)
-        total = sum(counts.values())
-
-        if total == 0:
-            return [0.0] * self.dims
-
-        embedding = [0.0] * self.dims
-        for char, count in counts.items():
-            weight = count / total
-            char_proj = self._char_projections[char]
-            for i, proj in enumerate(char_proj):
-                embedding[i] += weight * proj
-
-        norm = math.sqrt(sum(x * x for x in embedding))
-        if norm > 0:
-            embedding = [x / norm for x in embedding]
-
-        return embedding
-
-    def embed_documents(self, texts: list[str]) -> list[list[float]]:
-        """Embed a list of documents."""
-        return [self._embed_one(text) for text in texts]
-
-    def embed_query(self, text: str) -> list[float]:
-        """Embed a query string."""
-        return self._embed_one(text)
-
-    def __eq__(self, other: Any) -> bool:
-        return isinstance(other, CharacterEmbeddings) and self.dims == other.dims

libs/checkpoint-postgres/tests/test_async.py

@@ -1,14 +1,8 @@
-# type: ignore
-
-from contextlib import asynccontextmanager
 from typing import Any
-from uuid import uuid4
 
 import pytest
+from conftest import DEFAULT_URI  # type: ignore
 from langchain_core.runnables import RunnableConfig
-from psycopg import AsyncConnection
-from psycopg.rows import dict_row
-from psycopg_pool import AsyncConnectionPool
 
 from langgraph.checkpoint.base import (
     Checkpoint,
@@ -17,212 +11,103 @@ from langgraph.checkpoint.base import (
     empty_checkpoint,
 )
 from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver
-from tests.conftest import DEFAULT_POSTGRES_URI
 
 
-@asynccontextmanager
-async def _pool_saver():
-    """Fixture for pool 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:
-        # yield checkpointer
-        async with AsyncConnectionPool(
-            DEFAULT_POSTGRES_URI + database,
-            max_size=10,
-            kwargs={"autocommit": True, "row_factory": dict_row},
-        ) as pool:
-            checkpointer = AsyncPostgresSaver(pool)
-            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 _pipe_saver():
-    """Fixture for pipeline 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:
-            async with conn.pipeline() as pipe:
-                checkpointer = AsyncPostgresSaver(conn, pipe=pipe)
-                await checkpointer.setup()
-            async with conn.pipeline() as pipe:
-                checkpointer = AsyncPostgresSaver(conn, pipe=pipe)
-                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 _base_saver():
-    """Fixture for regular 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 = AsyncPostgresSaver(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 == "pool":
-        async with _pool_saver() as saver:
-            yield saver
-    elif name == "pipe":
-        async with _pipe_saver() as saver:
-            yield saver
-
-
-@pytest.fixture
-def test_data():
-    """Fixture providing test data for checkpoint tests."""
-    config_1: RunnableConfig = {
-        "configurable": {
-            "thread_id": "thread-1",
-            # for backwards compatibility testing
-            "thread_ts": "1",
-            "checkpoint_ns": "",
+class TestAsyncPostgresSaver:
+    @pytest.fixture(autouse=True)
+    async def setup(self) -> None:
+        # objects for test setup
+        self.config_1: RunnableConfig = {
+            "configurable": {
+                "thread_id": "thread-1",
+                # for backwards compatibility testing
+                "thread_ts": "1",
+                "checkpoint_ns": "",
+            }
         }
-    }
-    config_2: RunnableConfig = {
-        "configurable": {
-            "thread_id": "thread-2",
-            "checkpoint_id": "2",
-            "checkpoint_ns": "",
+        self.config_2: RunnableConfig = {
+            "configurable": {
+                "thread_id": "thread-2",
+                "checkpoint_id": "2",
+                "checkpoint_ns": "",
+            }
         }
-    }
-    config_3: RunnableConfig = {
-        "configurable": {
-            "thread_id": "thread-2",
-            "checkpoint_id": "2-inner",
-            "checkpoint_ns": "inner",
+        self.config_3: RunnableConfig = {
+            "configurable": {
+                "thread_id": "thread-2",
+                "checkpoint_id": "2-inner",
+                "checkpoint_ns": "inner",
+            }
         }
-    }
 
-    chkpnt_1: Checkpoint = empty_checkpoint()
-    chkpnt_2: Checkpoint = create_checkpoint(chkpnt_1, {}, 1)
-    chkpnt_3: Checkpoint = empty_checkpoint()
+        self.chkpnt_1: Checkpoint = empty_checkpoint()
+        self.chkpnt_2: Checkpoint = create_checkpoint(self.chkpnt_1, {}, 1)
+        self.chkpnt_3: Checkpoint = empty_checkpoint()
 
-    metadata_1: CheckpointMetadata = {
-        "source": "input",
-        "step": 2,
-        "writes": {},
-        "score": 1,
-    }
-    metadata_2: CheckpointMetadata = {
-        "source": "loop",
-        "step": 1,
-        "writes": {"foo": "bar"},
-        "score": None,
-    }
-    metadata_3: CheckpointMetadata = {}
-
-    return {
-        "configs": [config_1, config_2, config_3],
-        "checkpoints": [chkpnt_1, chkpnt_2, chkpnt_3],
-        "metadata": [metadata_1, metadata_2, metadata_3],
-    }
-
-
-@pytest.mark.parametrize("saver_name", ["base", "pool", "pipe"])
-async def test_asearch(request, saver_name: str, test_data) -> None:
-    async with _saver(saver_name) as saver:
-        configs = test_data["configs"]
-        checkpoints = test_data["checkpoints"]
-        metadata = test_data["metadata"]
-
-        await saver.aput(configs[0], checkpoints[0], metadata[0], {})
-        await saver.aput(configs[1], checkpoints[1], metadata[1], {})
-        await saver.aput(configs[2], checkpoints[2], metadata[2], {})
-
-        # call method / assertions
-        query_1 = {"source": "input"}  # search by 1 key
-        query_2 = {
+        self.metadata_1: CheckpointMetadata = {
+            "source": "input",
+            "step": 2,
+            "writes": {},
+            "score": 1,
+        }
+        self.metadata_2: CheckpointMetadata = {
+            "source": "loop",
             "step": 1,
             "writes": {"foo": "bar"},
-        }  # search by multiple keys
-        query_3: dict[str, Any] = {}  # search by no keys, return all checkpoints
-        query_4 = {"source": "update", "step": 1}  # no match
+            "score": None,
+        }
+        self.metadata_3: CheckpointMetadata = {}
+        async with AsyncPostgresSaver.from_conn_string(DEFAULT_URI) as saver:
+            await saver.setup()
 
-        search_results_1 = [c async for c in saver.alist(None, filter=query_1)]
-        assert len(search_results_1) == 1
-        assert search_results_1[0].metadata == metadata[0]
+    async def test_asearch(self) -> None:
+        async with AsyncPostgresSaver.from_conn_string(DEFAULT_URI) as saver:
+            await saver.aput(self.config_1, self.chkpnt_1, self.metadata_1, {})
+            await saver.aput(self.config_2, self.chkpnt_2, self.metadata_2, {})
+            await saver.aput(self.config_3, self.chkpnt_3, self.metadata_3, {})
 
-        search_results_2 = [c async for c in saver.alist(None, filter=query_2)]
-        assert len(search_results_2) == 1
-        assert search_results_2[0].metadata == metadata[1]
+            # call method / assertions
+            query_1 = {"source": "input"}  # search by 1 key
+            query_2 = {
+                "step": 1,
+                "writes": {"foo": "bar"},
+            }  # search by multiple keys
+            query_3: dict[str, Any] = {}  # search by no keys, return all checkpoints
+            query_4 = {"source": "update", "step": 1}  # no match
 
-        search_results_3 = [c async for c in saver.alist(None, filter=query_3)]
-        assert len(search_results_3) == 3
+            search_results_1 = [c async for c in saver.alist(None, filter=query_1)]
+            assert len(search_results_1) == 1
+            assert search_results_1[0].metadata == self.metadata_1
 
-        search_results_4 = [c async for c in saver.alist(None, filter=query_4)]
-        assert len(search_results_4) == 0
+            search_results_2 = [c async for c in saver.alist(None, filter=query_2)]
+            assert len(search_results_2) == 1
+            assert search_results_2[0].metadata == self.metadata_2
 
-        # search by config (defaults to checkpoints across all namespaces)
-        search_results_5 = [
-            c async for c in saver.alist({"configurable": {"thread_id": "thread-2"}})
-        ]
-        assert len(search_results_5) == 2
-        assert {
-            search_results_5[0].config["configurable"]["checkpoint_ns"],
-            search_results_5[1].config["configurable"]["checkpoint_ns"],
-        } == {"", "inner"}
+            search_results_3 = [c async for c in saver.alist(None, filter=query_3)]
+            assert len(search_results_3) == 3
 
+            search_results_4 = [c async for c in saver.alist(None, filter=query_4)]
+            assert len(search_results_4) == 0
 
-@pytest.mark.parametrize("saver_name", ["base", "pool", "pipe"])
-async def test_null_chars(request, saver_name: str, test_data) -> None:
-    async with _saver(saver_name) as saver:
-        config = await saver.aput(
-            test_data["configs"][0],
-            test_data["checkpoints"][0],
-            {"my_key": "\x00abc"},
-            {},
-        )
-        assert (await saver.aget_tuple(config)).metadata["my_key"] == "abc"  # type: ignore
-        assert [c async for c in saver.alist(None, filter={"my_key": "abc"})][
-            0
-        ].metadata["my_key"] == "abc"
+            # search by config (defaults to checkpoints across all namespaces)
+            search_results_5 = [
+                c
+                async for c in saver.alist({"configurable": {"thread_id": "thread-2"}})
+            ]
+            assert len(search_results_5) == 2
+            assert {
+                search_results_5[0].config["configurable"]["checkpoint_ns"],
+                search_results_5[1].config["configurable"]["checkpoint_ns"],
+            } == {"", "inner"}
+
+            # TODO: test before and limit params
+
+    async def test_null_chars(self) -> None:
+        async with AsyncPostgresSaver.from_conn_string(DEFAULT_URI) as saver:
+            config = await saver.aput(
+                self.config_1, self.chkpnt_1, {"my_key": "\x00abc"}, {}
+            )
+            assert (await saver.aget_tuple(config)).metadata["my_key"] == "abc"  # type: ignore
+            assert [c async for c in saver.alist(None, filter={"my_key": "abc"})][
+                0
+            ].metadata["my_key"] == "abc"

libs/checkpoint-postgres/tests/test_async_store.py

@@ -1,84 +1,114 @@
 # type: ignore
-import itertools
-import sys
 import uuid
-from collections.abc import AsyncIterator
-from contextlib import asynccontextmanager
-from typing import Any, Optional
+from datetime import datetime
+from typing import Any
+from unittest.mock import AsyncMock, MagicMock
 
 import pytest
-from langchain_core.embeddings import Embeddings
-from psycopg import AsyncConnection
+from conftest import DEFAULT_URI  # type: ignore
 
 from langgraph.store.base import GetOp, Item, ListNamespacesOp, PutOp, SearchOp
 from langgraph.store.postgres import AsyncPostgresStore
-from tests.conftest import (
-    DEFAULT_URI,
-    VECTOR_TYPES,
-    CharacterEmbeddings,
-)
 
 
-@pytest.fixture(scope="function", params=["default", "pipe", "pool"])
-async def store(request) -> AsyncIterator[AsyncPostgresStore]:
-    if sys.version_info < (3, 10):
-        pytest.skip("Async Postgres tests require Python 3.10+")
+class MockAsyncCursor:
+    def __init__(self, fetch_result: Any) -> None:
+        self.fetch_result = fetch_result
+        self.execute = AsyncMock()
+        self.fetchall = AsyncMock(return_value=self.fetch_result)
 
-    database = f"test_{uuid.uuid4().hex[:16]}"
-    uri_parts = DEFAULT_URI.split("/")
-    uri_base = "/".join(uri_parts[:-1])
-    query_params = ""
-    if "?" in uri_parts[-1]:
-        db_name, query_params = uri_parts[-1].split("?", 1)
-        query_params = "?" + query_params
 
-    conn_string = f"{uri_base}/{database}{query_params}"
-    admin_conn_string = DEFAULT_URI
+class MockAsyncConnection:
+    def __init__(self) -> None:
+        self.cursor = MagicMock()
+        self.pipeline = MagicMock(
+            return_value=AsyncMock(__aenter__=AsyncMock(), __aexit__=AsyncMock())
+        )
 
-    async with await AsyncConnection.connect(
-        admin_conn_string, autocommit=True
-    ) as conn:
-        await conn.execute(f"CREATE DATABASE {database}")
-    try:
-        async with AsyncPostgresStore.from_conn_string(conn_string) as store:
-            await store.setup()
 
-        if request.param == "pipe":
-            async with AsyncPostgresStore.from_conn_string(
-                conn_string, pipeline=True
-            ) as store:
-                yield store
-        elif request.param == "pool":
-            async with AsyncPostgresStore.from_conn_string(
-                conn_string, pool_config={"min_size": 1, "max_size": 10}
-            ) as store:
-                yield store
-        else:  # default
-            async with AsyncPostgresStore.from_conn_string(conn_string) as store:
-                yield store
-    finally:
-        async with await AsyncConnection.connect(
-            admin_conn_string, autocommit=True
-        ) as conn:
-            await conn.execute(f"DROP DATABASE {database}")
+@pytest.fixture
+def mock_connection() -> MockAsyncConnection:
+    return MockAsyncConnection()
+
+
+@pytest.fixture
+async def store(mock_connection: MockAsyncConnection) -> AsyncPostgresStore:
+    return AsyncPostgresStore(mock_connection)
 
 
 async def test_abatch_order(store: AsyncPostgresStore) -> None:
-    # Setup test data
-    await store.aput(("test", "foo"), "key1", {"data": "value1"})
-    await store.aput(("test", "bar"), "key2", {"data": "value2"})
+    mock_connection = store.conn
+    mock_get_cursor = MockAsyncCursor(
+        [
+            {
+                "key": "key1",
+                "value": '{"data": "value1"}',
+                "created_at": datetime.now(),
+                "updated_at": datetime.now(),
+                "prefix": "test.foo",
+            },
+            {
+                "key": "key2",
+                "value": '{"data": "value2"}',
+                "created_at": datetime.now(),
+                "updated_at": datetime.now(),
+                "prefix": "test.bar",
+            },
+        ]
+    )
+    mock_search_cursor = MockAsyncCursor(
+        [
+            {
+                "key": "key1",
+                "value": '{"data": "value1"}',
+                "created_at": datetime.now(),
+                "updated_at": datetime.now(),
+                "prefix": "test.foo",
+            },
+        ]
+    )
+    mock_list_namespaces_cursor = MockAsyncCursor(
+        [
+            {"truncated_prefix": b"\x01test"},
+        ]
+    )
+
+    failures = []
+
+    def cursor_side_effect(binary: bool = False) -> Any:
+        cursor = MagicMock()
+
+        async def execute_side_effect(query: str, *params: Any) -> None:
+            # My super sophisticated database.
+            if "SELECT prefix, key," in query:
+                cursor.fetchall = mock_search_cursor.fetchall
+            elif "SELECT DISTINCT ON (truncated_prefix)" in query:
+                cursor.fetchall = mock_list_namespaces_cursor.fetchall
+            elif "WHERE prefix = %s AND key" in query:
+                cursor.fetchall = mock_get_cursor.fetchall
+            elif "INSERT INTO " in query:
+                pass
+            else:
+                e = ValueError(f"Unmatched query: {query}")
+                failures.append(e)
+                raise e
+
+        cursor.execute = AsyncMock(side_effect=execute_side_effect)
+        return cursor
+
+    mock_connection.cursor.side_effect = cursor_side_effect  # type: ignore
 
     ops = [
-        GetOp(namespace=("test", "foo"), key="key1"),
-        PutOp(namespace=("test", "bar"), key="key2", value={"data": "value2"}),
+        GetOp(namespace=("test",), key="key1"),
+        PutOp(namespace=("test",), key="key2", value={"data": "value2"}),
         SearchOp(
             namespace_prefix=("test",), filter={"data": "value1"}, limit=10, offset=0
         ),
         ListNamespacesOp(match_conditions=None, max_depth=None, limit=10, offset=0),
         GetOp(namespace=("test",), key="key3"),
     ]
-
     results = await store.abatch(ops)
+    assert not failures
     assert len(results) == 5
     assert isinstance(results[0], Item)
     assert isinstance(results[0].value, dict)
@@ -88,29 +118,27 @@ async def test_abatch_order(store: AsyncPostgresStore) -> None:
     assert isinstance(results[2], list)
     assert len(results[2]) == 1
     assert isinstance(results[3], list)
-    assert ("test", "foo") in results[3] and ("test", "bar") in results[3]
+    assert results[3] == [("test",)]
     assert results[4] is None
 
     ops_reordered = [
         SearchOp(namespace_prefix=("test",), filter=None, limit=5, offset=0),
-        GetOp(namespace=("test", "bar"), key="key2"),
+        GetOp(namespace=("test",), key="key2"),
         ListNamespacesOp(match_conditions=None, max_depth=None, limit=5, offset=0),
         PutOp(namespace=("test",), key="key3", value={"data": "value3"}),
-        GetOp(namespace=("test", "foo"), key="key1"),
+        GetOp(namespace=("test",), key="key1"),
     ]
 
     results_reordered = await store.abatch(ops_reordered)
+    assert not failures
     assert len(results_reordered) == 5
     assert isinstance(results_reordered[0], list)
-    assert len(results_reordered[0]) == 2
+    assert len(results_reordered[0]) == 1
     assert isinstance(results_reordered[1], Item)
     assert results_reordered[1].value == {"data": "value2"}
     assert results_reordered[1].key == "key2"
     assert isinstance(results_reordered[2], list)
-    assert ("test", "foo") in results_reordered[2] and (
-        "test",
-        "bar",
-    ) in results_reordered[2]
+    assert results_reordered[2] == [("test",)]
     assert results_reordered[3] is None
     assert isinstance(results_reordered[4], Item)
     assert results_reordered[4].value == {"data": "value1"}
@@ -118,9 +146,26 @@ async def test_abatch_order(store: AsyncPostgresStore) -> None:
 
 
 async def test_batch_get_ops(store: AsyncPostgresStore) -> None:
-    # Setup test data
-    await store.aput(("test",), "key1", {"data": "value1"})
-    await store.aput(("test",), "key2", {"data": "value2"})
+    mock_connection = store.conn
+    mock_cursor = MockAsyncCursor(
+        [
+            {
+                "key": "key1",
+                "value": '{"data": "value1"}',
+                "created_at": datetime.now(),
+                "updated_at": datetime.now(),
+                "prefix": "test.foo",
+            },
+            {
+                "key": "key2",
+                "value": '{"data": "value2"}',
+                "created_at": datetime.now(),
+                "updated_at": datetime.now(),
+                "prefix": "test.bar",
+            },
+        ]
+    )
+    mock_connection.cursor.return_value = mock_cursor
 
     ops = [
         GetOp(namespace=("test",), key="key1"),
@@ -139,6 +184,10 @@ async def test_batch_get_ops(store: AsyncPostgresStore) -> None:
 
 
 async def test_batch_put_ops(store: AsyncPostgresStore) -> None:
+    mock_connection = store.conn
+    mock_cursor = MockAsyncCursor([])
+    mock_connection.cursor.return_value = mock_cursor
+
     ops = [
         PutOp(namespace=("test",), key="key1", value={"data": "value1"}),
         PutOp(namespace=("test",), key="key2", value={"data": "value2"}),
@@ -149,16 +198,30 @@ async def test_batch_put_ops(store: AsyncPostgresStore) -> None:
 
     assert len(results) == 3
     assert all(result is None for result in results)
-
-    # Verify the puts worked
-    items = await store.asearch(["test"], limit=10)
-    assert len(items) == 2  # key3 had None value so wasn't stored
+    assert mock_cursor.execute.call_count == 2
 
 
 async def test_batch_search_ops(store: AsyncPostgresStore) -> None:
-    # Setup test data
-    await store.aput(("test", "foo"), "key1", {"data": "value1"})
-    await store.aput(("test", "bar"), "key2", {"data": "value2"})
+    mock_connection = store.conn
+    mock_cursor = MockAsyncCursor(
+        [
+            {
+                "key": "key1",
+                "value": '{"data": "value1"}',
+                "created_at": datetime.now(),
+                "updated_at": datetime.now(),
+                "prefix": "test.foo",
+            },
+            {
+                "key": "key2",
+                "value": '{"data": "value2"}',
+                "created_at": datetime.now(),
+                "updated_at": datetime.now(),
+                "prefix": "test.bar",
+            },
+        ]
+    )
+    mock_connection.cursor.return_value = mock_cursor
 
     ops = [
         SearchOp(
@@ -170,338 +233,297 @@ async def test_batch_search_ops(store: AsyncPostgresStore) -> None:
     results = await store.abatch(ops)
 
     assert len(results) == 2
-    assert len(results[0]) == 1  # Filtered results
-    assert len(results[1]) == 2  # All results
+    assert len(results[0]) == 2
+    assert len(results[1]) == 2
 
 
 async def test_batch_list_namespaces_ops(store: AsyncPostgresStore) -> None:
-    # Setup test data
-    await store.aput(("test", "namespace1"), "key1", {"data": "value1"})
-    await store.aput(("test", "namespace2"), "key2", {"data": "value2"})
+    mock_connection = store.conn
+    mock_cursor = MockAsyncCursor(
+        [
+            {"truncated_prefix": b"\x01test.namespace1"},
+            {"truncated_prefix": b"\x01test.namespace2"},
+        ]
+    )
+    mock_connection.cursor.return_value = mock_cursor
 
     ops = [ListNamespacesOp(match_conditions=None, max_depth=None, limit=10, offset=0)]
 
     results = await store.abatch(ops)
 
     assert len(results) == 1
-    assert len(results[0]) == 2
-    assert ("test", "namespace1") in results[0]
-    assert ("test", "namespace2") in results[0]
+    assert results[0] == [("test", "namespace1"), ("test", "namespace2")]
 
 
-@asynccontextmanager
-async def _create_vector_store(
-    vector_type: str,
-    distance_type: str,
-    fake_embeddings: CharacterEmbeddings,
-    text_fields: Optional[list[str]] = None,
-) -> AsyncIterator[AsyncPostgresStore]:
-    """Create a store with vector search enabled."""
-    if sys.version_info < (3, 10):
-        pytest.skip("Async Postgres tests require Python 3.10+")
+# The following use the actual DB connection
 
-    database = f"test_{uuid.uuid4().hex[:16]}"
-    uri_parts = DEFAULT_URI.split("/")
-    uri_base = "/".join(uri_parts[:-1])
-    query_params = ""
-    if "?" in uri_parts[-1]:
-        db_name, query_params = uri_parts[-1].split("?", 1)
-        query_params = "?" + query_params
 
-    conn_string = f"{uri_base}/{database}{query_params}"
-    admin_conn_string = DEFAULT_URI
-
-    index_config = {
-        "dims": fake_embeddings.dims,
-        "embed": fake_embeddings,
-        "ann_index_config": {
-            "vector_type": vector_type,
-        },
-        "distance_type": distance_type,
-        "text_fields": text_fields,
-    }
-
-    async with await AsyncConnection.connect(
-        admin_conn_string, autocommit=True
-    ) as conn:
-        await conn.execute(f"CREATE DATABASE {database}")
-    try:
-        async with AsyncPostgresStore.from_conn_string(
-            conn_string,
-            index=index_config,
-        ) as store:
+class TestAsyncPostgresStore:
+    @pytest.fixture(autouse=True)
+    async def setup(self) -> None:
+        async with AsyncPostgresStore.from_conn_string(DEFAULT_URI) as store:
             await store.setup()
-            yield store
-    finally:
-        async with await AsyncConnection.connect(
-            admin_conn_string, autocommit=True
-        ) as conn:
-            await conn.execute(f"DROP DATABASE {database}")
 
+    async def test_basic_store_ops(self) -> None:
+        async with AsyncPostgresStore.from_conn_string(DEFAULT_URI) as store:
+            namespace = ("test", "documents")
+            item_id = "doc1"
+            item_value = {"title": "Test Document", "content": "Hello, World!"}
 
-@pytest.fixture(
-    scope="function",
-    params=[
-        (vector_type, distance_type)
-        for vector_type in VECTOR_TYPES
-        for distance_type in (
-            ["hamming"] if vector_type == "bit" else ["l2", "inner_product", "cosine"]
-        )
-    ],
-    ids=lambda p: f"{p[0]}_{p[1]}",
-)
-async def vector_store(
-    request,
-    fake_embeddings: CharacterEmbeddings,
-) -> AsyncIterator[AsyncPostgresStore]:
-    """Create a store with vector search enabled."""
-    vector_type, distance_type = request.param
-    async with _create_vector_store(
-        vector_type, distance_type, fake_embeddings
-    ) as store:
-        yield store
+            await store.aput(namespace, item_id, item_value)
+            item = await store.aget(namespace, item_id)
 
+            assert item
+            assert item.namespace == namespace
+            assert item.key == item_id
+            assert item.value == item_value
 
-async def test_vector_store_initialization(
-    vector_store: AsyncPostgresStore, fake_embeddings: CharacterEmbeddings
-) -> None:
-    """Test store initialization with embedding config."""
-    assert vector_store.index_config is not None
-    assert vector_store.index_config["dims"] == fake_embeddings.dims
-    if isinstance(vector_store.index_config["embed"], Embeddings):
-        assert vector_store.index_config["embed"] == fake_embeddings
+            updated_value = {
+                "title": "Updated Test Document",
+                "content": "Hello, LangGraph!",
+            }
+            await store.aput(namespace, item_id, updated_value)
+            updated_item = await store.aget(namespace, item_id)
 
+            assert updated_item.value == updated_value
+            assert updated_item.updated_at > item.updated_at
+            different_namespace = ("test", "other_documents")
+            item_in_different_namespace = await store.aget(different_namespace, item_id)
+            assert item_in_different_namespace is None
 
-async def test_vector_insert_with_auto_embedding(
-    vector_store: AsyncPostgresStore,
-) -> None:
-    """Test inserting items that get auto-embedded."""
-    docs = [
-        ("doc1", {"text": "short text"}),
-        ("doc2", {"text": "longer text document"}),
-        ("doc3", {"text": "longest text document here"}),
-        ("doc4", {"description": "text in description field"}),
-        ("doc5", {"content": "text in content field"}),
-        ("doc6", {"body": "text in body field"}),
-    ]
+            new_item_id = "doc2"
+            new_item_value = {"title": "Another Document", "content": "Greetings!"}
+            await store.aput(namespace, new_item_id, new_item_value)
 
-    for key, value in docs:
-        await vector_store.aput(("test",), key, value)
+            search_results = await store.asearch(["test"], limit=10)
+            items = search_results
+            assert len(items) == 2
+            assert any(item.key == item_id for item in items)
+            assert any(item.key == new_item_id for item in items)
 
-    results = await vector_store.asearch(("test",), query="long text")
-    assert len(results) > 0
+            namespaces = await store.alist_namespaces(prefix=["test"])
+            assert ("test", "documents") in namespaces
 
-    doc_order = [r.key for r in results]
-    assert "doc2" in doc_order
-    assert "doc3" in doc_order
+            await store.adelete(namespace, item_id)
+            await store.adelete(namespace, new_item_id)
+            deleted_item = await store.aget(namespace, item_id)
+            assert deleted_item is None
 
+            deleted_item = await store.aget(namespace, new_item_id)
+            assert deleted_item is None
 
-async def test_vector_update_with_embedding(vector_store: AsyncPostgresStore) -> None:
-    """Test that updating items properly updates their embeddings."""
-    await vector_store.aput(("test",), "doc1", {"text": "zany zebra Xerxes"})
-    await vector_store.aput(("test",), "doc2", {"text": "something about dogs"})
-    await vector_store.aput(("test",), "doc3", {"text": "text about birds"})
+            empty_search_results = await store.asearch(["test"], limit=10)
+            assert len(empty_search_results) == 0
 
-    results_initial = await vector_store.asearch(("test",), query="Zany Xerxes")
-    assert len(results_initial) > 0
-    assert results_initial[0].key == "doc1"
-    initial_score = results_initial[0].score
+    async def test_list_namespaces(self) -> None:
+        async with AsyncPostgresStore.from_conn_string(DEFAULT_URI) as store:
+            test_pref = str(uuid.uuid4())
+            test_namespaces = [
+                (test_pref, "test", "documents", "public", test_pref),
+                (test_pref, "test", "documents", "private", test_pref),
+                (test_pref, "test", "images", "public", test_pref),
+                (test_pref, "test", "images", "private", test_pref),
+                (test_pref, "prod", "documents", "public", test_pref),
+                (
+                    test_pref,
+                    "prod",
+                    "documents",
+                    "some",
+                    "nesting",
+                    "public",
+                    test_pref,
+                ),
+                (test_pref, "prod", "documents", "private", test_pref),
+            ]
 
-    await vector_store.aput(("test",), "doc1", {"text": "new text about dogs"})
+            for namespace in test_namespaces:
+                await store.aput(namespace, "dummy", {"content": "dummy"})
 
-    results_after = await vector_store.asearch(("test",), query="Zany Xerxes")
-    after_score = next((r.score for r in results_after if r.key == "doc1"), 0.0)
-    assert after_score < initial_score
+            prefix_result = await store.alist_namespaces(prefix=[test_pref, "test"])
+            assert len(prefix_result) == 4
+            assert all([ns[1] == "test" for ns in prefix_result])
 
-    results_new = await vector_store.asearch(("test",), query="new text about dogs")
-    for r in results_new:
-        if r.key == "doc1":
-            assert r.score > after_score
+            specific_prefix_result = await store.alist_namespaces(
+                prefix=[test_pref, "test", "documents"]
+            )
+            assert len(specific_prefix_result) == 2
+            assert all(
+                [ns[1:3] == ("test", "documents") for ns in specific_prefix_result]
+            )
 
-    # Don't index this one
-    await vector_store.aput(
-        ("test",), "doc4", {"text": "new text about dogs"}, index=False
-    )
-    results_new = await vector_store.asearch(
-        ("test",), query="new text about dogs", limit=3
-    )
-    assert not any(r.key == "doc4" for r in results_new)
+            suffix_result = await store.alist_namespaces(suffix=["public", test_pref])
+            assert len(suffix_result) == 4
+            assert all(ns[-2] == "public" for ns in suffix_result)
 
+            prefix_suffix_result = await store.alist_namespaces(
+                prefix=[test_pref, "test"], suffix=["public", test_pref]
+            )
+            assert len(prefix_suffix_result) == 2
+            assert all(
+                ns[1] == "test" and ns[-2] == "public" for ns in prefix_suffix_result
+            )
 
-async def test_vector_search_with_filters(vector_store: AsyncPostgresStore) -> None:
-    """Test combining vector search with filters."""
-    docs = [
-        ("doc1", {"text": "red apple", "color": "red", "score": 4.5}),
-        ("doc2", {"text": "red car", "color": "red", "score": 3.0}),
-        ("doc3", {"text": "green apple", "color": "green", "score": 4.0}),
-        ("doc4", {"text": "blue car", "color": "blue", "score": 3.5}),
-    ]
+            wildcard_prefix_result = await store.alist_namespaces(
+                prefix=[test_pref, "*", "documents"]
+            )
+            assert len(wildcard_prefix_result) == 5
+            assert all(ns[2] == "documents" for ns in wildcard_prefix_result)
 
-    for key, value in docs:
-        await vector_store.aput(("test",), key, value)
+            wildcard_suffix_result = await store.alist_namespaces(
+                suffix=["*", "public", test_pref]
+            )
+            assert len(wildcard_suffix_result) == 4
+            assert all(ns[-2] == "public" for ns in wildcard_suffix_result)
+            wildcard_single = await store.alist_namespaces(
+                suffix=["some", "*", "public", test_pref]
+            )
+            assert len(wildcard_single) == 1
+            assert wildcard_single[0] == (
+                test_pref,
+                "prod",
+                "documents",
+                "some",
+                "nesting",
+                "public",
+                test_pref,
+            )
 
-    results = await vector_store.asearch(
-        ("test",), query="apple", filter={"color": "red"}
-    )
-    assert len(results) == 2
-    assert results[0].key == "doc1"
+            max_depth_result = await store.alist_namespaces(max_depth=3)
+            assert all([len(ns) <= 3 for ns in max_depth_result])
+            max_depth_result = await store.alist_namespaces(
+                max_depth=4, prefix=[test_pref, "*", "documents"]
+            )
+            assert (
+                len(set(tuple(res) for res in max_depth_result))
+                == len(max_depth_result)
+                == 5
+            )
 
-    results = await vector_store.asearch(
-        ("test",), query="car", filter={"color": "red"}
-    )
-    assert len(results) == 2
-    assert results[0].key == "doc2"
+            limit_result = await store.alist_namespaces(prefix=[test_pref], limit=3)
+            assert len(limit_result) == 3
 
-    results = await vector_store.asearch(
-        ("test",), query="bbbbluuu", filter={"score": {"$gt": 3.2}}
-    )
-    assert len(results) == 3
-    assert results[0].key == "doc4"
+            offset_result = await store.alist_namespaces(prefix=[test_pref], offset=3)
+            assert len(offset_result) == len(test_namespaces) - 3
 
-    results = await vector_store.asearch(
-        ("test",), query="apple", filter={"score": {"$gte": 4.0}, "color": "green"}
-    )
-    assert len(results) == 1
-    assert results[0].key == "doc3"
+            empty_prefix_result = await store.alist_namespaces(prefix=[test_pref])
+            assert len(empty_prefix_result) == len(test_namespaces)
+            assert set(tuple(ns) for ns in empty_prefix_result) == set(
+                tuple(ns) for ns in test_namespaces
+            )
 
+            for namespace in test_namespaces:
+                await store.adelete(namespace, "dummy")
 
-async def test_vector_search_pagination(vector_store: AsyncPostgresStore) -> None:
-    """Test pagination with vector search."""
-    for i in range(5):
-        await vector_store.aput(
-            ("test",), f"doc{i}", {"text": f"test document number {i}"}
-        )
+    async def test_search(self):
+        async with AsyncPostgresStore.from_conn_string(DEFAULT_URI) as store:
+            test_namespaces = [
+                ("test_search", "documents", "user1"),
+                ("test_search", "documents", "user2"),
+                ("test_search", "reports", "department1"),
+                ("test_search", "reports", "department2"),
+            ]
+            test_items = [
+                {"title": "Doc 1", "author": "John Doe", "tags": ["important"]},
+                {"title": "Doc 2", "author": "Jane Smith", "tags": ["draft"]},
+                {"title": "Report A", "author": "John Doe", "tags": ["final"]},
+                {"title": "Report B", "author": "Alice Johnson", "tags": ["draft"]},
+            ]
+            empty = await store.asearch(
+                (
+                    "scoped",
+                    "assistant_id",
+                    "shared",
+                    "6c5356f6-63ab-4158-868d-cd9fd14c736e",
+                ),
+                limit=10,
+                offset=0,
+            )
+            assert len(empty) == 0
 
-    results_page1 = await vector_store.asearch(("test",), query="test", limit=2)
-    results_page2 = await vector_store.asearch(
-        ("test",), query="test", limit=2, offset=2
-    )
+            for namespace, item in zip(test_namespaces, test_items):
+                await store.aput(namespace, f"item_{namespace[-1]}", item)
 
-    assert len(results_page1) == 2
-    assert len(results_page2) == 2
-    assert results_page1[0].key != results_page2[0].key
+            docs_result = await store.asearch(["test_search", "documents"])
+            assert len(docs_result) == 2
+            assert all([item.namespace[1] == "documents" for item in docs_result]), [
+                item.namespace for item in docs_result
+            ]
 
-    all_results = await vector_store.asearch(("test",), query="test", limit=10)
-    assert len(all_results) == 5
+            reports_result = await store.asearch(["test_search", "reports"])
+            assert len(reports_result) == 2
+            assert all(item.namespace[1] == "reports" for item in reports_result)
 
+            limited_result = await store.asearch(["test_search"], limit=2)
+            assert len(limited_result) == 2
+            offset_result = await store.asearch(["test_search"])
+            assert len(offset_result) == 4
 
-async def test_vector_search_edge_cases(vector_store: AsyncPostgresStore) -> None:
-    """Test edge cases in vector search."""
-    await vector_store.aput(("test",), "doc1", {"text": "test document"})
+            offset_result = await store.asearch(["test_search"], offset=2)
+            assert len(offset_result) == 2
+            assert all(item not in limited_result for item in offset_result)
 
-    perfect_match = await vector_store.asearch(("test",), query="text test document")
-    perfect_score = perfect_match[0].score
+            john_doe_result = await store.asearch(
+                ["test_search"], filter={"author": "John Doe"}
+            )
+            assert len(john_doe_result) == 2
+            assert all(item.value["author"] == "John Doe" for item in john_doe_result)
 
-    results = await vector_store.asearch(("test",), query="")
-    assert len(results) == 1
-    assert results[0].score is None
+            draft_result = await store.asearch(
+                ["test_search"], filter={"tags": ["draft"]}
+            )
+            assert len(draft_result) == 2
+            assert all("draft" in item.value["tags"] for item in draft_result)
 
-    results = await vector_store.asearch(("test",), query=None)
-    assert len(results) == 1
-    assert results[0].score is None
+            page1 = await store.asearch(["test_search"], limit=2, offset=0)
+            page2 = await store.asearch(["test_search"], limit=2, offset=2)
+            all_items = page1 + page2
+            assert len(all_items) == 4
+            assert len(set(item.key for item in all_items)) == 4
+            empty = await store.asearch(
+                (
+                    "scoped",
+                    "assistant_id",
+                    "shared",
+                    "again",
+                    "maybe",
+                    "some-long",
+                    "6be5cb0e-2eb4-42e6-bb6b-fba3c269db25",
+                ),
+                limit=10,
+                offset=0,
+            )
+            assert len(empty) == 0
 
-    long_query = "foo " * 100
-    results = await vector_store.asearch(("test",), query=long_query)
-    assert len(results) == 1
-    assert results[0].score < perfect_score
+            # Test with a namespace beginning with a number (like a UUID)
+            uuid_namespace = (str(uuid.uuid4()), "documents")
+            uuid_item_id = "uuid_doc"
+            uuid_item_value = {
+                "title": "UUID Document",
+                "content": "This document has a UUID namespace.",
+            }
 
-    special_query = "test!@#$%^&*()"
-    results = await vector_store.asearch(("test",), query=special_query)
-    assert len(results) == 1
-    assert results[0].score < perfect_score
+            # Insert the item with the UUID namespace
+            await store.aput(uuid_namespace, uuid_item_id, uuid_item_value)
 
+            # Retrieve the item to verify it was stored correctly
+            retrieved_item = await store.aget(uuid_namespace, uuid_item_id)
+            assert retrieved_item is not None
+            assert retrieved_item.namespace == uuid_namespace
+            assert retrieved_item.key == uuid_item_id
+            assert retrieved_item.value == uuid_item_value
 
-@pytest.mark.parametrize(
-    "vector_type,distance_type",
-    [
-        *itertools.product(["vector", "halfvec"], ["cosine", "inner_product", "l2"]),
-    ],
-)
-async def test_embed_with_path(
-    request: Any,
-    fake_embeddings: CharacterEmbeddings,
-    vector_type: str,
-    distance_type: str,
-) -> None:
-    """Test vector search with specific text fields in Postgres store."""
-    async with _create_vector_store(
-        vector_type,
-        distance_type,
-        fake_embeddings,
-        text_fields=["key0", "key1", "key3"],
-    ) as store:
-        # This will have 2 vectors representing it
-        doc1 = {
-            # Omit key0 - check it doesn't raise an error
-            "key1": "xxx",
-            "key2": "yyy",
-            "key3": "zzz",
-        }
-        # This will have 3 vectors representing it
-        doc2 = {
-            "key0": "uuu",
-            "key1": "vvv",
-            "key2": "www",
-            "key3": "xxx",
-        }
-        await store.aput(("test",), "doc1", doc1)
-        await store.aput(("test",), "doc2", doc2)
+            # Search for the item using the UUID namespace
+            search_result = await store.asearch([uuid_namespace[0]])
+            assert len(search_result) == 1
+            assert search_result[0].key == uuid_item_id
+            assert search_result[0].value == uuid_item_value
 
-        # doc2.key3 and doc1.key1 both would have the highest score
-        results = await store.asearch(("test",), query="xxx")
-        assert len(results) == 2
-        assert results[0].key != results[1].key
-        ascore = results[0].score
-        bscore = results[1].score
-        assert ascore == pytest.approx(bscore, abs=1e-3)
+            # Clean up: delete the item with the UUID namespace
+            await store.adelete(uuid_namespace, uuid_item_id)
 
-        results = await store.asearch(("test",), query="uuu")
-        assert len(results) == 2
-        assert results[0].key != results[1].key
-        assert results[0].key == "doc2"
-        assert results[0].score > results[1].score
-        assert ascore == pytest.approx(results[0].score, abs=1e-3)
+            # Verify the item was deleted
+            deleted_item = await store.aget(uuid_namespace, uuid_item_id)
+            assert deleted_item is None
 
-        # Un-indexed - will have low results for both. Not zero (because we're projecting)
-        # but less than the above.
-        results = await store.asearch(("test",), query="www")
-        assert len(results) == 2
-        assert results[0].score < ascore
-        assert results[1].score < ascore
-
-
-@pytest.mark.parametrize(
-    "vector_type,distance_type",
-    [
-        *itertools.product(["vector", "halfvec"], ["cosine", "inner_product", "l2"]),
-    ],
-)
-async def test_search_sorting(
-    request: Any,
-    fake_embeddings: CharacterEmbeddings,
-    vector_type: str,
-    distance_type: str,
-) -> None:
-    """Test operation-level field configuration for vector search."""
-    async with _create_vector_store(
-        vector_type,
-        distance_type,
-        fake_embeddings,
-        text_fields=["key1"],  # Default fields that won't match our test data
-    ) as store:
-        amatch = {
-            "key1": "mmm",
-        }
-
-        await store.aput(("test", "M"), "M", amatch)
-        N = 100
-        for i in range(N):
-            await store.aput(("test", "A"), f"A{i}", {"key1": "no"})
-        for i in range(N):
-            await store.aput(("test", "Z"), f"Z{i}", {"key1": "no"})
-
-        results = await store.asearch(("test",), query="mmm", limit=10)
-        assert len(results) == 10
-        assert len(set(r.key for r in results)) == 10
-        assert results[0].key == "M"
-        assert results[0].score > results[1].score
+            for namespace in test_namespaces:
+                await store.adelete(namespace, f"item_{namespace[-1]}")

libs/checkpoint-postgres/tests/test_sync.py

@@ -1,14 +1,8 @@
-# type: ignore
-
-from contextlib import contextmanager
 from typing import Any
-from uuid import uuid4
 
 import pytest
+from conftest import DEFAULT_URI  # type: ignore
 from langchain_core.runnables import RunnableConfig
-from psycopg import Connection
-from psycopg.rows import dict_row
-from psycopg_pool import ConnectionPool
 
 from langgraph.checkpoint.base import (
     Checkpoint,
@@ -17,199 +11,102 @@ from langgraph.checkpoint.base import (
     empty_checkpoint,
 )
 from langgraph.checkpoint.postgres import PostgresSaver
-from tests.conftest import DEFAULT_POSTGRES_URI
 
 
-@contextmanager
-def _pool_saver():
-    """Fixture for pool mode testing."""
-    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:
-        # yield checkpointer
-        with ConnectionPool(
-            DEFAULT_POSTGRES_URI + database,
-            max_size=10,
-            kwargs={"autocommit": True, "row_factory": dict_row},
-        ) as pool:
-            checkpointer = PostgresSaver(pool)
-            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 _pipe_saver():
-    """Fixture for pipeline mode testing."""
-    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:
-            with conn.pipeline() as pipe:
-                checkpointer = PostgresSaver(conn, pipe=pipe)
-                checkpointer.setup()
-            with conn.pipeline() as pipe:
-                checkpointer = PostgresSaver(conn, pipe=pipe)
-                yield checkpointer
-    finally:
-        # drop unique db
-        with Connection.connect(DEFAULT_POSTGRES_URI, autocommit=True) as conn:
-            conn.execute(f"DROP DATABASE {database}")
-
-
-@contextmanager
-def _base_saver():
-    """Fixture for regular connection mode testing."""
-    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 = PostgresSaver(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 == "pool":
-        with _pool_saver() as saver:
-            yield saver
-    elif name == "pipe":
-        with _pipe_saver() as saver:
-            yield saver
-
-
-@pytest.fixture
-def test_data():
-    """Fixture providing test data for checkpoint tests."""
-    config_1: RunnableConfig = {
-        "configurable": {
-            "thread_id": "thread-1",
-            # for backwards compatibility testing
-            "thread_ts": "1",
-            "checkpoint_ns": "",
+class TestPostgresSaver:
+    @pytest.fixture(autouse=True)
+    def setup(self) -> None:
+        # objects for test setup
+        self.config_1: RunnableConfig = {
+            "configurable": {
+                "thread_id": "thread-1",
+                # for backwards compatibility testing
+                "thread_ts": "1",
+                "checkpoint_ns": "",
+            }
         }
-    }
-    config_2: RunnableConfig = {
-        "configurable": {
-            "thread_id": "thread-2",
-            "checkpoint_id": "2",
-            "checkpoint_ns": "",
+        self.config_2: RunnableConfig = {
+            "configurable": {
+                "thread_id": "thread-2",
+                "checkpoint_id": "2",
+                "checkpoint_ns": "",
+            }
         }
-    }
-    config_3: RunnableConfig = {
-        "configurable": {
-            "thread_id": "thread-2",
-            "checkpoint_id": "2-inner",
-            "checkpoint_ns": "inner",
+        self.config_3: RunnableConfig = {
+            "configurable": {
+                "thread_id": "thread-2",
+                "checkpoint_id": "2-inner",
+                "checkpoint_ns": "inner",
+            }
         }
-    }
 
-    chkpnt_1: Checkpoint = empty_checkpoint()
-    chkpnt_2: Checkpoint = create_checkpoint(chkpnt_1, {}, 1)
-    chkpnt_3: Checkpoint = empty_checkpoint()
+        self.chkpnt_1: Checkpoint = empty_checkpoint()
+        self.chkpnt_2: Checkpoint = create_checkpoint(self.chkpnt_1, {}, 1)
+        self.chkpnt_3: Checkpoint = empty_checkpoint()
 
-    metadata_1: CheckpointMetadata = {
-        "source": "input",
-        "step": 2,
-        "writes": {},
-        "score": 1,
-    }
-    metadata_2: CheckpointMetadata = {
-        "source": "loop",
-        "step": 1,
-        "writes": {"foo": "bar"},
-        "score": None,
-    }
-    metadata_3: CheckpointMetadata = {}
-
-    return {
-        "configs": [config_1, config_2, config_3],
-        "checkpoints": [chkpnt_1, chkpnt_2, chkpnt_3],
-        "metadata": [metadata_1, metadata_2, metadata_3],
-    }
-
-
-@pytest.mark.parametrize("saver_name", ["base", "pool", "pipe"])
-def test_search(saver_name: str, test_data) -> None:
-    with _saver(saver_name) as saver:
-        configs = test_data["configs"]
-        checkpoints = test_data["checkpoints"]
-        metadata = test_data["metadata"]
-
-        saver.put(configs[0], checkpoints[0], metadata[0], {})
-        saver.put(configs[1], checkpoints[1], metadata[1], {})
-        saver.put(configs[2], checkpoints[2], metadata[2], {})
-
-        # call method / assertions
-        query_1 = {"source": "input"}  # search by 1 key
-        query_2 = {
+        self.metadata_1: CheckpointMetadata = {
+            "source": "input",
+            "step": 2,
+            "writes": {},
+            "score": 1,
+        }
+        self.metadata_2: CheckpointMetadata = {
+            "source": "loop",
             "step": 1,
             "writes": {"foo": "bar"},
-        }  # search by multiple keys
-        query_3: dict[str, Any] = {}  # search by no keys, return all checkpoints
-        query_4 = {"source": "update", "step": 1}  # no match
+            "score": None,
+        }
+        self.metadata_3: CheckpointMetadata = {}
+        with PostgresSaver.from_conn_string(DEFAULT_URI) as saver:
+            saver.setup()
 
-        search_results_1 = list(saver.list(None, filter=query_1))
-        assert len(search_results_1) == 1
-        assert search_results_1[0].metadata == metadata[0]
+    def test_search(self) -> None:
+        with PostgresSaver.from_conn_string(DEFAULT_URI) as saver:
+            # save checkpoints
+            saver.put(self.config_1, self.chkpnt_1, self.metadata_1, {})
+            saver.put(self.config_2, self.chkpnt_2, self.metadata_2, {})
+            saver.put(self.config_3, self.chkpnt_3, self.metadata_3, {})
 
-        search_results_2 = list(saver.list(None, filter=query_2))
-        assert len(search_results_2) == 1
-        assert search_results_2[0].metadata == metadata[1]
+            # call method / assertions
+            query_1 = {"source": "input"}  # search by 1 key
+            query_2 = {
+                "step": 1,
+                "writes": {"foo": "bar"},
+            }  # search by multiple keys
+            query_3: dict[str, Any] = {}  # search by no keys, return all checkpoints
+            query_4 = {"source": "update", "step": 1}  # no match
 
-        search_results_3 = list(saver.list(None, filter=query_3))
-        assert len(search_results_3) == 3
+            search_results_1 = list(saver.list(None, filter=query_1))
+            assert len(search_results_1) == 1
+            assert search_results_1[0].metadata == self.metadata_1
 
-        search_results_4 = list(saver.list(None, filter=query_4))
-        assert len(search_results_4) == 0
+            search_results_2 = list(saver.list(None, filter=query_2))
+            assert len(search_results_2) == 1
+            assert search_results_2[0].metadata == self.metadata_2
 
-        # search by config (defaults to checkpoints across all namespaces)
-        search_results_5 = list(saver.list({"configurable": {"thread_id": "thread-2"}}))
-        assert len(search_results_5) == 2
-        assert {
-            search_results_5[0].config["configurable"]["checkpoint_ns"],
-            search_results_5[1].config["configurable"]["checkpoint_ns"],
-        } == {"", "inner"}
+            search_results_3 = list(saver.list(None, filter=query_3))
+            assert len(search_results_3) == 3
 
+            search_results_4 = list(saver.list(None, filter=query_4))
+            assert len(search_results_4) == 0
 
-@pytest.mark.parametrize("saver_name", ["base", "pool", "pipe"])
-def test_null_chars(saver_name: str, test_data) -> None:
-    with _saver(saver_name) as saver:
-        config = saver.put(
-            test_data["configs"][0],
-            test_data["checkpoints"][0],
-            {"my_key": "\x00abc"},
-            {},
-        )
-        assert saver.get_tuple(config).metadata["my_key"] == "abc"  # type: ignore
-        assert (
-            list(saver.list(None, filter={"my_key": "abc"}))[0].metadata["my_key"]
-            == "abc"
-        )
+            # search by config (defaults to checkpoints across all namespaces)
+            search_results_5 = list(
+                saver.list({"configurable": {"thread_id": "thread-2"}})
+            )
+            assert len(search_results_5) == 2
+            assert {
+                search_results_5[0].config["configurable"]["checkpoint_ns"],
+                search_results_5[1].config["configurable"]["checkpoint_ns"],
+            } == {"", "inner"}
+
+            # TODO: test before and limit params
+
+    def test_null_chars(self) -> None:
+        with PostgresSaver.from_conn_string(DEFAULT_URI) as saver:
+            config = saver.put(self.config_1, self.chkpnt_1, {"my_key": "\x00abc"}, {})
+            assert saver.get_tuple(config).metadata["my_key"] == "abc"  # type: ignore
+            assert (
+                list(saver.list(None, filter={"my_key": "abc"}))[0].metadata["my_key"]  # type: ignore
+                == "abc"
+            )

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

@@ -110,7 +110,7 @@ class SqliteSaver(BaseCheckpointSaver[str]):
                 check_same_thread=False,
             )
         ) as conn:
-            yield cls(conn)
+            yield SqliteSaver(conn)
 
     def setup(self) -> None:
         """Set up the checkpoint database.

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

@@ -137,7 +137,7 @@ class AsyncSqliteSaver(BaseCheckpointSaver[str]):
             AsyncSqliteSaver: A new AsyncSqliteSaver instance.
         """
         async with aiosqlite.connect(conn_string) as conn:
-            yield cls(conn)
+            yield AsyncSqliteSaver(conn)
 
     def get_tuple(self, config: RunnableConfig) -> Optional[CheckpointTuple]:
         """Get a checkpoint tuple from the database.

libs/checkpoint/Makefile

@@ -4,13 +4,11 @@
 # TESTING AND COVERAGE
 ######################
 
-TEST ?= .
-
 test:
-	poetry run pytest $(TEST)
+	poetry run pytest tests
 
 test_watch:
-	poetry run ptw $(TEST)
+	poetry run ptw .
 
 ######################
 # LINTING AND FORMATTING

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

@@ -1,27 +1,12 @@
 """Base classes and types for persistent key-value stores.
 
-Stores provide long-term memory that persists across threads and conversations.
-Supports hierarchical namespaces, key-value storage, and optional vector search.
-
-Core types:
-    - BaseStore: Store interface with sync/async operations
-    - Item: Stored key-value pairs with metadata
-    - Op: Get/Put/Search/List operations
+Stores enable persistence and memory that can be shared across threads,
+scoped to user IDs, assistant IDs, or other arbitrary namespaces.
 """
 
 from abc import ABC, abstractmethod
 from datetime import datetime
-from typing import Any, Iterable, Literal, NamedTuple, Optional, TypedDict, Union, cast
-
-from langchain_core.embeddings import Embeddings
-
-from langgraph.store.base.embed import (
-    AEmbeddingsFunc,
-    EmbeddingsFunc,
-    ensure_embeddings,
-    get_text_at_path,
-    tokenize_path,
-)
+from typing import Any, Iterable, Literal, NamedTuple, Optional, Union, cast
 
 
 class Item:
@@ -88,510 +73,112 @@ class Item:
         }
 
 
-class SearchItem(Item):
-    """Represents an item returned from a search operation with additional metadata."""
-
-    __slots__ = ("score",)
-
-    def __init__(
-        self,
-        namespace: tuple[str, ...],
-        key: str,
-        value: dict[str, Any],
-        created_at: datetime,
-        updated_at: datetime,
-        score: Optional[float] = None,
-    ) -> None:
-        """Initialize a result item.
-
-        Args:
-            namespace: Hierarchical path to the item.
-            key: Unique identifier within the namespace.
-            value: The stored value.
-            created_at: When the item was first created.
-            updated_at: When the item was last updated.
-            score: Relevance/similarity score if from a ranked operation.
-        """
-        super().__init__(
-            value=value,
-            key=key,
-            namespace=namespace,
-            created_at=created_at,
-            updated_at=updated_at,
-        )
-        self.score = score
-
-    def dict(self) -> dict:
-        result = super().dict()
-        result["score"] = self.score
-        return result
-
-
 class GetOp(NamedTuple):
-    """Operation to retrieve a specific item by its namespace and key.
-
-    This operation allows precise retrieval of stored items using their full path
-    (namespace) and unique identifier (key) combination.
-
-    ???+ example "Examples"
-
-        Basic item retrieval:
-        ```python
-        GetOp(namespace=("users", "profiles"), key="user123")
-        GetOp(namespace=("cache", "embeddings"), key="doc456")
-        ```
-    """
+    """Operation to retrieve an item by namespace and key."""
 
     namespace: tuple[str, ...]
-    """Hierarchical path that uniquely identifies the item's location.
-
-    ???+ example "Examples"
-
-        ```python
-        ("users",)  # Root level users namespace
-        ("users", "profiles")  # Profiles within users namespace
-        ```
-    """
-
+    """Hierarchical path for the item."""
     key: str
-    """Unique identifier for the item within its specific namespace.
-
-    ???+ example "Examples"
-
-        ```python
-        "user123"  # For a user profile
-        "doc456"  # For a document
-        ```
-    """
+    """Unique identifier within the namespace."""
 
 
 class SearchOp(NamedTuple):
-    """Operation to search for items within a specified namespace hierarchy.
-
-    This operation supports both structured filtering and natural language search
-    within a given namespace prefix. It provides pagination through limit and offset
-    parameters.
-
-    Note:
-        Natural language search support depends on your store implementation.
-
-    ???+ example "Examples"
-        Search with filters and pagination:
-        ```python
-        SearchOp(
-            namespace_prefix=("documents",),
-            filter={"type": "report", "status": "active"},
-            limit=5,
-            offset=10
-        )
-        ```
-
-        Natural language search:
-        ```python
-        SearchOp(
-            namespace_prefix=("users", "content"),
-            query="technical documentation about APIs",
-            limit=20
-        )
-        ```
-    """
+    """Operation to search for items within a namespace prefix."""
 
     namespace_prefix: tuple[str, ...]
-    """Hierarchical path prefix defining the search scope.
-
-    ???+ example "Examples"
-
-        ```python
-        ()  # Search entire store
-        ("documents",)  # Search all documents
-        ("users", "content")  # Search within user content
-        ```
-    """
-
+    """Hierarchical path prefix to search within."""
     filter: Optional[dict[str, Any]] = None
-    """Key-value pairs for filtering results based on exact matches or comparison operators.
-
-    The filter supports both exact matches and operator-based comparisons.
-
-    Supported Operators:
-        - $eq: Equal to (same as direct value comparison)
-        - $ne: Not equal to
-        - $gt: Greater than
-        - $gte: Greater than or equal to
-        - $lt: Less than
-        - $lte: Less than or equal to
-
-    ???+ example "Examples"
-        Simple exact match:
-
-        ```python
-        {"status": "active"}
-        ```
-
-        Comparison operators:
-
-        ```python
-        {"score": {"$gt": 4.99}}  # Score greater than 4.99
-        ```
-
-        Multiple conditions:
-
-        ```python
-        {
-            "score": {"$gte": 3.0},
-            "color": "red"
-        }
-        ```
-    """
-
+    """Key-value pairs to filter results."""
     limit: int = 10
-    """Maximum number of items to return in the search results."""
-
+    """Maximum number of items to return."""
     offset: int = 0
-    """Number of matching items to skip for pagination."""
+    """Number of items to skip before returning results."""
 
-    query: Optional[str] = None
-    """Natural language search query for semantic search capabilities.
 
-    ???+ example "Examples"
-        - "technical documentation about REST APIs"
-        - "machine learning papers from 2023"
+class PutOp(NamedTuple):
+    """Operation to store, update, or delete an item."""
+
+    namespace: tuple[str, ...]
+    """Hierarchical path for the item.
+    
+    Represented as a tuple of strings, allowing for nested categorization.
+    For example: ("documents", "user123")
+    """
+
+    key: str
+    """Unique identifier for the document.
+    
+    Should be distinct within its namespace.
+    """
+
+    value: Optional[dict[str, Any]]
+    """Data to be stored, or None to delete the item.
+    
+    Schema:
+    - Should be a dictionary where:
+      - Keys are strings representing field names
+      - Values can be of any serializable type
+    - If None, it indicates that the item should be deleted
     """
 
 
-# Type representing a namespace path that can include wildcards
-NamespacePath = tuple[Union[str, Literal["*"]], ...]
-"""A tuple representing a namespace path that can include wildcards.
+NameSpacePath = tuple[Union[str, Literal["*"]], ...]
 
-???+ example "Examples"
-    ```python
-    ("users",)  # Exact users namespace
-    ("documents", "*")  # Any sub-namespace under documents
-    ("cache", "*", "v1")  # Any cache category with v1 version
-    ```
-"""
-
-# Type for specifying how to match namespaces
 NamespaceMatchType = Literal["prefix", "suffix"]
-"""Specifies how to match namespace paths.
-
-Values:
-    "prefix": Match from the start of the namespace
-    "suffix": Match from the end of the namespace
-"""
 
 
 class MatchCondition(NamedTuple):
-    """Represents a pattern for matching namespaces in the store.
-
-    This class combines a match type (prefix or suffix) with a namespace path
-    pattern that can include wildcards to flexibly match different namespace
-    hierarchies.
-
-    ???+ example "Examples"
-        Prefix matching:
-        ```python
-        MatchCondition(match_type="prefix", path=("users", "profiles"))
-        ```
-
-        Suffix matching with wildcard:
-        ```python
-        MatchCondition(match_type="suffix", path=("cache", "*"))
-        ```
-
-        Simple suffix matching:
-        ```python
-        MatchCondition(match_type="suffix", path=("v1",))
-        ```
-    """
+    """Represents a single match condition."""
 
     match_type: NamespaceMatchType
-    """Type of namespace matching to perform."""
-
-    path: NamespacePath
-    """Namespace path pattern that can include wildcards."""
+    path: NameSpacePath
 
 
 class ListNamespacesOp(NamedTuple):
-    """Operation to list and filter namespaces in the store.
-
-    This operation allows exploring the organization of data, finding specific
-    collections, and navigating the namespace hierarchy.
-
-    ???+ example "Examples"
-
-        List all namespaces under the "documents" path:
-        ```python
-        ListNamespacesOp(
-            match_conditions=(MatchCondition(match_type="prefix", path=("documents",)),),
-            max_depth=2
-        )
-        ```
-
-        List all namespaces that end with "v1":
-        ```python
-        ListNamespacesOp(
-            match_conditions=(MatchCondition(match_type="suffix", path=("v1",)),),
-            limit=50
-        )
-        ```
-
-    """
+    """Operation to list namespaces with optional match conditions."""
 
     match_conditions: Optional[tuple[MatchCondition, ...]] = None
-    """Optional conditions for filtering namespaces.
-
-    ???+ example "Examples"
-        All user namespaces:
-        ```python
-        (MatchCondition(match_type="prefix", path=("users",)),)
-        ```
-
-        All namespaces that start with "docs" and end with "draft":
-        ```python
-        (
-            MatchCondition(match_type="prefix", path=("docs",)),
-            MatchCondition(match_type="suffix", path=("draft",))
-        ) 
-        ```
-    """
+    """A tuple of match conditions to apply to namespaces."""
 
     max_depth: Optional[int] = None
-    """Maximum depth of namespace hierarchy to return.
-
-    Note:
-        Namespaces deeper than this level will be truncated.
-    """
+    """Return namespaces up to this depth in the hierarchy."""
 
     limit: int = 100
     """Maximum number of namespaces to return."""
 
     offset: int = 0
-    """Number of namespaces to skip for pagination."""
-
-
-class PutOp(NamedTuple):
-    """Operation to store, update, or delete an item in the store.
-
-    This class represents a single operation to modify the store's contents,
-    whether adding new items, updating existing ones, or removing them.
-    """
-
-    namespace: tuple[str, ...]
-    """Hierarchical path that identifies the location of the item.
-
-    The namespace acts as a folder-like structure to organize items.
-    Each element in the tuple represents one level in the hierarchy.
-
-    ???+ example "Examples"
-        Root level documents
-        ```python
-        ("documents",)
-        ```
-        
-        User-specific documents
-        ```python
-        ("documents", "user123")
-        ```
-        
-        Nested cache structure
-        ```python
-        ("cache", "embeddings", "v1")
-        ```
-    """
-
-    key: str
-    """Unique identifier for the item within its namespace.
-
-    The key must be unique within the specific namespace to avoid conflicts.
-    Together with the namespace, it forms a complete path to the item.
-
-    Example:
-        If namespace is ("documents", "user123") and key is "report1",
-        the full path would effectively be "documents/user123/report1"
-    """
-
-    value: Optional[dict[str, Any]]
-    """The data to store, or None to mark the item for deletion.
-
-    The value must be a dictionary with string keys and JSON-serializable values.
-    Setting this to None signals that the item should be deleted.
-
-    Example:
-        {
-            "field1": "string value",
-            "field2": 123,
-            "nested": {"can": "contain", "any": "serializable data"}
-        }
-    """
-
-    index: Optional[Union[Literal[False], list[str]]] = None  # type: ignore[assignment]
-    """Controls how the item's fields are indexed for search operations.
-
-    Indexing configuration determines how the item can be found through search:
-        - None (default): Uses the store's default indexing configuration (if provided)
-        - False: Disables indexing for this item
-        - list[str]: Specifies which json path fields to index for search
-
-    The item remains accessible through direct get() operations regardless of indexing.
-    When indexed, fields can be searched using natural language queries through
-    vector similarity search (if supported by the store implementation).
-
-    Path Syntax:
-        - Simple field access: "field"
-        - Nested fields: "parent.child.grandchild"
-        - Array indexing:
-          - Specific index: "array[0]"
-          - Last element: "array[-1]"
-          - All elements (each individually): "array[*]"
-
-    ???+ example "Examples"
-        - None - Use store defaults (whole item)
-        - list[str] - List of fields to index
-        
-        ```python
-        [
-            "metadata.title",                    # Nested field access
-            "context[*].content",                # Index content from all context as separate vectors
-            "authors[0].name",                   # First author's name
-            "revisions[-1].changes",             # Most recent revision's changes
-            "sections[*].paragraphs[*].text",    # All text from all paragraphs in all sections
-            "metadata.tags[*]",                  # All tags in metadata
-        ]
-        ```
-    """
+    """Number of namespaces to skip before returning results."""
 
 
 Op = Union[GetOp, SearchOp, PutOp, ListNamespacesOp]
-Result = Union[Item, list[Item], list[SearchItem], list[tuple[str, ...]], None]
+Result = Union[Item, list[Item], list[tuple[str, ...]], None]
 
 
 class InvalidNamespaceError(ValueError):
     """Provided namespace is invalid."""
 
 
-class IndexConfig(TypedDict, total=False):
-    """Configuration for indexing documents for semantic search in the store.
-
-    If not provided to the store, the store will not support vector search.
-    In that case, all `index` arguments to put() and `aput()` operations will be ignored.
-    """
-
-    dims: int
-    """Number of dimensions in the embedding vectors.
-    
-    Common embedding models have the following dimensions:
-        - openai:text-embedding-3-large: 3072
-        - openai:text-embedding-3-small: 1536
-        - openai:text-embedding-ada-002: 1536
-        - cohere:embed-english-v3.0: 1024
-        - cohere:embed-english-light-v3.0: 384
-        - cohere:embed-multilingual-v3.0: 1024
-        - cohere:embed-multilingual-light-v3.0: 384
-    """
-
-    embed: Union[Embeddings, EmbeddingsFunc, AEmbeddingsFunc]
-    """Optional function to generate embeddings from text.
-    
-    Can be specified in three ways:
-        1. A LangChain Embeddings instance
-        2. A synchronous embedding function (EmbeddingsFunc)
-        3. An asynchronous embedding function (AEmbeddingsFunc)
-    
-    ???+ example "Examples"
-        Using LangChain's initialization with InMemoryStore:
-        ```python
-        from langchain.embeddings import init_embeddings
-        from langgraph.store.memory import InMemoryStore
-        
-        store = InMemoryStore(
-            index={
-                "dims": 1536,
-                "embed": init_embeddings("openai:text-embedding-3-small")
-            }
-        )
-        ```
-        
-        Using a custom embedding function with InMemoryStore:
-        ```python
-        from openai import OpenAI
-        from langgraph.store.memory import InMemoryStore
-        
-        client = OpenAI()
-        
-        def embed_texts(texts: list[str]) -> list[list[float]]:
-            response = client.embeddings.create(
-                model="text-embedding-3-small",
-                input=texts
+def _validate_namespace(namespace: tuple[str, ...]) -> None:
+    if not namespace:
+        raise InvalidNamespaceError("Namespace cannot be empty.")
+    for label in namespace:
+        if not isinstance(label, str):
+            raise InvalidNamespaceError(
+                f"Invalid namespace label '{label}' found in {namespace}. Namespace labels"
+                f" must be strings, but got {type(label).__name__}."
             )
-            return [e.embedding for e in response.data]
-            
-        store = InMemoryStore(
-            index={
-                "dims": 1536,
-                "embed": embed_texts
-            }
-        )
-        ```
-        
-        Using an asynchronous embedding function with InMemoryStore:
-        ```python
-        from openai import AsyncOpenAI
-        from langgraph.store.memory import InMemoryStore
-        
-        client = AsyncOpenAI()
-        
-        async def aembed_texts(texts: list[str]) -> list[list[float]]:
-            response = await client.embeddings.create(
-                model="text-embedding-3-small",
-                input=texts
+        if "." in label:
+            raise InvalidNamespaceError(
+                f"Invalid namespace label '{label}' found in {namespace}. Namespace labels cannot contain periods ('.')."
             )
-            return [e.embedding for e in response.data]
-            
-        store = InMemoryStore(
-            index={
-                "dims": 1536,
-                "embed": aembed_texts
-            }
+        elif not label:
+            raise InvalidNamespaceError(
+                f"Namespace labels cannot be empty strings. Got {label} in {namespace}"
+            )
+    if namespace[0] == "langgraph":
+        raise InvalidNamespaceError(
+            f'Root label for namespace cannot be "langgraph". Got: {namespace}'
         )
-        ```
-    """
-
-    fields: Optional[list[str]]
-    """Fields to extract text from for embedding generation.
-    
-    Controls which parts of stored items are embedded for semantic search. Follows JSON path syntax:
-
-        - ["$"]: Embeds the entire JSON object as one vector  (default)
-        - ["field1", "field2"]: Embeds specific top-level fields
-        - ["parent.child"]: Embeds nested fields using dot notation
-        - ["array[*].field"]: Embeds field from each array element separately
-    
-    Note:
-        You can always override this behavior when storing an item using the
-        `index` parameter in the `put` or `aput` operations.
-    
-    ???+ example "Examples"
-        ```python
-        # Embed entire document (default)
-        fields=["$"]
-        
-        # Embed specific fields
-        fields=["text", "summary"]
-        
-        # Embed nested fields
-        fields=["metadata.title", "content.body"]
-        
-        # Embed from arrays
-        fields=["messages[*].content"]  # Each message content separately
-        fields=["context[0].text"]      # First context item's text
-        ```
-    
-    Note:
-        - Fields missing from a document are skipped
-        - Array notation creates separate embeddings for each element
-        - Complex nested paths are supported (e.g., "a.b[*].c.d")
-    """
 
 
 class BaseStore(ABC):
@@ -599,15 +186,6 @@ class BaseStore(ABC):
 
     Stores enable persistence and memory that can be shared across threads,
     scoped to user IDs, assistant IDs, or other arbitrary namespaces.
-    Some implementations may support semantic search capabilities through
-    an optional `index` configuration.
-
-    Note:
-        Semantic search capabilities vary by implementation and are typically
-        disabled by default. Stores that support this feature can be configured
-        by providing an `index` configuration at creation time. Without this
-        configuration, semantic search is disabled and any `index` arguments
-        to storage operations will have no effect.
     """
 
     __slots__ = ("__weakref__",)
@@ -653,109 +231,33 @@ class BaseStore(ABC):
         namespace_prefix: tuple[str, ...],
         /,
         *,
-        query: Optional[str] = None,
         filter: Optional[dict[str, Any]] = None,
         limit: int = 10,
         offset: int = 0,
-    ) -> list[SearchItem]:
+    ) -> list[Item]:
         """Search for items within a namespace prefix.
 
         Args:
             namespace_prefix: Hierarchical path prefix to search within.
-            query: Optional query for natural language search.
             filter: Key-value pairs to filter results.
             limit: Maximum number of items to return.
             offset: Number of items to skip before returning results.
 
         Returns:
             List of items matching the search criteria.
-
-        ???+ example "Examples"
-            Basic filtering:
-            ```python
-            # Search for documents with specific metadata
-            results = store.search(
-                ("docs",),
-                filter={"type": "article", "status": "published"}
-            )
-            ```
-
-            Natural language search (requires vector store implementation):
-            ```python
-            # Initialize store with embedding configuration
-            store = YourStore( # e.g., InMemoryStore, AsyncPostgresStore
-                index={
-                    "dims": 1536,  # embedding dimensions
-                    "embed": your_embedding_function,  # function to create embeddings
-                    "fields": ["text"]  # fields to embed. Defaults to ["$"]
-                }
-            )
-
-            # Search for semantically similar documents
-            results = store.search(
-                ("docs",),
-                query="machine learning applications in healthcare",
-                filter={"type": "research_paper"},
-                limit=5
-            )
-            ```
-
-            Note: Natural language search support depends on your store implementation
-            and requires proper embedding configuration.
         """
-        return self.batch([SearchOp(namespace_prefix, filter, limit, offset, query)])[0]
+        return self.batch([SearchOp(namespace_prefix, filter, limit, offset)])[0]
 
-    def put(
-        self,
-        namespace: tuple[str, ...],
-        key: str,
-        value: dict[str, Any],
-        index: Optional[Union[Literal[False], list[str]]] = None,
-    ) -> None:
-        """Store or update an item in the store.
+    def put(self, namespace: tuple[str, ...], key: str, value: dict[str, Any]) -> None:
+        """Store or update an item.
 
         Args:
-            namespace: Hierarchical path for the item, represented as a tuple of strings.
-                Example: ("documents", "user123")
-            key: Unique identifier within the namespace. Together with namespace forms
-                the complete path to the item.
-            value: Dictionary containing the item's data. Must contain string keys
-                and JSON-serializable values.
-            index: Controls how the item's fields are indexed for search:
-
-                - None (default): Use `fields` you configured when creating the store (if any)
-                    If you do not initialize the store with indexing capabilities,
-                    the `index` parameter will be ignored
-                - False: Disable indexing for this item
-                - list[str]: List of field paths to index, supporting:
-                    - Nested fields: "metadata.title"
-                    - Array access: "chapters[*].content" (each indexed separately)
-                    - Specific indices: "authors[0].name"
-
-        Note:
-            Indexing support depends on your store implementation.
-            If you do not initialize the store with indexing capabilities,
-            the `index` parameter will be ignored.
-
-        ???+ example "Examples"
-            Store item. Indexing depends on how you configure the store.
-            ```python
-            store.put(("docs",), "report", {"memory": "Will likes ai"})
-            ```
-
-            Do not index item for semantic search. Still accessible through get()
-            and search() operations but won't have a vector representation.
-            ```python
-            store.put(("docs",), "report", {"memory": "Will likes ai"}, index=False)
-            ```
-
-            Index specific fields for search.
-            ```python
-            store.put(("docs",), "report", {"memory": "Will likes ai"}, index=["memory"])
-            ```
+            namespace: Hierarchical path for the item.
+            key: Unique identifier within the namespace.
+            value: Dictionary containing the item's data.
         """
         _validate_namespace(namespace)
-        self.batch([PutOp(namespace, key, value, index=index)])
+        self.batch([PutOp(namespace, key, value)])
 
     def delete(self, namespace: tuple[str, ...], key: str) -> None:
         """Delete an item.
@@ -769,8 +271,8 @@ class BaseStore(ABC):
     def list_namespaces(
         self,
         *,
-        prefix: Optional[NamespacePath] = None,
-        suffix: Optional[NamespacePath] = None,
+        prefix: Optional[NameSpacePath] = None,
+        suffix: Optional[NameSpacePath] = None,
         max_depth: Optional[int] = None,
         limit: int = 100,
         offset: int = 0,
@@ -784,7 +286,7 @@ class BaseStore(ABC):
             prefix (Optional[Tuple[str, ...]]): Filter namespaces that start with this path.
             suffix (Optional[Tuple[str, ...]]): Filter namespaces that end with this path.
             max_depth (Optional[int]): Return namespaces up to this depth in the hierarchy.
-                Namespaces deeper than this level will be truncated.
+                Namespaces deeper than this level will be truncated to this depth.
             limit (int): Maximum number of namespaces to return (default 100).
             offset (int): Number of namespaces to skip for pagination (default 0).
 
@@ -792,18 +294,16 @@ class BaseStore(ABC):
             List[Tuple[str, ...]]: A list of namespace tuples that match the criteria.
             Each tuple represents a full namespace path up to `max_depth`.
 
-        ???+ example "Examples":
+        Examples:
+
             Setting max_depth=3. Given the namespaces:
-            ```python
-            # Example if you have the following namespaces:
-            # ("a", "b", "c")
-            # ("a", "b", "d", "e")
-            # ("a", "b", "d", "i")
-            # ("a", "b", "f")
-            # ("a", "c", "f")
-            store.list_namespaces(prefix=("a", "b"), max_depth=3)
-            # [("a", "b", "c"), ("a", "b", "d"), ("a", "b", "f")]
-            ```
+                # ("a", "b", "c")
+                # ("a", "b", "d", "e")
+                # ("a", "b", "d", "i")
+                # ("a", "b", "f")
+                # ("a", "c", "f")
+                store.list_namespaces(prefix=("a", "b"), max_depth=3)
+                # [("a", "b", "c"), ("a", "b", "d"), ("a", "b", "f")]
         """
         match_conditions = []
         if prefix:
@@ -836,121 +336,37 @@ class BaseStore(ABC):
         namespace_prefix: tuple[str, ...],
         /,
         *,
-        query: Optional[str] = None,
         filter: Optional[dict[str, Any]] = None,
         limit: int = 10,
         offset: int = 0,
-    ) -> list[SearchItem]:
+    ) -> list[Item]:
         """Asynchronously search for items within a namespace prefix.
 
         Args:
             namespace_prefix: Hierarchical path prefix to search within.
-            query: Optional query for natural language search.
             filter: Key-value pairs to filter results.
             limit: Maximum number of items to return.
             offset: Number of items to skip before returning results.
 
         Returns:
             List of items matching the search criteria.
-
-        ???+ example "Examples"
-            Basic filtering:
-            ```python
-            # Search for documents with specific metadata
-            results = await store.asearch(
-                ("docs",),
-                filter={"type": "article", "status": "published"}
-            )
-            ```
-
-            Natural language search (requires vector store implementation):
-            ```python
-            # Initialize store with embedding configuration
-            store = YourStore( # e.g., InMemoryStore, AsyncPostgresStore
-                index={
-                    "dims": 1536,  # embedding dimensions
-                    "embed": your_embedding_function,  # function to create embeddings
-                    "fields": ["text"]  # fields to embed
-                }
-            )
-
-            # Search for semantically similar documents
-            results = await store.asearch(
-                ("docs",),
-                query="machine learning applications in healthcare",
-                filter={"type": "research_paper"},
-                limit=5
-            )
-            ```
-
-            Note: Natural language search support depends on your store implementation
-            and requires proper embedding configuration.
         """
-        return (
-            await self.abatch(
-                [SearchOp(namespace_prefix, filter, limit, offset, query)]
-            )
-        )[0]
+        return (await self.abatch([SearchOp(namespace_prefix, filter, limit, offset)]))[
+            0
+        ]
 
     async def aput(
-        self,
-        namespace: tuple[str, ...],
-        key: str,
-        value: dict[str, Any],
-        index: Optional[Union[Literal[False], list[str]]] = None,
+        self, namespace: tuple[str, ...], key: str, value: dict[str, Any]
     ) -> None:
-        """Asynchronously store or update an item in the store.
+        """Asynchronously store or update an item.
 
         Args:
-            namespace: Hierarchical path for the item, represented as a tuple of strings.
-                Example: ("documents", "user123")
-            key: Unique identifier within the namespace. Together with namespace forms
-                the complete path to the item.
-            value: Dictionary containing the item's data. Must contain string keys
-                and JSON-serializable values.
-            index: Controls how the item's fields are indexed for search:
-
-                - None (default): Use `fields` you configured when creating the store (if any)
-                    If you do not initialize the store with indexing capabilities,
-                    the `index` parameter will be ignored
-                - False: Disable indexing for this item
-                - list[str]: List of field paths to index, supporting:
-                    - Nested fields: "metadata.title"
-                    - Array access: "chapters[*].content" (each indexed separately)
-                    - Specific indices: "authors[0].name"
-
-        Note:
-            Indexing support depends on your store implementation.
-            If you do not initialize the store with indexing capabilities,
-            the `index` parameter will be ignored.
-
-        ???+ example "Examples"
-            Store item. Indexing depends on how you configure the store.
-            ```python
-            await store.aput(("docs",), "report", {"memory": "Will likes ai"})
-            ```
-
-            Do not index item for semantic search. Still accessible through get()
-            and search() operations but won't have a vector representation.
-            ```python
-            await store.aput(("docs",), "report", {"memory": "Will likes ai"}, index=False)
-            ```
-
-            Index specific fields for search (if store configured to index items):
-            ```python
-            await store.aput(
-                ("docs",),
-                "report",
-                {
-                    "memory": "Will likes ai",
-                    "context": [{"content": "..."}, {"content": "..."}]
-                },
-                index=["memory", "context[*].content"]
-            )
-            ```
+            namespace: Hierarchical path for the item.
+            key: Unique identifier within the namespace.
+            value: Dictionary containing the item's data.
         """
         _validate_namespace(namespace)
-        await self.abatch([PutOp(namespace, key, value, index=index)])
+        await self.abatch([PutOp(namespace, key, value)])
 
     async def adelete(self, namespace: tuple[str, ...], key: str) -> None:
         """Asynchronously delete an item.
@@ -964,8 +380,8 @@ class BaseStore(ABC):
     async def alist_namespaces(
         self,
         *,
-        prefix: Optional[NamespacePath] = None,
-        suffix: Optional[NamespacePath] = None,
+        prefix: Optional[NameSpacePath] = None,
+        suffix: Optional[NameSpacePath] = None,
         max_depth: Optional[int] = None,
         limit: int = 100,
         offset: int = 0,
@@ -987,19 +403,16 @@ class BaseStore(ABC):
             List[Tuple[str, ...]]: A list of namespace tuples that match the criteria.
             Each tuple represents a full namespace path up to `max_depth`.
 
-        ???+ example "Examples"
-            Setting max_depth=3 with existing namespaces:
-            ```python
-            # Given the following namespaces:
-            # ("a", "b", "c")
-            # ("a", "b", "d", "e")
-            # ("a", "b", "d", "i")
-            # ("a", "b", "f")
-            # ("a", "c", "f")
+        Examples:
 
-            await store.alist_namespaces(prefix=("a", "b"), max_depth=3)
-            # Returns: [("a", "b", "c"), ("a", "b", "d"), ("a", "b", "f")]
-            ```
+            Setting max_depth=3. Given the namespaces:
+                # ("a", "b", "c")
+                # ("a", "b", "d", "e")
+                # ("a", "b", "d", "i")
+                # ("a", "b", "f")
+                # ("a", "c", "f")
+                await store.alist_namespaces(prefix=("a", "b"), max_depth=3)
+                # [("a", "b", "c"), ("a", "b", "d"), ("a", "b", "f")]
         """
         match_conditions = []
         if prefix:
@@ -1014,44 +427,3 @@ class BaseStore(ABC):
             offset=offset,
         )
         return (await self.abatch([op]))[0]
-
-
-def _validate_namespace(namespace: tuple[str, ...]) -> None:
-    if not namespace:
-        raise InvalidNamespaceError("Namespace cannot be empty.")
-    for label in namespace:
-        if not isinstance(label, str):
-            raise InvalidNamespaceError(
-                f"Invalid namespace label '{label}' found in {namespace}. Namespace labels"
-                f" must be strings, but got {type(label).__name__}."
-            )
-        if "." in label:
-            raise InvalidNamespaceError(
-                f"Invalid namespace label '{label}' found in {namespace}. Namespace labels cannot contain periods ('.')."
-            )
-        elif not label:
-            raise InvalidNamespaceError(
-                f"Namespace labels cannot be empty strings. Got {label} in {namespace}"
-            )
-    if namespace[0] == "langgraph":
-        raise InvalidNamespaceError(
-            f'Root label for namespace cannot be "langgraph". Got: {namespace}'
-        )
-
-
-__all__ = [
-    "BaseStore",
-    "Item",
-    "Op",
-    "PutOp",
-    "GetOp",
-    "SearchOp",
-    "ListNamespacesOp",
-    "MatchCondition",
-    "NamespacePath",
-    "NamespaceMatchType",
-    "Embeddings",
-    "ensure_embeddings",
-    "tokenize_path",
-    "get_text_at_path",
-]

libs/checkpoint/langgraph/store/base/batch.py

@@ -1,17 +1,13 @@
 import asyncio
 import weakref
-from typing import Any, Literal, Optional, Union
+from typing import Any, Optional
 
 from langgraph.store.base import (
     BaseStore,
     GetOp,
     Item,
-    ListNamespacesOp,
-    MatchCondition,
-    NamespacePath,
     Op,
     PutOp,
-    SearchItem,
     SearchOp,
     _validate_namespace,
 )
@@ -44,13 +40,12 @@ class AsyncBatchedBaseStore(BaseStore):
         namespace_prefix: tuple[str, ...],
         /,
         *,
-        query: Optional[str] = None,
         filter: Optional[dict[str, Any]] = None,
         limit: int = 10,
         offset: int = 0,
-    ) -> list[SearchItem]:
+    ) -> list[Item]:
         fut = self._loop.create_future()
-        self._aqueue[fut] = SearchOp(namespace_prefix, filter, limit, offset, query)
+        self._aqueue[fut] = SearchOp(namespace_prefix, filter, limit, offset)
         return await fut
 
     async def aput(
@@ -58,11 +53,10 @@ class AsyncBatchedBaseStore(BaseStore):
         namespace: tuple[str, ...],
         key: str,
         value: dict[str, Any],
-        index: Optional[Union[Literal[False], list[str]]] = None,
     ) -> None:
         _validate_namespace(namespace)
         fut = self._loop.create_future()
-        self._aqueue[fut] = PutOp(namespace, key, value, index)
+        self._aqueue[fut] = PutOp(namespace, key, value)
         return await fut
 
     async def adelete(
@@ -74,74 +68,6 @@ class AsyncBatchedBaseStore(BaseStore):
         self._aqueue[fut] = PutOp(namespace, key, None)
         return await fut
 
-    async def alist_namespaces(
-        self,
-        *,
-        prefix: Optional[NamespacePath] = None,
-        suffix: Optional[NamespacePath] = None,
-        max_depth: Optional[int] = None,
-        limit: int = 100,
-        offset: int = 0,
-    ) -> list[tuple[str, ...]]:
-        fut = self._loop.create_future()
-        match_conditions = []
-        if prefix:
-            match_conditions.append(MatchCondition(match_type="prefix", path=prefix))
-        if suffix:
-            match_conditions.append(MatchCondition(match_type="suffix", path=suffix))
-
-        op = ListNamespacesOp(
-            match_conditions=tuple(match_conditions),
-            max_depth=max_depth,
-            limit=limit,
-            offset=offset,
-        )
-        self._aqueue[fut] = op
-        return await fut
-
-
-def _dedupe_ops(values: list[Op]) -> tuple[Optional[list[int]], list[Op]]:
-    """Dedupe operations while preserving order for results.
-
-    Args:
-        values: List of operations to dedupe
-
-    Returns:
-        Tuple of (listen indices, deduped operations)
-        where listen indices map deduped operation results back to original positions
-    """
-    if len(values) <= 1:
-        return None, list(values)
-
-    dedupped: list[Op] = []
-    listen: list[int] = []
-    puts: dict[tuple[tuple[str, ...], str], int] = {}
-
-    for op in values:
-        if isinstance(op, (GetOp, SearchOp, ListNamespacesOp)):
-            try:
-                listen.append(dedupped.index(op))
-            except ValueError:
-                listen.append(len(dedupped))
-                dedupped.append(op)
-        elif isinstance(op, PutOp):
-            putkey = (op.namespace, op.key)
-            if putkey in puts:
-                # Overwrite previous put
-                ix = puts[putkey]
-                dedupped[ix] = op
-                listen.append(ix)
-            else:
-                puts[putkey] = len(dedupped)
-                listen.append(len(dedupped))
-                dedupped.append(op)
-
-        else:  # Any new ops will be treated regularly
-            listen.append(len(dedupped))
-            dedupped.append(op)
-
-    return listen, dedupped
-
 
 async def _run(
     aqueue: dict[asyncio.Future, Op], store: weakref.ReferenceType[BaseStore]
@@ -155,12 +81,7 @@ async def _run(
             taken = aqueue.copy()
             # action each operation
             try:
-                values = list(taken.values())
-                listen, dedupped = _dedupe_ops(values)
-                results = await s.abatch(dedupped)
-                if listen is not None:
-                    results = [results[ix] for ix in listen]
-
+                results = await s.abatch(taken.values())
                 # set the results of each operation
                 for fut, result in zip(taken, results):
                     fut.set_result(result)

libs/checkpoint/langgraph/store/base/embed.py

@@ -1,380 +0,0 @@
-"""Utilities for working with embedding functions and LangChain's Embeddings interface.
-
-This module provides tools to wrap arbitrary embedding functions (both sync and async)
-into LangChain's Embeddings interface. This enables using custom embedding functions
-with LangChain-compatible tools while maintaining support for both synchronous and
-asynchronous operations.
-"""
-
-import asyncio
-import json
-from typing import Any, Awaitable, Callable, Optional, Sequence, Union
-
-from langchain_core.embeddings import Embeddings
-
-EmbeddingsFunc = Callable[[Sequence[str]], list[list[float]]]
-"""Type for synchronous embedding functions.
-
-The function should take a sequence of strings and return a list of embeddings,
-where each embedding is a list of floats. The dimensionality of the embeddings
-should be consistent for all inputs.
-"""
-
-AEmbeddingsFunc = Callable[[Sequence[str]], Awaitable[list[list[float]]]]
-"""Type for asynchronous embedding functions.
-
-Similar to EmbeddingsFunc, but returns an awaitable that resolves to the embeddings.
-"""
-
-
-def ensure_embeddings(
-    embed: Union[Embeddings, EmbeddingsFunc, AEmbeddingsFunc, None],
-) -> Embeddings:
-    """Ensure that an embedding function conforms to LangChain's Embeddings interface.
-
-    This function wraps arbitrary embedding functions to make them compatible with
-    LangChain's Embeddings interface. It handles both synchronous and asynchronous
-    functions.
-
-    Args:
-        embed: Either an existing Embeddings instance, or a function that converts
-            text to embeddings. If the function is async, it will be used for both
-            sync and async operations.
-
-    Returns:
-        An Embeddings instance that wraps the provided function(s).
-
-    ??? example "Examples"
-        Wrap a synchronous embedding function:
-        ```python
-        def my_embed_fn(texts):
-            return [[0.1, 0.2] for _ in texts]
-
-        embeddings = ensure_embeddings(my_embed_fn)
-        result = embeddings.embed_query("hello")  # Returns [0.1, 0.2]
-        ```
-
-        Wrap an asynchronous embedding function:
-        ```python
-        async def my_async_fn(texts):
-            return [[0.1, 0.2] for _ in texts]
-
-        embeddings = ensure_embeddings(my_async_fn)
-        result = await embeddings.aembed_query("hello")  # Returns [0.1, 0.2]
-        ```
-    """
-    if embed is None:
-        raise ValueError("embed must be provided")
-    if isinstance(embed, Embeddings):
-        return embed
-    return EmbeddingsLambda(embed)
-
-
-class EmbeddingsLambda(Embeddings):
-    """Wrapper to convert embedding functions into LangChain's Embeddings interface.
-
-    This class allows arbitrary embedding functions to be used with LangChain-compatible
-    tools. It supports both synchronous and asynchronous operations, and can handle:
-    1. A synchronous function for sync operations (async operations will use sync function)
-    2. An async function for both sync/async operations (sync operations will raise an error)
-
-    The embedding functions should convert text into fixed-dimensional vectors that
-    capture the semantic meaning of the text.
-
-    Args:
-        func: Function that converts text to embeddings. Can be sync or async.
-            If async, it will be used for async operations, but sync operations
-            will raise an error. If sync, it will be used for both sync and async operations.
-
-    ??? example "Examples"
-        With a sync function:
-        ```python
-        def my_embed_fn(texts):
-            # Return 2D embeddings for each text
-            return [[0.1, 0.2] for _ in texts]
-
-        embeddings = EmbeddingsLambda(my_embed_fn)
-        result = embeddings.embed_query("hello")  # Returns [0.1, 0.2]
-        await embeddings.aembed_query("hello")  # Also returns [0.1, 0.2]
-        ```
-
-        With an async function:
-        ```python
-        async def my_async_fn(texts):
-            return [[0.1, 0.2] for _ in texts]
-
-        embeddings = EmbeddingsLambda(my_async_fn)
-        await embeddings.aembed_query("hello")  # Returns [0.1, 0.2]
-        # Note: embed_query() would raise an error
-        ```
-    """
-
-    def __init__(
-        self,
-        func: Union[EmbeddingsFunc, AEmbeddingsFunc],
-    ) -> None:
-        if func is None:
-            raise ValueError("func must be provided")
-        if _is_async_callable(func):
-            self.afunc = func
-        else:
-            self.func = func
-
-    def embed_documents(self, texts: list[str]) -> list[list[float]]:
-        """Embed a list of texts into vectors.
-
-        Args:
-            texts: list of texts to convert to embeddings.
-
-        Returns:
-            list of embeddings, one per input text. Each embedding is a list of floats.
-
-        Raises:
-            ValueError: If the instance was initialized with only an async function.
-        """
-        func = getattr(self, "func", None)
-        if func is None:
-            raise ValueError(
-                "EmbeddingsLambda was initialized with an async function but no sync function. "
-                "Use aembed_documents for async operation or provide a sync function."
-            )
-        return func(texts)
-
-    def embed_query(self, text: str) -> list[float]:
-        """Embed a single piece of text.
-
-        Args:
-            text: Text to convert to an embedding.
-
-        Returns:
-            Embedding vector as a list of floats.
-
-        Note:
-            This is equivalent to calling embed_documents with a single text
-            and taking the first result.
-        """
-        return self.embed_documents([text])[0]
-
-    async def aembed_documents(self, texts: list[str]) -> list[list[float]]:
-        """Asynchronously embed a list of texts into vectors.
-
-        Args:
-            texts: list of texts to convert to embeddings.
-
-        Returns:
-            list of embeddings, one per input text. Each embedding is a list of floats.
-
-        Note:
-            If no async function was provided, this falls back to the sync implementation.
-        """
-        afunc = getattr(self, "afunc", None)
-        if afunc is None:
-            return await super().aembed_documents(texts)
-        return await afunc(texts)
-
-    async def aembed_query(self, text: str) -> list[float]:
-        """Asynchronously embed a single piece of text.
-
-        Args:
-            text: Text to convert to an embedding.
-
-        Returns:
-            Embedding vector as a list of floats.
-
-        Note:
-            This is equivalent to calling aembed_documents with a single text
-            and taking the first result.
-        """
-        afunc = getattr(self, "afunc", None)
-        if afunc is None:
-            return await super().aembed_query(text)
-        return (await afunc([text]))[0]
-
-
-def get_text_at_path(obj: Any, path: Union[str, list[str]]) -> list[str]:
-    """Extract text from an object using a path expression or pre-tokenized path.
-
-    Args:
-        obj: The object to extract text from
-        path: Either a path string or pre-tokenized path list.
-
-    !!! info "Path types handled"
-        - Simple paths: "field1.field2"
-        - Array indexing: "[0]", "[*]", "[-1]"
-        - Wildcards: "*"
-        - Multi-field selection: "{field1,field2}"
-        - Nested paths in multi-field: "{field1,nested.field2}"
-    """
-    if not path or path == "$":
-        return [json.dumps(obj, sort_keys=True)]
-
-    tokens = tokenize_path(path) if isinstance(path, str) else path
-
-    def _extract_from_obj(obj: Any, tokens: list[str], pos: int) -> list[str]:
-        if pos >= len(tokens):
-            if isinstance(obj, (str, int, float, bool)):
-                return [str(obj)]
-            elif obj is None:
-                return []
-            elif isinstance(obj, (list, dict)):
-                return [json.dumps(obj, sort_keys=True)]
-            return []
-
-        token = tokens[pos]
-        results = []
-
-        if token.startswith("[") and token.endswith("]"):
-            if not isinstance(obj, list):
-                return []
-
-            index = token[1:-1]
-            if index == "*":
-                for item in obj:
-                    results.extend(_extract_from_obj(item, tokens, pos + 1))
-            else:
-                try:
-                    idx = int(index)
-                    if idx < 0:
-                        idx = len(obj) + idx
-                    if 0 <= idx < len(obj):
-                        results.extend(_extract_from_obj(obj[idx], tokens, pos + 1))
-                except (ValueError, IndexError):
-                    return []
-
-        elif token.startswith("{") and token.endswith("}"):
-            if not isinstance(obj, dict):
-                return []
-
-            fields = [f.strip() for f in token[1:-1].split(",")]
-            for field in fields:
-                nested_tokens = tokenize_path(field)
-                if nested_tokens:
-                    current_obj: Optional[dict] = obj
-                    for nested_token in nested_tokens:
-                        if (
-                            isinstance(current_obj, dict)
-                            and nested_token in current_obj
-                        ):
-                            current_obj = current_obj[nested_token]
-                        else:
-                            current_obj = None
-                            break
-                    if current_obj is not None:
-                        if isinstance(current_obj, (str, int, float, bool)):
-                            results.append(str(current_obj))
-                        elif isinstance(current_obj, (list, dict)):
-                            results.append(json.dumps(current_obj, sort_keys=True))
-
-        # Handle wildcard
-        elif token == "*":
-            if isinstance(obj, dict):
-                for value in obj.values():
-                    results.extend(_extract_from_obj(value, tokens, pos + 1))
-            elif isinstance(obj, list):
-                for item in obj:
-                    results.extend(_extract_from_obj(item, tokens, pos + 1))
-
-        # Handle regular field
-        else:
-            if isinstance(obj, dict) and token in obj:
-                results.extend(_extract_from_obj(obj[token], tokens, pos + 1))
-
-        return results
-
-    return _extract_from_obj(obj, tokens, 0)
-
-
-# Private utility functions
-
-
-def tokenize_path(path: str) -> list[str]:
-    """Tokenize a path into components.
-
-    !!! info "Types handled"
-        - Simple paths: "field1.field2"
-        - Array indexing: "[0]", "[*]", "[-1]"
-        - Wildcards: "*"
-        - Multi-field selection: "{field1,field2}"
-    """
-    if not path:
-        return []
-
-    tokens = []
-    current: list[str] = []
-    i = 0
-    while i < len(path):
-        char = path[i]
-
-        if char == "[":  # Handle array index
-            if current:
-                tokens.append("".join(current))
-                current = []
-            bracket_count = 1
-            index_chars = ["["]
-            i += 1
-            while i < len(path) and bracket_count > 0:
-                if path[i] == "[":
-                    bracket_count += 1
-                elif path[i] == "]":
-                    bracket_count -= 1
-                index_chars.append(path[i])
-                i += 1
-            tokens.append("".join(index_chars))
-            continue
-
-        elif char == "{":  # Handle multi-field selection
-            if current:
-                tokens.append("".join(current))
-                current = []
-            brace_count = 1
-            field_chars = ["{"]
-            i += 1
-            while i < len(path) and brace_count > 0:
-                if path[i] == "{":
-                    brace_count += 1
-                elif path[i] == "}":
-                    brace_count -= 1
-                field_chars.append(path[i])
-                i += 1
-            tokens.append("".join(field_chars))
-            continue
-
-        elif char == ".":  # Handle regular field
-            if current:
-                tokens.append("".join(current))
-                current = []
-        else:
-            current.append(char)
-        i += 1
-
-    if current:
-        tokens.append("".join(current))
-
-    return tokens
-
-
-def _is_async_callable(
-    func: Any,
-) -> bool:
-    """Check if a function is async.
-
-    This includes both async def functions and classes with async __call__ methods.
-
-    Args:
-        func: Function or callable object to check.
-
-    Returns:
-        True if the function is async, False otherwise.
-    """
-    return (
-        asyncio.iscoroutinefunction(func)
-        or hasattr(func, "__call__")  # noqa: B004
-        and asyncio.iscoroutinefunction(func.__call__)
-    )
-
-
-__all__ = [
-    "ensure_embeddings",
-    "EmbeddingsFunc",
-    "AEmbeddingsFunc",
-]

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

@@ -1,456 +1,79 @@
-"""In-memory dictionary-backed store with optional vector search.
-
-!!! example "Examples"
-    Basic key-value storage:
-    ```python
-    from langgraph.store.memory import InMemoryStore
-
-    store = InMemoryStore()
-    store.put(("users", "123"), "prefs", {"theme": "dark"})
-    item = store.get(("users", "123"), "prefs")
-    ```
-
-    Vector search using LangChain embeddings:
-    ```python
-    from langchain.embeddings import init_embeddings
-    from langgraph.store.memory import InMemoryStore
-
-    store = InMemoryStore(
-        index={
-            "dims": 1536,
-            "embed": init_embeddings("openai:text-embedding-3-small")
-        }
-    )
-
-    # Store documents
-    store.put(("docs",), "doc1", {"text": "Python tutorial"})
-    store.put(("docs",), "doc2", {"text": "TypeScript guide"})
-
-    # Search by similarity
-    results = store.search(("docs",), query="python programming")
-    ```
-
-    Vector search using OpenAI SDK directly:
-    ```python
-    from openai import OpenAI
-    from langgraph.store.memory import InMemoryStore
-
-    client = OpenAI()
-
-    def embed_texts(texts: list[str]) -> list[list[float]]:
-        response = client.embeddings.create(
-            model="text-embedding-3-small",
-            input=texts
-        )
-        return [e.embedding for e in response.data]
-
-    store = InMemoryStore(
-        index={
-            "dims": 1536,
-            "embed": embed_texts
-        }
-    )
-
-    # Store documents
-    store.put(("docs",), "doc1", {"text": "Python tutorial"})
-    store.put(("docs",), "doc2", {"text": "TypeScript guide"})
-
-    # Search by similarity
-    results = store.search(("docs",), query="python programming")
-    ```
-
-    Async vector search using OpenAI SDK:
-    ```python
-    from openai import AsyncOpenAI
-    from langgraph.store.memory import InMemoryStore
-
-    client = AsyncOpenAI()
-
-    async def aembed_texts(texts: list[str]) -> list[list[float]]:
-        response = await client.embeddings.create(
-            model="text-embedding-3-small",
-            input=texts
-        )
-        return [e.embedding for e in response.data]
-
-    store = InMemoryStore(
-        index={
-            "dims": 1536,
-            "embed": aembed_texts
-        }
-    )
-
-    # Store documents
-    await store.aput(("docs",), "doc1", {"text": "Python tutorial"})
-    await store.aput(("docs",), "doc2", {"text": "TypeScript guide"})
-
-    # Search by similarity
-    results = await store.asearch(("docs",), query="python programming")
-    ```
-
-Warning:
-    This store keeps all data in memory. Data is lost when the process exits.
-    For persistence, use a database-backed store like PostgresStore.
-
-Tip:
-    For vector search, install numpy for better performance:
-    ```bash
-    pip install numpy
-    ```
-"""
-
-import asyncio
-import concurrent.futures as cf
-import functools
-import logging
 from collections import defaultdict
 from datetime import datetime, timezone
-from importlib import util
-from typing import Any, Iterable, Optional
-
-from langchain_core.embeddings import Embeddings
+from typing import Iterable
 
 from langgraph.store.base import (
     BaseStore,
     GetOp,
-    IndexConfig,
     Item,
     ListNamespacesOp,
     MatchCondition,
     Op,
     PutOp,
     Result,
-    SearchItem,
     SearchOp,
-    ensure_embeddings,
-    get_text_at_path,
-    tokenize_path,
 )
 
-logger = logging.getLogger(__name__)
-
 
 class InMemoryStore(BaseStore):
-    """In-memory dictionary-backed store with optional vector search.
+    """A KV store backed by an in-memory python dictionary.
 
-    !!! example "Examples"
-        Basic key-value storage:
-            store = InMemoryStore()
-            store.put(("users", "123"), "prefs", {"theme": "dark"})
-            item = store.get(("users", "123"), "prefs")
-
-        Vector search with embeddings:
-            from langchain.embeddings import init_embeddings
-            store = InMemoryStore(index={
-                "dims": 1536,
-                "embed": init_embeddings("openai:text-embedding-3-small"),
-                "fields": ["text"],
-            })
-
-            # Store documents
-            store.put(("docs",), "doc1", {"text": "Python tutorial"})
-            store.put(("docs",), "doc2", {"text": "TypeScript guide"})
-
-            # Search by similarity
-            results = store.search(("docs",), query="python programming")
-
-    Note:
-        Semantic search is disabled by default. You can enable it by providing an `index` configuration
-        when creating the store. Without this configuration, all `index` arguments passed to
-        `put` or `aput`will have no effect.
-
-    Warning:
-        This store keeps all data in memory. Data is lost when the process exits.
-        For persistence, use a database-backed store like PostgresStore.
-
-    Tip:
-        For vector search, install numpy for better performance:
-        ```bash
-        pip install numpy
-        ```
+    Useful for testing/experimentation and lightweight PoC's.
+    For actual persistence, use a Store backed by a proper database.
     """
 
-    __slots__ = (
-        "_data",
-        "_vectors",
-        "index_config",
-        "embeddings",
-    )
+    __slots__ = ("_data",)
 
-    def __init__(self, *, index: Optional[IndexConfig] = None) -> None:
-        # Both _data and _vectors are wrapped in the In-memory API
-        # Do not change their names
+    def __init__(self) -> None:
         self._data: dict[tuple[str, ...], dict[str, Item]] = defaultdict(dict)
-        # [ns][key][path]
-        self._vectors: dict[tuple[str, ...], dict[str, dict[str, list[float]]]] = (
-            defaultdict(lambda: defaultdict(dict))
-        )
-        self.index_config = index
-        if self.index_config:
-            self.index_config = self.index_config.copy()
-            self.embeddings: Optional[Embeddings] = ensure_embeddings(
-                self.index_config.get("embed"),
-            )
-            self.index_config["__tokenized_fields"] = [
-                (p, tokenize_path(p)) if p != "$" else (p, p)
-                for p in (self.index_config.get("fields") or ["$"])
-            ]
-
-        else:
-            self.index_config = None
-            self.embeddings = None
 
     def batch(self, ops: Iterable[Op]) -> list[Result]:
-        # The batch/abatch methods are treated as internal.
-        # Users should access via put/search/get/list_namespaces/etc.
-        results, put_ops, search_ops = self._prepare_ops(ops)
-        if search_ops:
-            queryinmem_store = self._embed_search_queries(search_ops)
-            self._batch_search(search_ops, queryinmem_store, results)
-
-        to_embed = self._extract_texts(put_ops)
-        if to_embed and self.index_config and self.embeddings:
-            embeddings = self.embeddings.embed_documents(list(to_embed))
-            self._insertinmem_store(to_embed, embeddings)
-        self._apply_put_ops(put_ops)
-        return results
-
-    async def abatch(self, ops: Iterable[Op]) -> list[Result]:
-        # The batch/abatch methods are treated as internal.
-        # Users should access via put/search/get/list_namespaces/etc.
-        results, put_ops, search_ops = self._prepare_ops(ops)
-        if search_ops:
-            queryinmem_store = await self._aembed_search_queries(search_ops)
-            self._batch_search(search_ops, queryinmem_store, results)
-
-        to_embed = self._extract_texts(put_ops)
-        if to_embed and self.index_config and self.embeddings:
-            embeddings = await self.embeddings.aembed_documents(list(to_embed))
-            self._insertinmem_store(to_embed, embeddings)
-        self._apply_put_ops(put_ops)
-        return results
-
-    # Helpers
-
-    def _filter_items(self, op: SearchOp) -> list[tuple[Item, list[list[float]]]]:
-        """Filter items by namespace and filter function, return items with their embeddings."""
-        namespace_prefix = op.namespace_prefix
-
-        def filter_func(item: Item) -> bool:
-            if not op.filter:
-                return True
-
-            return all(
-                _compare_values(item.value.get(key), filter_value)
-                for key, filter_value in op.filter.items()
-            )
-
-        filtered = []
-        for namespace in self._data:
-            if not (
-                namespace[: len(namespace_prefix)] == namespace_prefix
-                if len(namespace) >= len(namespace_prefix)
-                else False
-            ):
-                continue
-
-            for key, item in self._data[namespace].items():
-                if filter_func(item):
-                    if op.query and (embeddings := self._vectors[namespace].get(key)):
-                        filtered.append((item, list(embeddings.values())))
-                    else:
-                        filtered.append((item, []))
-        return filtered
-
-    def _embed_search_queries(
-        self,
-        search_ops: dict[int, tuple[SearchOp, list[tuple[Item, list[list[float]]]]]],
-    ) -> dict[str, list[float]]:
-        queryinmem_store = {}
-        if self.index_config and self.embeddings and search_ops:
-            queries = {op.query for (op, _) in search_ops.values() if op.query}
-
-            if queries:
-                with cf.ThreadPoolExecutor() as executor:
-                    futures = {
-                        q: executor.submit(self.embeddings.embed_query, q)
-                        for q in list(queries)
-                    }
-                    for query, future in futures.items():
-                        queryinmem_store[query] = future.result()
-
-        return queryinmem_store
-
-    async def _aembed_search_queries(
-        self,
-        search_ops: dict[int, tuple[SearchOp, list[tuple[Item, list[list[float]]]]]],
-    ) -> dict[str, list[float]]:
-        queryinmem_store = {}
-        if self.index_config and self.embeddings and search_ops:
-            queries = {op.query for (op, _) in search_ops.values() if op.query}
-
-            if queries:
-                coros = [self.embeddings.aembed_query(q) for q in list(queries)]
-                results = await asyncio.gather(*coros)
-                queryinmem_store = dict(zip(queries, results))
-
-        return queryinmem_store
-
-    def _batch_search(
-        self,
-        ops: dict[int, tuple[SearchOp, list[tuple[Item, list[list[float]]]]]],
-        queryinmem_store: dict[str, list[float]],
-        results: list[Result],
-    ) -> None:
-        """Perform batch similarity search for multiple queries."""
-        for i, (op, candidates) in ops.items():
-            if not candidates:
-                results[i] = []
-                continue
-            if op.query and queryinmem_store:
-                query_embedding = queryinmem_store[op.query]
-                flat_items, flat_vectors = [], []
-                scoreless = []
-                for item, vectors in candidates:
-                    for vector in vectors:
-                        flat_items.append(item)
-                        flat_vectors.append(vector)
-                    if not vectors:
-                        scoreless.append(item)
-
-                scores = _cosine_similarity(query_embedding, flat_vectors)
-                sorted_results = sorted(
-                    zip(scores, flat_items), key=lambda x: x[0], reverse=True
-                )
-                # max pooling
-                seen: set[tuple[tuple[str, ...], str]] = set()
-                kept: list[tuple[Optional[float], Item]] = []
-                for score, item in sorted_results:
-                    key = (item.namespace, item.key)
-                    if key in seen:
-                        continue
-                    ix = len(seen)
-                    seen.add(key)
-                    if ix >= op.offset + op.limit:
-                        break
-                    if ix < op.offset:
-                        continue
-
-                    kept.append((score, item))
-                if scoreless and len(kept) < op.limit:
-                    # Corner case: if we request more items than what we have embedded,
-                    # fill the rest with non-scored items
-                    kept.extend(
-                        (None, item) for item in scoreless[: op.limit - len(kept)]
-                    )
-
-                results[i] = [
-                    SearchItem(
-                        namespace=item.namespace,
-                        key=item.key,
-                        value=item.value,
-                        created_at=item.created_at,
-                        updated_at=item.updated_at,
-                        score=float(score) if score is not None else None,
-                    )
-                    for score, item in kept
-                ]
-            else:
-                results[i] = [
-                    SearchItem(
-                        namespace=item.namespace,
-                        key=item.key,
-                        value=item.value,
-                        created_at=item.created_at,
-                        updated_at=item.updated_at,
-                    )
-                    for (item, _) in candidates[op.offset : op.offset + op.limit]
-                ]
-
-    def _prepare_ops(
-        self, ops: Iterable[Op]
-    ) -> tuple[
-        list[Result],
-        dict[tuple[tuple[str, ...], str], PutOp],
-        dict[int, tuple[SearchOp, list[tuple[Item, list[list[float]]]]]],
-    ]:
         results: list[Result] = []
-        put_ops: dict[tuple[tuple[str, ...], str], PutOp] = {}
-        search_ops: dict[
-            int, tuple[SearchOp, list[tuple[Item, list[list[float]]]]]
-        ] = {}
-        for i, op in enumerate(ops):
+        for op in ops:
             if isinstance(op, GetOp):
                 item = self._data[op.namespace].get(op.key)
                 results.append(item)
             elif isinstance(op, SearchOp):
-                search_ops[i] = (op, self._filter_items(op))
+                candidates = [
+                    item
+                    for namespace, items in self._data.items()
+                    if (
+                        namespace[: len(op.namespace_prefix)] == op.namespace_prefix
+                        if len(namespace) >= len(op.namespace_prefix)
+                        else False
+                    )
+                    for item in items.values()
+                ]
+                if op.filter:
+                    candidates = [
+                        item
+                        for item in candidates
+                        if item.value.items() >= op.filter.items()
+                    ]
+                results.append(candidates[op.offset : op.offset + op.limit])
+            elif isinstance(op, PutOp):
+                if op.value is None:
+                    self._data[op.namespace].pop(op.key, None)
+                elif op.key in self._data[op.namespace]:
+                    self._data[op.namespace][op.key].value = op.value
+                    self._data[op.namespace][op.key].updated_at = datetime.now(
+                        timezone.utc
+                    )
+                else:
+                    self._data[op.namespace][op.key] = Item(
+                        value=op.value,
+                        key=op.key,
+                        namespace=op.namespace,
+                        created_at=datetime.now(timezone.utc),
+                        updated_at=datetime.now(timezone.utc),
+                    )
                 results.append(None)
             elif isinstance(op, ListNamespacesOp):
                 results.append(self._handle_list_namespaces(op))
-            elif isinstance(op, PutOp):
-                put_ops[(op.namespace, op.key)] = op
-                results.append(None)
-            else:
-                raise ValueError(f"Unknown operation type: {type(op)}")
+        return results
 
-        return results, put_ops, search_ops
-
-    def _apply_put_ops(self, put_ops: dict[tuple[tuple[str, ...], str], PutOp]) -> None:
-        for (namespace, key), op in put_ops.items():
-            if op.value is None:
-                self._data[namespace].pop(key, None)
-                self._vectors[namespace].pop(key, None)
-            else:
-                self._data[namespace][key] = Item(
-                    value=op.value,
-                    key=key,
-                    namespace=namespace,
-                    created_at=datetime.now(timezone.utc),
-                    updated_at=datetime.now(timezone.utc),
-                )
-
-    def _extract_texts(
-        self, put_ops: dict[tuple[tuple[str, ...], str], PutOp]
-    ) -> dict[str, list[tuple[tuple[str, ...], str, str]]]:
-        if put_ops and self.index_config and self.embeddings:
-            to_embed = defaultdict(list)
-
-            for op in put_ops.values():
-                if op.value is not None and op.index is not False:
-                    if op.index is None:
-                        paths = self.index_config["__tokenized_fields"]
-                    else:
-                        paths = [(ix, tokenize_path(ix)) for ix in op.index]
-                    for path, field in paths:
-                        texts = get_text_at_path(op.value, field)
-                        if texts:
-                            if len(texts) > 1:
-                                for i, text in enumerate(texts):
-                                    to_embed[text].append(
-                                        (op.namespace, op.key, f"{path}.{i}")
-                                    )
-
-                            else:
-                                to_embed[texts[0]].append((op.namespace, op.key, path))
-
-            return to_embed
-
-        return {}
-
-    def _insertinmem_store(
-        self,
-        to_embed: dict[str, list[tuple[tuple[str, ...], str, str]]],
-        embeddings: list[list[float]],
-    ) -> None:
-        indices = [index for indices in to_embed.values() for index in indices]
-        if len(indices) != len(embeddings):
-            raise ValueError(
-                f"Number of embeddings ({len(embeddings)}) does not"
-                f" match number of indices ({len(indices)})"
-            )
-        for embedding, (ns, key, path) in zip(embeddings, indices):
-            self._vectors[ns][key][path] = embedding
+    async def abatch(self, ops: Iterable[Op]) -> list[Result]:
+        return self.batch(ops)
 
     def _handle_list_namespaces(self, op: ListNamespacesOp) -> list[tuple[str, ...]]:
         all_namespaces = list(
@@ -471,54 +94,7 @@ class InMemoryStore(BaseStore):
         return namespaces[op.offset : op.offset + op.limit]
 
 
-@functools.lru_cache(maxsize=1)
-def _check_numpy() -> bool:
-    if bool(util.find_spec("numpy")):
-        return True
-    logger.warning(
-        "NumPy not found in the current Python environment. "
-        "The InMemoryStore will use a pure Python implementation for vector operations, "
-        "which may significantly impact performance, especially for large datasets or frequent searches. "
-        "For optimal speed and efficiency, consider installing NumPy: "
-        "pip install numpy"
-    )
-    return False
-
-
-def _cosine_similarity(X: list[float], Y: list[list[float]]) -> list[float]:
-    """
-    Compute cosine similarity between a vector X and a matrix Y.
-    Lazy import numpy for efficiency.
-    """
-    if not Y:
-        return []
-    if _check_numpy():
-        import numpy as np  # type: ignore
-
-        X_arr = np.array(X) if not isinstance(X, np.ndarray) else X
-        Y_arr = np.array(Y) if not isinstance(Y, np.ndarray) else Y
-        X_norm = np.linalg.norm(X_arr)
-        Y_norm = np.linalg.norm(Y_arr, axis=1)
-
-        # Avoid division by zero
-        mask = Y_norm != 0
-        similarities = np.zeros_like(Y_norm)
-        similarities[mask] = np.dot(Y_arr[mask], X_arr) / (Y_norm[mask] * X_norm)
-        return similarities.tolist()
-
-    similarities = []
-    for y in Y:
-        dot_product = sum(a * b for a, b in zip(X, y))
-        norm1 = sum(a * a for a in X) ** 0.5
-        norm2 = sum(a * a for a in y) ** 0.5
-        similarity = dot_product / (norm1 * norm2) if norm1 > 0 and norm2 > 0 else 0.0
-        similarities.append(similarity)
-
-    return similarities
-
-
 def _does_match(match_condition: MatchCondition, key: tuple[str, ...]) -> bool:
-    """Whether a namespace key matches a match condition."""
     match_type = match_condition.match_type
     path = match_condition.path
 
@@ -541,44 +117,3 @@ def _does_match(match_condition: MatchCondition, key: tuple[str, ...]) -> bool:
         return True
     else:
         raise ValueError(f"Unsupported match type: {match_type}")
-
-
-def _compare_values(item_value: Any, filter_value: Any) -> bool:
-    """Compare values in a JSONB-like way, handling nested objects."""
-    if isinstance(filter_value, dict):
-        if any(k.startswith("$") for k in filter_value):
-            return all(
-                _apply_operator(item_value, op_key, op_value)
-                for op_key, op_value in filter_value.items()
-            )
-        if not isinstance(item_value, dict):
-            return False
-        return all(
-            _compare_values(item_value.get(k), v) for k, v in filter_value.items()
-        )
-    elif isinstance(filter_value, (list, tuple)):
-        return (
-            isinstance(item_value, (list, tuple))
-            and len(item_value) == len(filter_value)
-            and all(_compare_values(iv, fv) for iv, fv in zip(item_value, filter_value))
-        )
-    else:
-        return item_value == filter_value
-
-
-def _apply_operator(value: Any, operator: str, op_value: Any) -> bool:
-    """Apply a comparison operator, matching PostgreSQL's JSONB behavior."""
-    if operator == "$eq":
-        return value == op_value
-    elif operator == "$gt":
-        return float(value) > float(op_value)
-    elif operator == "$gte":
-        return float(value) >= float(op_value)
-    elif operator == "$lt":
-        return float(value) < float(op_value)
-    elif operator == "$lte":
-        return float(value) <= float(op_value)
-    elif operator == "$ne":
-        return value != op_value
-    else:
-        raise ValueError(f"Unsupported operator: {operator}")

libs/checkpoint/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langgraph-checkpoint"
-version = "2.0.8"
+version = "2.0.5"
 description = "Library with base interfaces for LangGraph checkpoint savers."
 authors = []
 license = "MIT"

libs/checkpoint/tests/embed_test_utils.py

@@ -1,55 +0,0 @@
-"""Embedding utilities for testing."""
-
-import math
-import random
-from collections import Counter, defaultdict
-from typing import Any
-
-from langchain_core.embeddings import Embeddings
-
-
-class CharacterEmbeddings(Embeddings):
-    """Simple character-frequency based embeddings using random projections."""
-
-    def __init__(self, dims: int = 50, seed: int = 42):
-        """Initialize with embedding dimensions and random seed."""
-        self._rng = random.Random(seed)
-        self.dims = dims
-        # Create projection vector for each character lazily
-        self._char_projections: defaultdict[str, list[float]] = defaultdict(
-            lambda: [
-                self._rng.gauss(0, 1 / math.sqrt(self.dims)) for _ in range(self.dims)
-            ]
-        )
-
-    def _embed_one(self, text: str) -> list[float]:
-        """Embed a single text."""
-        counts = Counter(text)
-        total = sum(counts.values())
-
-        if total == 0:
-            return [0.0] * self.dims
-
-        embedding = [0.0] * self.dims
-        for char, count in counts.items():
-            weight = count / total
-            char_proj = self._char_projections[char]
-            for i, proj in enumerate(char_proj):
-                embedding[i] += weight * proj
-
-        norm = math.sqrt(sum(x * x for x in embedding))
-        if norm > 0:
-            embedding = [x / norm for x in embedding]
-
-        return embedding
-
-    def embed_documents(self, texts: list[str]) -> list[list[float]]:
-        """Embed a list of documents."""
-        return [self._embed_one(text) for text in texts]
-
-    def embed_query(self, text: str) -> list[float]:
-        """Embed a query string."""
-        return self._embed_one(text)
-
-    def __eq__(self, other: Any) -> bool:
-        return isinstance(other, CharacterEmbeddings) and self.dims == other.dims

libs/checkpoint/tests/test_store.py

@@ -1,104 +1,13 @@
-# mypy: disable-error-code="operator"
 import asyncio
-import json
 from datetime import datetime
-from typing import Any, Iterable
+from typing import Iterable
 
 import pytest
 from pytest_mock import MockerFixture
 
-from langgraph.store.base import (
-    GetOp,
-    InvalidNamespaceError,
-    Item,
-    Op,
-    PutOp,
-    Result,
-    get_text_at_path,
-)
+from langgraph.store.base import GetOp, InvalidNamespaceError, Item, Op, PutOp, Result
 from langgraph.store.base.batch import AsyncBatchedBaseStore
 from langgraph.store.memory import InMemoryStore
-from tests.embed_test_utils import CharacterEmbeddings
-
-
-class MockAsyncBatchedStore(AsyncBatchedBaseStore):
-    def __init__(self, **kwargs: Any) -> None:
-        super().__init__()
-        self._store = InMemoryStore(**kwargs)
-
-    def batch(self, ops: Iterable[Op]) -> list[Result]:
-        return self._store.batch(ops)
-
-    async def abatch(self, ops: Iterable[Op]) -> list[Result]:
-        return self._store.batch(ops)
-
-
-def test_get_text_at_path() -> None:
-    nested_data = {
-        "name": "test",
-        "info": {
-            "age": 25,
-            "tags": ["a", "b", "c"],
-            "metadata": {"created": "2024-01-01", "updated": "2024-01-02"},
-        },
-        "items": [
-            {"id": 1, "value": "first", "tags": ["x", "y"]},
-            {"id": 2, "value": "second", "tags": ["y", "z"]},
-            {"id": 3, "value": "third", "tags": ["z", "w"]},
-        ],
-        "empty": None,
-        "zeros": [0, 0.0, "0"],
-        "empty_list": [],
-        "empty_dict": {},
-    }
-
-    assert get_text_at_path(nested_data, "$") == [
-        json.dumps(nested_data, sort_keys=True)
-    ]
-
-    assert get_text_at_path(nested_data, "name") == ["test"]
-    assert get_text_at_path(nested_data, "info.age") == ["25"]
-
-    assert get_text_at_path(nested_data, "info.metadata.created") == ["2024-01-01"]
-
-    assert get_text_at_path(nested_data, "items[0].value") == ["first"]
-    assert get_text_at_path(nested_data, "items[-1].value") == ["third"]
-    assert get_text_at_path(nested_data, "items[1].tags[0]") == ["y"]
-
-    values = get_text_at_path(nested_data, "items[*].value")
-    assert set(values) == {"first", "second", "third"}
-
-    metadata_dates = get_text_at_path(nested_data, "info.metadata.*")
-    assert set(metadata_dates) == {"2024-01-01", "2024-01-02"}
-    name_and_age = get_text_at_path(nested_data, "{name,info.age}")
-    assert set(name_and_age) == {"test", "25"}
-
-    item_fields = get_text_at_path(nested_data, "items[*].{id,value}")
-    assert set(item_fields) == {"1", "2", "3", "first", "second", "third"}
-
-    all_tags = get_text_at_path(nested_data, "items[*].tags[*]")
-    assert set(all_tags) == {"x", "y", "z", "w"}
-
-    assert get_text_at_path(None, "any.path") == []
-    assert get_text_at_path({}, "any.path") == []
-    assert get_text_at_path(nested_data, "") == [
-        json.dumps(nested_data, sort_keys=True)
-    ]
-    assert get_text_at_path(nested_data, "nonexistent") == []
-    assert get_text_at_path(nested_data, "items[99].value") == []
-    assert get_text_at_path(nested_data, "items[*].nonexistent") == []
-
-    assert get_text_at_path(nested_data, "empty") == []
-    assert get_text_at_path(nested_data, "empty_list") == ["[]"]
-    assert get_text_at_path(nested_data, "empty_dict") == ["{}"]
-
-    zeros = get_text_at_path(nested_data, "zeros[*]")
-    assert set(zeros) == {"0", "0.0"}
-
-    assert get_text_at_path(nested_data, "items[].value") == []
-    assert get_text_at_path(nested_data, "items[abc].value") == []
-    assert get_text_at_path(nested_data, "{unclosed") == []
-    assert get_text_at_path(nested_data, "nested[{invalid}]") == []
 
 
 async def test_async_batch_store(mocker: MockerFixture) -> None:
@@ -383,14 +292,12 @@ async def test_cannot_put_empty_namespace() -> None:
 
     await store.aput(("foo", "langgraph", "foo"), "bar", doc)
     assert (await store.aget(("foo", "langgraph", "foo"), "bar")).value == doc  # type: ignore[union-attr]
-    assert (await store.asearch(("foo", "langgraph", "foo"), query="bar"))[
-        0
-    ].value == doc
+    assert (await store.asearch(("foo", "langgraph", "foo")))[0].value == doc
     await store.adelete(("foo", "langgraph", "foo"), "bar")
     assert (await store.aget(("foo", "langgraph", "foo"), "bar")) is None
     store.put(("foo", "langgraph", "foo"), "bar", doc)
     assert store.get(("foo", "langgraph", "foo"), "bar").value == doc  # type: ignore[union-attr]
-    assert store.search(("foo", "langgraph", "foo"), query="bar")[0].value == doc
+    assert store.search(("foo", "langgraph", "foo"))[0].value == doc
     store.delete(("foo", "langgraph", "foo"), "bar")
     assert store.get(("foo", "langgraph", "foo"), "bar") is None
 
@@ -406,6 +313,17 @@ async def test_cannot_put_empty_namespace() -> None:
     store.delete(("langgraph", "foo"), "bar")
     assert store.get(("langgraph", "foo"), "bar") is None
 
+    class MockAsyncBatchedStore(AsyncBatchedBaseStore):
+        def __init__(self) -> None:
+            super().__init__()
+            self._store = InMemoryStore()
+
+        def batch(self, ops: Iterable[Op]) -> list[Result]:
+            return self._store.batch(ops)
+
+        async def abatch(self, ops: Iterable[Op]) -> list[Result]:
+            return self._store.batch(ops)
+
     async_store = MockAsyncBatchedStore()
     doc = {"foo": "bar"}
 
@@ -426,9 +344,6 @@ async def test_cannot_put_empty_namespace() -> None:
     assert val is not None
     assert val.value == doc
     assert (await async_store.asearch(("foo", "langgraph", "foo")))[0].value == doc
-    assert (await async_store.asearch(("foo", "langgraph", "foo"), query="bar"))[
-        0
-    ].value == doc
     await async_store.adelete(("foo", "langgraph", "foo"), "bar")
     assert (await async_store.aget(("foo", "langgraph", "foo"), "bar")) is None
 
@@ -439,511 +354,3 @@ async def test_cannot_put_empty_namespace() -> None:
     assert (await async_store.asearch(("valid", "namespace")))[0].value == doc
     await async_store.adelete(("valid", "namespace"), "key")
     assert (await async_store.aget(("valid", "namespace"), "key")) is None
-
-
-async def test_async_batch_store_deduplication(mocker: MockerFixture) -> None:
-    abatch = mocker.spy(InMemoryStore, "batch")
-    store = MockAsyncBatchedStore()
-
-    same_doc = {"value": "same"}
-    diff_doc = {"value": "different"}
-    await asyncio.gather(
-        store.aput(namespace=("test",), key="same", value=same_doc),
-        store.aput(namespace=("test",), key="different", value=diff_doc),
-    )
-    abatch.reset_mock()
-
-    results = await asyncio.gather(
-        store.aget(namespace=("test",), key="same"),
-        store.aget(namespace=("test",), key="same"),
-        store.aget(namespace=("test",), key="different"),
-    )
-
-    assert len(results) == 3
-    assert results[0] == results[1]
-    assert results[0] != results[2]
-    assert results[0].value == same_doc  # type: ignore
-    assert results[2].value == diff_doc  # type: ignore
-    assert len(abatch.call_args_list) == 1
-    ops = list(abatch.call_args_list[0].args[1])
-    assert len(ops) == 2
-    assert GetOp(("test",), "same") in ops
-    assert GetOp(("test",), "different") in ops
-
-    abatch.reset_mock()
-
-    doc1 = {"value": 1}
-    doc2 = {"value": 2}
-    results = await asyncio.gather(
-        store.aput(namespace=("test",), key="key", value=doc1),
-        store.aput(namespace=("test",), key="key", value=doc2),
-    )
-    assert len(abatch.call_args_list) == 1
-    ops = list(abatch.call_args_list[0].args[1])
-    assert len(ops) == 1
-    assert ops[0] == PutOp(("test",), "key", doc2)
-    assert len(results) == 2
-    assert all(result is None for result in results)
-
-    result = await store.aget(namespace=("test",), key="key")
-    assert result is not None
-    assert result.value == doc2
-
-    abatch.reset_mock()
-
-    results = await asyncio.gather(
-        store.asearch(("test",), filter={"value": 2}),
-        store.asearch(("test",), filter={"value": 2}),
-    )
-    assert len(abatch.call_args_list) == 1
-    ops = list(abatch.call_args_list[0].args[1])
-    assert len(ops) == 1
-    assert len(results) == 2
-    assert results[0] == results[1]
-    assert len(results[0]) == 1
-    assert results[0][0].value == doc2
-
-    abatch.reset_mock()
-
-
-@pytest.fixture
-def fake_embeddings() -> CharacterEmbeddings:
-    return CharacterEmbeddings(dims=500)
-
-
-def test_vector_store_initialization(fake_embeddings: CharacterEmbeddings) -> None:
-    """Test store initialization with embedding config."""
-    store = InMemoryStore(
-        index={"dims": fake_embeddings.dims, "embed": fake_embeddings}
-    )
-    assert store.index_config is not None
-    assert store.index_config["dims"] == fake_embeddings.dims
-    assert store.index_config["embed"] == fake_embeddings
-
-
-def test_vector_insert_with_auto_embedding(
-    fake_embeddings: CharacterEmbeddings,
-) -> None:
-    """Test inserting items that get auto-embedded."""
-    store = InMemoryStore(
-        index={"dims": fake_embeddings.dims, "embed": fake_embeddings}
-    )
-    docs = [
-        ("doc1", {"text": "short text"}),
-        ("doc2", {"text": "longer text document"}),
-        ("doc3", {"text": "longest text document here"}),
-        ("doc4", {"description": "text in description field"}),
-        ("doc5", {"content": "text in content field"}),
-        ("doc6", {"body": "text in body field"}),
-    ]
-
-    for key, value in docs:
-        store.put(("test",), key, value)
-
-    results = store.search(("test",), query="long text")
-    assert len(results) > 0
-
-    doc_order = [r.key for r in results]
-    assert "doc2" in doc_order
-    assert "doc3" in doc_order
-
-
-async def test_async_vector_insert_with_auto_embedding(
-    fake_embeddings: CharacterEmbeddings,
-) -> None:
-    """Test inserting items that get auto-embedded using async methods."""
-    store = InMemoryStore(
-        index={"dims": fake_embeddings.dims, "embed": fake_embeddings}
-    )
-    docs = [
-        ("doc1", {"text": "short text"}),
-        ("doc2", {"text": "longer text document"}),
-        ("doc3", {"text": "longest text document here"}),
-        ("doc4", {"description": "text in description field"}),
-        ("doc5", {"content": "text in content field"}),
-        ("doc6", {"body": "text in body field"}),
-    ]
-
-    for key, value in docs:
-        await store.aput(("test",), key, value)
-
-    results = await store.asearch(("test",), query="long text")
-    assert len(results) > 0
-
-    doc_order = [r.key for r in results]
-    assert "doc2" in doc_order
-    assert "doc3" in doc_order
-
-
-def test_vector_update_with_embedding(fake_embeddings: CharacterEmbeddings) -> None:
-    """Test that updating items properly updates their embeddings."""
-    store = InMemoryStore(
-        index={"dims": fake_embeddings.dims, "embed": fake_embeddings}
-    )
-    store.put(("test",), "doc1", {"text": "zany zebra Xerxes"})
-    store.put(("test",), "doc2", {"text": "something about dogs"})
-    store.put(("test",), "doc3", {"text": "text about birds"})
-
-    results_initial = store.search(("test",), query="Zany Xerxes")
-    assert len(results_initial) > 0
-    assert results_initial[0].key == "doc1"
-    initial_score = results_initial[0].score
-    assert initial_score is not None
-
-    store.put(("test",), "doc1", {"text": "new text about dogs"})
-
-    results_after = store.search(("test",), query="Zany Xerxes")
-    after_score = next((r.score for r in results_after if r.key == "doc1"), 0.0)
-    assert after_score is not None
-    assert after_score < initial_score
-
-    results_new = store.search(("test",), query="new text about dogs")
-    for r in results_new:
-        if r.key == "doc1":
-            assert r.score > after_score
-
-    # Don't index this one
-    store.put(("test",), "doc4", {"text": "new text about dogs"}, index=False)
-    results_new = store.search(("test",), query="new text about dogs", limit=3)
-    assert not any(r.key == "doc4" for r in results_new)
-
-
-async def test_async_vector_update_with_embedding(
-    fake_embeddings: CharacterEmbeddings,
-) -> None:
-    """Test that updating items properly updates their embeddings using async methods."""
-    store = InMemoryStore(
-        index={"dims": fake_embeddings.dims, "embed": fake_embeddings}
-    )
-    await store.aput(("test",), "doc1", {"text": "zany zebra Xerxes"})
-    await store.aput(("test",), "doc2", {"text": "something about dogs"})
-    await store.aput(("test",), "doc3", {"text": "text about birds"})
-
-    results_initial = await store.asearch(("test",), query="Zany Xerxes")
-    assert len(results_initial) > 0
-    assert results_initial[0].key == "doc1"
-    initial_score = results_initial[0].score
-
-    await store.aput(("test",), "doc1", {"text": "new text about dogs"})
-
-    results_after = await store.asearch(("test",), query="Zany Xerxes")
-    after_score = next((r.score for r in results_after if r.key == "doc1"), 0.0)
-    assert after_score is not None
-    assert after_score < initial_score
-
-    results_new = await store.asearch(("test",), query="new text about dogs")
-    for r in results_new:
-        if r.key == "doc1":
-            assert r.score is not None
-            assert r.score > after_score
-
-    # Don't index this one
-    await store.aput(("test",), "doc4", {"text": "new text about dogs"}, index=False)
-    results_new = await store.asearch(("test",), query="new text about dogs", limit=3)
-    assert not any(r.key == "doc4" for r in results_new)
-
-
-def test_vector_search_with_filters(fake_embeddings: CharacterEmbeddings) -> None:
-    """Test combining vector search with filters."""
-    inmem_store = InMemoryStore(
-        index={"dims": fake_embeddings.dims, "embed": fake_embeddings}
-    )
-    # Insert test documents
-    docs = [
-        ("doc1", {"text": "red apple", "color": "red", "score": 4.5}),
-        ("doc2", {"text": "red car", "color": "red", "score": 3.0}),
-        ("doc3", {"text": "green apple", "color": "green", "score": 4.0}),
-        ("doc4", {"text": "blue car", "color": "blue", "score": 3.5}),
-    ]
-
-    for key, value in docs:
-        inmem_store.put(("test",), key, value)
-
-    results = inmem_store.search(("test",), query="apple", filter={"color": "red"})
-    assert len(results) == 2
-    assert results[0].key == "doc1"
-
-    results = inmem_store.search(("test",), query="car", filter={"color": "red"})
-    assert len(results) == 2
-    assert results[0].key == "doc2"
-
-    results = inmem_store.search(
-        ("test",), query="bbbbluuu", filter={"score": {"$gt": 3.2}}
-    )
-    assert len(results) == 3
-    assert results[0].key == "doc4"
-
-    # Multiple filters
-    results = inmem_store.search(
-        ("test",), query="apple", filter={"score": {"$gte": 4.0}, "color": "green"}
-    )
-    assert len(results) == 1
-    assert results[0].key == "doc3"
-
-
-async def test_async_vector_search_with_filters(
-    fake_embeddings: CharacterEmbeddings,
-) -> None:
-    """Test combining vector search with filters using async methods."""
-    store = InMemoryStore(
-        index={"dims": fake_embeddings.dims, "embed": fake_embeddings}
-    )
-    # Insert test documents
-    docs = [
-        ("doc1", {"text": "red apple", "color": "red", "score": 4.5}),
-        ("doc2", {"text": "red car", "color": "red", "score": 3.0}),
-        ("doc3", {"text": "green apple", "color": "green", "score": 4.0}),
-        ("doc4", {"text": "blue car", "color": "blue", "score": 3.5}),
-    ]
-
-    for key, value in docs:
-        await store.aput(("test",), key, value)
-
-    results = await store.asearch(("test",), query="apple", filter={"color": "red"})
-    assert len(results) == 2
-    assert results[0].key == "doc1"
-
-    results = await store.asearch(("test",), query="car", filter={"color": "red"})
-    assert len(results) == 2
-    assert results[0].key == "doc2"
-
-    results = await store.asearch(
-        ("test",), query="bbbbluuu", filter={"score": {"$gt": 3.2}}
-    )
-    assert len(results) == 3
-    assert results[0].key == "doc4"
-
-    # Multiple filters
-    results = await store.asearch(
-        ("test",), query="apple", filter={"score": {"$gte": 4.0}, "color": "green"}
-    )
-    assert len(results) == 1
-    assert results[0].key == "doc3"
-
-
-async def test_async_batched_vector_search_concurrent(
-    fake_embeddings: CharacterEmbeddings,
-) -> None:
-    """Test concurrent vector search operations using async batched store."""
-    store = MockAsyncBatchedStore(
-        index={"dims": fake_embeddings.dims, "embed": fake_embeddings}
-    )
-
-    colors = ["red", "blue", "green", "yellow", "purple"]
-    items = ["apple", "car", "house", "book", "phone"]
-    scores = [3.0, 3.5, 4.0, 4.5, 5.0]
-
-    docs = []
-    for i in range(50):
-        color = colors[i % len(colors)]
-        item = items[i % len(items)]
-        score = scores[i % len(scores)]
-        docs.append(
-            (
-                f"doc{i}",
-                {"text": f"{color} {item}", "color": color, "score": score, "index": i},
-            )
-        )
-    coros = [
-        *[store.aput(("test",), key, value) for key, value in docs],
-        *[store.adelete(("test",), key) for key, value in docs],
-        *[store.aput(("test",), key, value) for key, value in docs],
-    ]
-    await asyncio.gather(*coros)
-
-    # Prepare multiple search queries with different filters
-    search_queries: list[tuple[str, dict[str, Any]]] = [
-        ("apple", {"color": "red"}),
-        ("car", {"color": "blue"}),
-        ("house", {"color": "green"}),
-        ("phone", {"score": {"$gt": 4.99}}),
-        ("book", {"score": {"$lte": 3.5}}),
-        ("apple", {"score": {"$gte": 3.0}, "color": "red"}),
-        ("car", {"score": {"$lt": 5.1}, "color": "blue"}),
-        ("house", {"index": {"$gt": 25}}),
-        ("phone", {"index": {"$lte": 10}}),
-    ]
-
-    all_results = await asyncio.gather(
-        *[
-            store.asearch(("test",), query=query, filter=filter_)
-            for query, filter_ in search_queries
-        ]
-    )
-
-    for results, (query, filter_) in zip(all_results, search_queries):
-        assert len(results) > 0, f"No results for query '{query}' with filter {filter_}"
-
-        for result in results:
-            if "color" in filter_:
-                assert result.value["color"] == filter_["color"]
-
-            if "score" in filter_:
-                score = result.value["score"]
-                for op, value in filter_["score"].items():
-                    if op == "$gt":
-                        assert score > value
-                    elif op == "$gte":
-                        assert score >= value
-                    elif op == "$lt":
-                        assert score < value
-                    elif op == "$lte":
-                        assert score <= value
-
-            if "index" in filter_:
-                index = result.value["index"]
-                for op, value in filter_["index"].items():
-                    if op == "$gt":
-                        assert index > value
-                    elif op == "$gte":
-                        assert index >= value
-                    elif op == "$lt":
-                        assert index < value
-                    elif op == "$lte":
-                        assert index <= value
-
-
-def test_vector_search_pagination(fake_embeddings: CharacterEmbeddings) -> None:
-    """Test pagination with vector search."""
-    store = InMemoryStore(
-        index={"dims": fake_embeddings.dims, "embed": fake_embeddings}
-    )
-    for i in range(5):
-        store.put(("test",), f"doc{i}", {"text": f"test document number {i}"})
-
-    results_page1 = store.search(("test",), query="test", limit=2)
-    results_page2 = store.search(("test",), query="test", limit=2, offset=2)
-
-    assert len(results_page1) == 2
-    assert len(results_page2) == 2
-    assert results_page1[0].key != results_page2[0].key
-
-    all_results = store.search(("test",), query="test", limit=10)
-    assert len(all_results) == 5
-
-
-async def test_async_vector_search_pagination(
-    fake_embeddings: CharacterEmbeddings,
-) -> None:
-    """Test pagination with vector search using async methods."""
-    store = InMemoryStore(
-        index={"dims": fake_embeddings.dims, "embed": fake_embeddings}
-    )
-    for i in range(5):
-        await store.aput(("test",), f"doc{i}", {"text": f"test document number {i}"})
-
-    results_page1 = await store.asearch(("test",), query="test", limit=2)
-    results_page2 = await store.asearch(("test",), query="test", limit=2, offset=2)
-
-    assert len(results_page1) == 2
-    assert len(results_page2) == 2
-    assert results_page1[0].key != results_page2[0].key
-
-    all_results = await store.asearch(("test",), query="test", limit=10)
-    assert len(all_results) == 5
-
-
-async def test_embed_with_path(fake_embeddings: CharacterEmbeddings) -> None:
-    # Test store-level field configuration
-    store = InMemoryStore(
-        index={
-            "dims": fake_embeddings.dims,
-            "embed": fake_embeddings,
-            # Key 2 isn't included. Don't index it.
-            "fields": ["key0", "key1", "key3"],
-        }
-    )
-    # This will have 2 vectors representing it
-    doc1 = {
-        # Omit key0 - check it doesn't raise an error
-        "key1": "xxx",
-        "key2": "yyy",
-        "key3": "zzz",
-    }
-    # This will have 3 vectors representing it
-    doc2 = {
-        "key0": "uuu",
-        "key1": "vvv",
-        "key2": "www",
-        "key3": "xxx",
-    }
-    await store.aput(("test",), "doc1", doc1)
-    await store.aput(("test",), "doc2", doc2)
-
-    # doc2.key3 and doc1.key1 both would have the highest score
-    results = await store.asearch(("test",), query="xxx")
-    assert len(results) == 2
-    assert results[0].key != results[1].key
-    ascore = results[0].score
-    bscore = results[1].score
-    assert ascore == bscore
-    assert ascore is not None and bscore is not None
-
-    results = await store.asearch(("test",), query="uuu")
-    assert len(results) == 2
-    assert results[0].key != results[1].key
-    assert results[0].key == "doc2"
-    assert results[0].score is not None and results[0].score > results[1].score
-    assert ascore == pytest.approx(results[0].score, abs=1e-5)
-
-    # Un-indexed - will have low results for both. Not zero (because we're projecting)
-    # but less than the above.
-    results = await store.asearch(("test",), query="www")
-    assert len(results) == 2
-    assert results[0].score < ascore
-    assert results[1].score < ascore
-
-    # Test operation-level field configuration
-    store_no_defaults = InMemoryStore(
-        index={
-            "dims": fake_embeddings.dims,
-            "embed": fake_embeddings,
-            "fields": ["key17"],
-        }
-    )
-
-    doc3 = {
-        "key0": "aaa",
-        "key1": "bbb",
-        "key2": "ccc",
-        "key3": "ddd",
-    }
-    doc4 = {
-        "key0": "eee",
-        "key1": "bbb",  # Same as doc3.key1
-        "key2": "fff",
-        "key3": "ggg",
-    }
-
-    await store_no_defaults.aput(("test",), "doc3", doc3, index=["key0", "key1"])
-    await store_no_defaults.aput(("test",), "doc4", doc4, index=["key1", "key3"])
-
-    results = await store_no_defaults.asearch(("test",), query="aaa")
-    assert len(results) == 2
-    assert results[0].key == "doc3"
-    assert results[0].score is not None and results[0].score > results[1].score
-
-    results = await store_no_defaults.asearch(("test",), query="ggg")
-    assert len(results) == 2
-    assert results[0].key == "doc4"
-    assert results[0].score is not None and results[0].score > results[1].score
-
-    results = await store_no_defaults.asearch(("test",), query="bbb")
-    assert len(results) == 2
-    assert results[0].key != results[1].key
-    assert results[0].score == results[1].score
-
-    results = await store_no_defaults.asearch(("test",), query="ccc")
-    assert len(results) == 2
-    assert all(r.score < ascore for r in results)
-
-    doc5 = {
-        "key0": "hhh",
-        "key1": "iii",
-    }
-    await store_no_defaults.aput(("test",), "doc5", doc5, index=False)
-
-    results = await store_no_defaults.asearch(("test",), query="hhh")
-    assert len(results) == 3
-    doc5_result = next(r for r in results if r.key == "doc5")
-    assert doc5_result.score is None

libs/cli/js-examples/yarn.lock

@@ -1299,9 +1299,9 @@ create-jest@^29.7.0:
     prompts "^2.0.1"
 
 cross-spawn@^7.0.2, cross-spawn@^7.0.3:
-  version "7.0.6"
-  resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-7.0.6.tgz#8a58fe78f00dcd70c370451759dfbfaf03e8ee9f"
-  integrity sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==
+  version "7.0.3"
+  resolved "https://registry.yarnpkg.com/cross-spawn/-/cross-spawn-7.0.3.tgz#f73a85b9d5d41d045551c177e2882d4ac85728a6"
+  integrity sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==
   dependencies:
     path-key "^3.1.0"
     shebang-command "^2.0.0"

libs/cli/langgraph_cli/cli.py

@@ -1,4 +1,3 @@
-import os
 import pathlib
 import shutil
 import sys
@@ -190,6 +189,7 @@ def up(
     click.secho(
         """For local dev, requires env var LANGSMITH_API_KEY with access to LangGraph Cloud closed beta.
 For production use, requires a license key in env var LANGGRAPH_CLOUD_LICENSE_KEY.""",
+        fg="red",
     )
     with Runner() as runner, Progress(message="Pulling...") as set:
         capabilities = langgraph_cli.docker.check_capabilities(runner)
@@ -511,6 +511,19 @@ def dockerfile(save_path: str, config: pathlib.Path, add_docker_compose: bool) -
     )
 
 
+@click.argument("path", required=False)
+@click.option(
+    "--template",
+    type=str,
+    help=TEMPLATE_HELP_STRING,
+)
+@cli.command("new", help="🌱 Create a new LangGraph project from a template.")
+@log_command
+def new(path: Optional[str], template: Optional[str]) -> None:
+    """Create a new LangGraph project from a template."""
+    return create_new(path, template)
+
+
 @click.option(
     "--host",
     default="127.0.0.1",
@@ -550,12 +563,6 @@ def dockerfile(save_path: str, config: pathlib.Path, add_docker_compose: bool) -
     type=int,
     help="Enable remote debugging by listening on specified port. Requires debugpy to be installed",
 )
-@click.option(
-    "--wait-for-client",
-    is_flag=True,
-    help="Wait for a debugger client to connect to the debug port before starting the server",
-    default=False,
-)
 @cli.command(
     "dev",
     help="🏃‍♀️‍➡️ Run LangGraph API server in development mode with hot reloading and debugging support",
@@ -569,7 +576,6 @@ def dev(
     n_jobs_per_worker: Optional[int],
     no_browser: bool,
     debug_port: Optional[int],
-    wait_for_client: bool,
 ):
     """CLI entrypoint for running the LangGraph API server."""
     try:
@@ -593,16 +599,8 @@ def dev(
         ) from None
 
     config_json = langgraph_cli.config.validate_config_file(config)
-    cwd = os.getcwd()
-    sys.path.append(cwd)
-    dependencies = config_json.get("dependencies", [])
-    for dep in dependencies:
-        dep_path = pathlib.Path(cwd) / dep
-        if dep_path.is_dir() and dep_path.exists():
-            sys.path.append(str(dep_path))
 
     graphs = config_json.get("graphs", {})
-
     run_server(
         host,
         port,
@@ -611,25 +609,9 @@ def dev(
         n_jobs_per_worker=n_jobs_per_worker,
         open_browser=not no_browser,
         debug_port=debug_port,
-        env=config_json.get("env"),
-        store=config_json.get("store"),
-        wait_for_client=wait_for_client,
     )
 
 
-@click.argument("path", required=False)
-@click.option(
-    "--template",
-    type=str,
-    help=TEMPLATE_HELP_STRING,
-)
-@cli.command("new", help="🌱 Create a new LangGraph project from a template.")
-@log_command
-def new(path: Optional[str], template: Optional[str]) -> None:
-    """Create a new LangGraph project from a template."""
-    return create_new(path, template)
-
-
 def prepare_args_and_stdin(
     *,
     capabilities: DockerCapabilities,

libs/cli/langgraph_cli/config.py

@@ -1,5 +1,4 @@
 import json
-import os
 import pathlib
 import textwrap
 from typing import NamedTuple, Optional, TypedDict, Union
@@ -10,44 +9,7 @@ MIN_NODE_VERSION = "20"
 MIN_PYTHON_VERSION = "3.11"
 
 
-class IndexConfig(TypedDict, total=False):
-    """Configuration for indexing documents for semantic search in the store."""
-
-    dims: int
-    """Number of dimensions in the embedding vectors.
-    
-    Common embedding models have the following dimensions:
-        - openai:text-embedding-3-large: 3072
-        - openai:text-embedding-3-small: 1536
-        - openai:text-embedding-ada-002: 1536
-        - cohere:embed-english-v3.0: 1024
-        - cohere:embed-english-light-v3.0: 384
-        - cohere:embed-multilingual-v3.0: 1024
-        - cohere:embed-multilingual-light-v3.0: 384
-    """
-
-    embed: str
-    """Optional model (string) to generate embeddings from text or path to model or function.
-    
-    Examples:
-        - "openai:text-embedding-3-large"
-        - "cohere:embed-multilingual-v3.0"
-        - "src/app.py:embeddings
-    """
-
-    fields: Optional[list[str]]
-    """Fields to extract text from for embedding generation.
-    
-    Defaults to the root ["$"], which embeds the json object as a whole.
-    """
-
-
-class StoreConfig(TypedDict, total=False):
-    embed: Optional[IndexConfig]
-    """Configuration for vector embeddings in store."""
-
-
-class Config(TypedDict, total=False):
+class Config(TypedDict):
     python_version: str
     node_version: Optional[str]
     pip_config_file: Optional[str]
@@ -55,7 +17,6 @@ class Config(TypedDict, total=False):
     dependencies: list[str]
     graphs: dict[str, str]
     env: Union[dict[str, str], str]
-    store: Optional[StoreConfig]
 
 
 def _parse_version(version_str: str) -> tuple[int, int]:
@@ -87,7 +48,6 @@ def validate_config(config: Config) -> Config:
             "dockerfile_lines": config.get("dockerfile_lines", []),
             "graphs": config.get("graphs", {}),
             "env": config.get("env", {}),
-            "store": config.get("store"),
         }
         if config.get("node_version")
         else {
@@ -97,7 +57,6 @@ def validate_config(config: Config) -> Config:
             "dependencies": config.get("dependencies", []),
             "graphs": config.get("graphs", {}),
             "env": config.get("env", {}),
-            "store": config.get("store"),
         }
     )
 
@@ -232,66 +191,76 @@ def _assemble_local_deps(config_path: pathlib.Path, config: Config) -> LocalDeps
         resolved = config_path.parent / local_dep
 
         # validate local dependency
-        if not resolved.exists():
-            raise FileNotFoundError(f"Could not find local dependency: {resolved}")
-        elif not resolved.is_dir():
-            raise NotADirectoryError(
-                f"Local dependency must be a directory: {resolved}"
-            )
-        elif not resolved.is_relative_to(config_path.parent):
-            raise ValueError(
-                f"Local dependency '{resolved}' must be a subdirectory of '{config_path.parent}'"
-            )
-
-        # if it's installable, add it to local_pkgs
-        # otherwise, add it to faux_pkgs, and create a pyproject.toml
-        files = os.listdir(resolved)
-        if "pyproject.toml" in files:
-            real_pkgs[resolved] = local_dep
-            if local_dep == ".":
-                working_dir = f"/deps/{resolved.name}"
-        elif "setup.py" in files:
-            real_pkgs[resolved] = local_dep
-            if local_dep == ".":
-                working_dir = f"/deps/{resolved.name}"
-        else:
-            if any(file == "__init__.py" for file in files):
-                # flat layout
-                if "-" in resolved.name:
-                    raise ValueError(
-                        f"Package name '{resolved.name}' contains a hyphen. "
-                        "Rename the directory to use it as flat-layout package."
-                    )
-                check_reserved(resolved.name, local_dep)
-                container_path = f"/deps/__outer_{resolved.name}/{resolved.name}"
-            else:
-                # src layout
-                container_path = f"/deps/__outer_{resolved.name}/src"
-                for file in files:
-                    rfile = resolved / file
-                    if (
-                        rfile.is_dir()
-                        and file != "__pycache__"
-                        and not file.startswith(".")
-                    ):
-                        try:
-                            for subfile in os.listdir(rfile):
-                                if subfile.endswith(".py"):
-                                    check_reserved(file, local_dep)
-                                    break
-                        except PermissionError:
-                            pass
-            faux_pkgs[resolved] = (local_dep, container_path)
-            if local_dep == ".":
-                working_dir = container_path
-            if "requirements.txt" in files:
-                rfile = resolved / "requirements.txt"
-                pip_reqs.append(
-                    (
-                        rfile.relative_to(config_path.parent),
-                        f"{container_path}/requirements.txt",
-                    )
+        try:
+            if not resolved.exists():
+                raise FileNotFoundError(f"Could not find local dependency: {resolved}")
+            elif not resolved.is_dir():
+                raise NotADirectoryError(
+                    f"Local dependency must be a directory: {resolved}"
                 )
+            elif not resolved.is_relative_to(config_path.parent):
+                raise ValueError(
+                    f"Local dependency '{resolved}' must be a subdirectory of '{config_path.parent}'"
+                )
+
+            # if it's installable, add it to local_pkgs
+            # otherwise, add it to faux_pkgs, and create a pyproject.toml
+            try:
+                files = list(resolved.iterdir())
+                file_names = [f.name for f in files]
+            except (PermissionError, OSError) as e:
+                raise click.UsageError(
+                    f"Cannot access directory {resolved}: {str(e)}"
+                ) from None
+
+            if "pyproject.toml" in file_names:
+                real_pkgs[resolved] = local_dep
+                if local_dep == ".":
+                    working_dir = f"/deps/{resolved.name}"
+            elif "setup.py" in file_names:
+                real_pkgs[resolved] = local_dep
+                if local_dep == ".":
+                    working_dir = f"/deps/{resolved.name}"
+            else:
+                if any(file == "__init__.py" for file in file_names):
+                    # flat layout
+                    if "-" in resolved.name:
+                        raise ValueError(
+                            f"Package name '{resolved.name}' contains a hyphen. "
+                            "Rename the directory to use it as flat-layout package."
+                        )
+                    check_reserved(resolved.name, local_dep)
+                    container_path = f"/deps/__outer_{resolved.name}/{resolved.name}"
+                else:
+                    # src layout
+                    container_path = f"/deps/__outer_{resolved.name}/src"
+                    for file in files:
+                        if (
+                            file.is_dir()
+                            and file.name != "__pycache__"
+                            and not file.name.startswith(".")
+                        ):
+                            try:
+                                subfiles = list(file.iterdir())
+                                if any(f.name.endswith(".py") for f in subfiles):
+                                    check_reserved(file.name, local_dep)
+                            except (PermissionError, OSError):
+                                continue
+                faux_pkgs[resolved] = (local_dep, container_path)
+                if local_dep == ".":
+                    working_dir = container_path
+                if "requirements.txt" in file_names:
+                    rfile = resolved / "requirements.txt"
+                    pip_reqs.append(
+                        (
+                            pathlib.PurePosixPath(
+                                rfile.relative_to(config_path.parent)
+                            ),
+                            f"{container_path}/requirements.txt",
+                        )
+                    )
+        except (PermissionError, OSError) as e:
+            raise click.UsageError(f"Cannot access path {resolved}: {str(e)}") from e
 
     return LocalDeps(pip_reqs, real_pkgs, faux_pkgs, working_dir)
 
@@ -315,12 +284,12 @@ def _update_graph_paths(
             else:
                 for path in local_deps.real_pkgs:
                     if resolved.is_relative_to(path):
-                        module_str = f"/deps/{path.name}/{resolved.relative_to(path)}"
+                        module_str = f"/deps/{path.name}/{pathlib.PurePosixPath(resolved.relative_to(path))}"
                         break
                 else:
                     for faux_pkg, (_, destpath) in local_deps.faux_pkgs.items():
                         if resolved.is_relative_to(faux_pkg):
-                            module_str = f"{destpath}/{resolved.relative_to(faux_pkg)}"
+                            module_str = f"{destpath}/{pathlib.PurePosixPath(resolved.relative_to(faux_pkg))}"
                             break
                     else:
                         raise ValueError(
@@ -353,17 +322,17 @@ def python_config_to_docker(config_path: pathlib.Path, config: Config, base_imag
 
     pip_pkgs_str = f"RUN {pip_install} {' '.join(pypi_deps)}" if pypi_deps else ""
     if local_deps.pip_reqs:
-        pip_reqs_str = os.linesep.join(
+        pip_reqs_str = "\n".join(
             f"ADD {reqpath} {destpath}" for reqpath, destpath in local_deps.pip_reqs
         )
-        pip_reqs_str += f'{os.linesep}RUN {pip_install} {" ".join("-r " + r for _,r in local_deps.pip_reqs)}'
-
+        pip_reqs_str += (
+            f'\nRUN {pip_install} {" ".join("-r " + r for _,r in local_deps.pip_reqs)}'
+        )
     else:
         pip_reqs_str = ""
-
     # https://setuptools.pypa.io/en/latest/userguide/datafiles.html#package-data
     # https://til.simonwillison.net/python/pyproject
-    faux_pkgs_str = f"{os.linesep}{os.linesep}".join(
+    faux_pkgs_str = "\n\n".join(
         f"""ADD {relpath} {destpath}
 RUN set -ex && \\
     for line in '[project]' \\
@@ -375,12 +344,12 @@ RUN set -ex && \\
     done"""
         for fullpath, (relpath, destpath) in local_deps.faux_pkgs.items()
     )
-    local_pkgs_str = os.linesep.join(
+    local_pkgs_str = "\n".join(
         f"ADD {relpath} /deps/{fullpath.name}"
         for fullpath, relpath in local_deps.real_pkgs.items()
     )
 
-    installs = f"{os.linesep}{os.linesep}".join(
+    installs = "\n\n".join(
         filter(
             None,
             [
@@ -392,25 +361,19 @@ RUN set -ex && \\
             ],
         )
     )
-    store_config = config.get("store")
-    env_additional_config = (
-        ""
-        if not store_config
-        else f"""
-ENV LANGGRAPH_STORE='{json.dumps(store_config)}'
-"""
-    )
+    _workdir = f"WORKDIR {local_deps.working_dir}" if local_deps.working_dir else ""
+    dockerfile_lines = "\n".join(config["dockerfile_lines"])
     return f"""FROM {base_image}:{config['python_version']}
 
-{os.linesep.join(config["dockerfile_lines"])}
+{dockerfile_lines}
 
 {installs}
 
 RUN {pip_install} -e /deps/*
-{env_additional_config}
+
 ENV LANGSERVE_GRAPHS='{json.dumps(config["graphs"])}'
 
-{f"WORKDIR {local_deps.working_dir}" if local_deps.working_dir else ""}"""
+{_workdir}"""
 
 
 def node_config_to_docker(config_path: pathlib.Path, config: Config, base_image: str):
@@ -437,22 +400,15 @@ def node_config_to_docker(config_path: pathlib.Path, config: Config, base_image:
         install_cmd = "npm ci"
     else:
         install_cmd = "npm i"
-    store_config = config.get("store")
-    env_additional_config = (
-        ""
-        if not store_config
-        else f"""
-ENV LANGGRAPH_STORE='{json.dumps(store_config)}'
-"""
-    )
+    dockerfile_lines = "\n".join(config["dockerfile_lines"])
     return f"""FROM {base_image}:{config['node_version']}
 
-{os.linesep.join(config["dockerfile_lines"])}
+{dockerfile_lines}
 
 ADD . {faux_path}
 
 RUN cd {faux_path} && {install_cmd}
-{env_additional_config}
+
 ENV LANGSERVE_GRAPHS='{json.dumps(config["graphs"])}'
 
 WORKDIR {faux_path}

libs/cli/pyproject.toml

@@ -1,12 +1,12 @@
 [tool.poetry]
 name = "langgraph-cli"
-version = "0.1.61"
+version = "0.1.56"
 description = "CLI for interacting with LangGraph API"
 authors = []
 license = "MIT"
 readme = "README.md"
 repository = "https://www.github.com/langchain-ai/langgraph"
-packages = [{ include = "langgraph_cli" }]
+packages = [{include = "langgraph_cli"}]
 
 [tool.poetry.scripts]
 langgraph = "langgraph_cli.cli:cli"
@@ -14,8 +14,7 @@ langgraph = "langgraph_cli.cli:cli"
 [tool.poetry.dependencies]
 python = "^3.9.0,<4.0"
 click = "^8.1.7"
-langgraph-api = { version = ">=0.0.6,<0.1.0", optional = true, python = ">=3.11,<4.0" }
-python-dotenv = { version = ">=0.8.0", optional = true }
+langgraph-api-inmem = { version = ">=0.0.3,<0.1.0", optional = true }
 
 [tool.poetry.group.dev.dependencies]
 ruff = "^0.6.2"
@@ -27,7 +26,7 @@ pytest-watch = "^4.2.0"
 mypy = "^1.10.0"
 
 [tool.poetry.extras]
-inmem = ["langgraph-api", "python-dotenv"]
+inmem = ["langgraph-api-inmem"]
 
 [tool.pytest.ini_options]
 # --strict-markers will raise errors on unknown marks.
@@ -57,4 +56,4 @@ lint.select = [
   # isort
   "I",
 ]
-lint.ignore = ["E501", "B008"]
+lint.ignore = [ "E501", "B008" ]

libs/cli/tests/unit_tests/test_config.py

@@ -30,7 +30,6 @@ def test_validate_config():
         "pip_config_file": None,
         "dockerfile_lines": [],
         "env": {},
-        "store": None,
         **expected_config,
     }
     actual_config = validate_config(expected_config)
@@ -47,7 +46,6 @@ def test_validate_config():
             "agent": "./agent.py:graph",
         },
         "env": env,
-        "store": None,
     }
     actual_config = validate_config(expected_config)
     assert actual_config == expected_config

libs/langgraph/Makefile

@@ -48,19 +48,8 @@ test:
 	make stop-postgres; \
 	exit $$EXIT_CODE
 
-test_parallel:
-	make start-postgres && poetry run pytest -n auto --dist worksteal $(TEST); \
-	EXIT_CODE=$$?; \
-	make stop-postgres; \
-	exit $$EXIT_CODE
-
-WORKERS ?= auto
-XDIST_ARGS := $(if $(WORKERS),-n $(WORKERS) --dist worksteal,)
-MAXFAIL ?=
-MAXFAIL_ARGS := $(if $(MAXFAIL),--maxfail $(MAXFAIL),)
-
 test_watch:
-	make start-postgres && poetry run ptw . -- --ff -vv -x $(XDIST_ARGS) $(MAXFAIL_ARGS) --snapshot-update --tb short $(TEST); \
+	make start-postgres && poetry run ptw . -- --ff -vv -x -n auto --dist worksteal --snapshot-update --tb short $(TEST); \
 	EXIT_CODE=$$?; \
 	make stop-postgres; \
 	exit $$EXIT_CODE

libs/langgraph/README.md

@@ -238,7 +238,7 @@ final_state["messages"][-1].content
 * [How-to Guides](https://langchain-ai.github.io/langgraph/how-tos/): Accomplish specific things within LangGraph, from streaming, to adding memory & persistence, to common design patterns (branching, subgraphs, etc.), these are the place to go if you want to copy and run a specific code snippet.
 * [Conceptual Guides](https://langchain-ai.github.io/langgraph/concepts/high_level/): In-depth explanations of the key concepts and principles behind LangGraph, such as nodes, edges, state and more.
 * [API Reference](https://langchain-ai.github.io/langgraph/reference/graphs/): Review important classes and methods, simple examples of how to use the graph and checkpointing APIs, higher-level prebuilt components and more.
-* [LangGraph Platform](https://langchain-ai.github.io/langgraph/concepts/#langgraph-platform): LangGraph Platform is a commercial solution for deploying agentic applications in production, built on the open-source LangGraph framework.
+* [Cloud (beta)](https://langchain-ai.github.io/langgraph/cloud/): With one click, deploy LangGraph applications to LangGraph Cloud.
 
 ## Contributing
 

libs/langgraph/langgraph/constants.py

@@ -72,11 +72,9 @@ CONFIG_KEY_CHECKPOINT_ID = sys.intern("checkpoint_id")
 CONFIG_KEY_CHECKPOINT_NS = sys.intern("checkpoint_ns")
 # holds the current checkpoint_ns, "" for root graph
 CONFIG_KEY_NODE_FINISHED = sys.intern("__pregel_node_finished")
+# callback to be called when a node is finished
+CONFIG_KEY_RESUME_VALUE = sys.intern("__pregel_resume_value")
 # holds the value that "answers" an interrupt() call
-CONFIG_KEY_WRITES = sys.intern("__pregel_writes")
-# read-only list of existing task writes
-CONFIG_KEY_SCRATCHPAD = sys.intern("__pregel_scratchpad")
-# holds a mutable dict for temporary storage scoped to the current task
 
 # --- Other constants ---
 PUSH = sys.intern("__pregel_push")

libs/langgraph/langgraph/errors.py

@@ -2,7 +2,7 @@ from enum import Enum
 from typing import Any, Sequence
 
 from langgraph.checkpoint.base import EmptyChannelError  # noqa: F401
-from langgraph.types import Command, Interrupt
+from langgraph.types import Interrupt
 
 # EmptyChannelError re-exported for backwards compatibility
 
@@ -58,11 +58,7 @@ class InvalidUpdateError(Exception):
     pass
 
 
-class GraphBubbleUp(Exception):
-    pass
-
-
-class GraphInterrupt(GraphBubbleUp):
+class GraphInterrupt(Exception):
     """Raised when a subgraph is interrupted, suppressed by the root graph.
     Never raised directly, or surfaced to the user."""
 
@@ -77,20 +73,13 @@ class NodeInterrupt(GraphInterrupt):
         super().__init__([Interrupt(value=value)])
 
 
-class GraphDelegate(GraphBubbleUp):
+class GraphDelegate(Exception):
     """Raised when a graph is delegated (for distributed mode)."""
 
     def __init__(self, *args: dict[str, Any]) -> None:
         super().__init__(*args)
 
 
-class ParentCommand(GraphBubbleUp):
-    args: tuple[Command]
-
-    def __init__(self, command: Command) -> None:
-        super().__init__(command)
-
-
 class EmptyInputError(Exception):
     """Raised when graph receives an empty input."""
 

libs/langgraph/langgraph/graph/__init__.py

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

libs/langgraph/langgraph/graph/graph.py

@@ -374,11 +374,6 @@ class Graph:
             if source not in self.nodes and source != START:
                 raise ValueError(f"Found edge starting at unknown node '{source}'")
 
-        if START not in all_sources:
-            raise ValueError(
-                "Graph must have an entrypoint: add at least one edge from START to another node"
-            )
-
         # assemble targets
         all_targets = {end for _, end in self._all_edges}
         for start, branches in self.branches.items():
@@ -400,6 +395,10 @@ class Graph:
         for name, spec in self.nodes.items():
             if spec.ends:
                 all_targets.update(spec.ends)
+        # validate targets
+        for node in self.nodes:
+            if node not in all_targets:
+                raise ValueError(f"Node `{node}` is not reachable")
         for target in all_targets:
             if target not in self.nodes and target != END:
                 raise ValueError(f"Found edge ending at unknown node `{target}`")

libs/langgraph/langgraph/graph/state.py

@@ -1,3 +1,4 @@
+import dataclasses
 import inspect
 import logging
 import typing
@@ -8,6 +9,7 @@ from types import FunctionType
 from typing import (
     Any,
     Callable,
+    Generic,
     Literal,
     NamedTuple,
     Optional,
@@ -35,12 +37,7 @@ from langgraph.channels.ephemeral_value import EphemeralValue
 from langgraph.channels.last_value import LastValue
 from langgraph.channels.named_barrier_value import NamedBarrierValue
 from langgraph.constants import EMPTY_SEQ, NS_END, NS_SEP, SELF, TAG_HIDDEN
-from langgraph.errors import (
-    ErrorCode,
-    InvalidUpdateError,
-    ParentCommand,
-    create_error_message,
-)
+from langgraph.errors import ErrorCode, InvalidUpdateError, create_error_message
 from langgraph.graph.graph import END, START, Branch, CompiledGraph, Graph, Send
 from langgraph.managed.base import (
     ChannelKeyPlaceholder,
@@ -53,7 +50,7 @@ from langgraph.managed.base import (
 from langgraph.pregel.read import ChannelRead, PregelNode
 from langgraph.pregel.write import SKIP_WRITE, ChannelWrite, ChannelWriteEntry
 from langgraph.store.base import BaseStore
-from langgraph.types import All, Checkpointer, Command, RetryPolicy
+from langgraph.types import _DC_KWARGS, All, Checkpointer, Command, N, RetryPolicy
 from langgraph.utils.fields import get_field_default
 from langgraph.utils.pydantic import create_model
 from langgraph.utils.runnable import RunnableCallable, coerce_to_runnable
@@ -82,6 +79,22 @@ def _get_node_name(node: RunnableLike) -> str:
         raise TypeError(f"Unsupported node type: {type(node)}")
 
 
+@dataclasses.dataclass(**_DC_KWARGS)
+class GraphCommand(Generic[N], Command[N]):
+    """One or more commands to update a StateGraph's state and go to, or send messages to nodes."""
+
+    goto: Union[str, Sequence[str]] = ()
+
+    def __repr__(self) -> str:
+        # get all non-None values
+        contents = ", ".join(
+            f"{key}={value!r}"
+            for key, value in dataclasses.asdict(self).items()
+            if value
+        )
+        return f"Command({contents})"
+
+
 class StateNodeSpec(NamedTuple):
     runnable: Runnable
     metadata: Optional[dict[str, Any]]
@@ -374,7 +387,7 @@ class StateGraph(Graph):
                             input = input_hint
                 if (
                     (rtn := hints.get("return"))
-                    and get_origin(rtn) is Command
+                    and get_origin(rtn) in (Command, GraphCommand)
                     and (rargs := get_args(rtn))
                     and get_origin(rargs[0]) is Literal
                     and (vals := get_args(rargs[0]))
@@ -610,27 +623,20 @@ class CompiledStateGraph(CompiledGraph):
 
         def _get_root(input: Any) -> Any:
             if isinstance(input, Command):
-                if input.graph == Command.PARENT:
-                    return SKIP_WRITE
                 return input.update
             else:
                 return input
 
-        # to avoid name collision below
-        node_key = key
-
         def _get_state_key(input: Union[None, dict, Any], *, key: str) -> Any:
             if input is None:
                 return SKIP_WRITE
             elif isinstance(input, dict):
                 if all(k not in output_keys for k in input):
                     raise InvalidUpdateError(
-                        f"Expected node {node_key} to update at least one of {output_keys}, got {input}"
+                        f"Expected node {key} to update at least one of {output_keys}, got {input}"
                     )
                 return input.get(key, SKIP_WRITE)
             elif isinstance(input, Command):
-                if input.graph == Command.PARENT:
-                    return SKIP_WRITE
                 return _get_state_key(input.update, key=key)
             elif get_type_hints(type(input)):
                 value = getattr(input, key, SKIP_WRITE)
@@ -811,34 +817,34 @@ def _coerce_state(schema: Type[Any], input: dict[str, Any]) -> dict[str, Any]:
 def _control_branch(value: Any) -> Sequence[Union[str, Send]]:
     if isinstance(value, Send):
         return [value]
-    if not isinstance(value, Command):
+    if not isinstance(value, GraphCommand):
         return EMPTY_SEQ
-    if value.graph == Command.PARENT:
-        raise ParentCommand(value)
     rtn: list[Union[str, Send]] = []
-    if isinstance(value.goto, Send):
-        rtn.append(value.goto)
-    elif isinstance(value.goto, str):
+    if isinstance(value.goto, str):
         rtn.append(value.goto)
     else:
         rtn.extend(value.goto)
+    if isinstance(value.send, Send):
+        rtn.append(value.send)
+    else:
+        rtn.extend(value.send)
     return rtn
 
 
 async def _acontrol_branch(value: Any) -> Sequence[Union[str, Send]]:
     if isinstance(value, Send):
         return [value]
-    if not isinstance(value, Command):
+    if not isinstance(value, GraphCommand):
         return EMPTY_SEQ
-    if value.graph == Command.PARENT:
-        raise ParentCommand(value)
     rtn: list[Union[str, Send]] = []
-    if isinstance(value.goto, Send):
-        rtn.append(value.goto)
-    elif isinstance(value.goto, str):
+    if isinstance(value.goto, str):
         rtn.append(value.goto)
     else:
         rtn.extend(value.goto)
+    if isinstance(value.send, Send):
+        rtn.append(value.send)
+    else:
+        rtn.extend(value.send)
     return rtn
 
 
@@ -911,12 +917,12 @@ def _is_field_binop(typ: Type[Any]) -> Optional[BinaryOperatorAggregate]:
     if hasattr(typ, "__metadata__"):
         meta = typ.__metadata__
         if len(meta) >= 1 and callable(meta[-1]):
-            sig = signature(meta[-1])
+            sig = signature(meta[0])
             params = list(sig.parameters.values())
             if len(params) == 2 and all(
                 p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD) for p in params
             ):
-                return BinaryOperatorAggregate(typ, meta[-1])
+                return BinaryOperatorAggregate(typ, meta[0])
             else:
                 raise ValueError(
                     f"Invalid reducer signature. Expected (a, b) -> c. Got {sig}"

libs/langgraph/langgraph/prebuilt/chat_agent_executor.py

@@ -212,7 +212,6 @@ def create_react_agent(
     Args:
         model: The `LangChain` chat model that supports tool calling.
         tools: A list of tools, a ToolExecutor, or a ToolNode instance.
-            If an empty list is provided, the agent will consist of a single LLM node without tool calling.
         state_schema: An optional state schema that defines graph state.
             Must have `messages` and `is_last_step` keys.
             Defaults to `AgentState` that defines those two keys.
@@ -541,11 +540,20 @@ def create_react_agent(
         # get the tool functions wrapped in a tool class from the ToolNode
         tool_classes = list(tool_node.tools_by_name.values())
 
-    tool_calling_enabled = len(tool_classes) > 0
-
-    if _should_bind_tools(model, tool_classes) and tool_calling_enabled:
+    if _should_bind_tools(model, tool_classes):
         model = cast(BaseChatModel, model).bind_tools(tool_classes)
 
+    # Define the function that determines whether to continue or not
+    def should_continue(state: AgentState) -> Literal["tools", "__end__"]:
+        messages = state["messages"]
+        last_message = messages[-1]
+        # If there is no function call, then we finish
+        if not isinstance(last_message, AIMessage) or not last_message.tool_calls:
+            return "__end__"
+        # Otherwise if there is, we continue
+        else:
+            return "tools"
+
     # we're passing store here for validation
     preprocessor = _get_model_preprocessing_runnable(
         state_modifier, messages_modifier, store
@@ -627,30 +635,6 @@ def create_react_agent(
         # We return a list, because this will get added to the existing list
         return {"messages": [response]}
 
-    if not tool_calling_enabled:
-        # Define a new graph
-        workflow = StateGraph(state_schema or AgentState)
-        workflow.add_node("agent", RunnableCallable(call_model, acall_model))
-        workflow.set_entry_point("agent")
-        return workflow.compile(
-            checkpointer=checkpointer,
-            store=store,
-            interrupt_before=interrupt_before,
-            interrupt_after=interrupt_after,
-            debug=debug,
-        )
-
-    # Define the function that determines whether to continue or not
-    def should_continue(state: AgentState) -> Literal["tools", "__end__"]:
-        messages = state["messages"]
-        last_message = messages[-1]
-        # If there is no function call, then we finish
-        if not isinstance(last_message, AIMessage) or not last_message.tool_calls:
-            return "__end__"
-        # Otherwise if there is, we continue
-        else:
-            return "tools"
-
     # Define a new graph
     workflow = StateGraph(state_schema or AgentState)
 

libs/langgraph/langgraph/prebuilt/tool_node.py

@@ -37,7 +37,7 @@ from langchain_core.tools import tool as create_tool
 from langchain_core.tools.base import get_all_basemodel_annotations
 from typing_extensions import Annotated, get_args, get_origin
 
-from langgraph.errors import GraphBubbleUp
+from langgraph.errors import GraphInterrupt
 from langgraph.store.base import BaseStore
 from langgraph.utils.runnable import RunnableCallable
 
@@ -275,7 +275,7 @@ class ToolNode(RunnableCallable):
         # (2) a NodeInterrupt is raised inside a graph node for a graph called as a tool
         # (3) a GraphInterrupt is raised when a subgraph is interrupted inside a graph called as a tool
         # (2 and 3 can happen in a "supervisor w/ tools" multi-agent architecture)
-        except GraphBubbleUp as e:
+        except GraphInterrupt as e:
             raise e
         except Exception as e:
             if isinstance(self.handle_tool_errors, tuple):
@@ -316,7 +316,7 @@ class ToolNode(RunnableCallable):
         # (2) a NodeInterrupt is raised inside a graph node for a graph called as a tool
         # (3) a GraphInterrupt is raised when a subgraph is interrupted inside a graph called as a tool
         # (2 and 3 can happen in a "supervisor w/ tools" multi-agent architecture)
-        except GraphBubbleUp as e:
+        except GraphInterrupt as e:
             raise e
         except Exception as e:
             if isinstance(self.handle_tool_errors, tuple):

libs/langgraph/langgraph/pregel/__init__.py

@@ -673,7 +673,7 @@ class Pregel(PregelProtocol):
         self, config: RunnableConfig, *, subgraphs: bool = False
     ) -> StateSnapshot:
         """Get the current state of the graph."""
-        checkpointer: Optional[BaseCheckpointSaver] = ensure_config(config)[CONF].get(
+        checkpointer: Optional[BaseCheckpointSaver] = config[CONF].get(
             CONFIG_KEY_CHECKPOINTER, self.checkpointer
         )
         if not checkpointer:
@@ -710,7 +710,7 @@ class Pregel(PregelProtocol):
         self, config: RunnableConfig, *, subgraphs: bool = False
     ) -> StateSnapshot:
         """Get the current state of the graph."""
-        checkpointer: Optional[BaseCheckpointSaver] = ensure_config(config)[CONF].get(
+        checkpointer: Optional[BaseCheckpointSaver] = config[CONF].get(
             CONFIG_KEY_CHECKPOINTER, self.checkpointer
         )
         if not checkpointer:
@@ -751,9 +751,8 @@ class Pregel(PregelProtocol):
         before: Optional[RunnableConfig] = None,
         limit: Optional[int] = None,
     ) -> Iterator[StateSnapshot]:
-        config = ensure_config(config)
         """Get the history of the state of the graph."""
-        checkpointer: Optional[BaseCheckpointSaver] = ensure_config(config)[CONF].get(
+        checkpointer: Optional[BaseCheckpointSaver] = config[CONF].get(
             CONFIG_KEY_CHECKPOINTER, self.checkpointer
         )
         if not checkpointer:
@@ -801,9 +800,8 @@ class Pregel(PregelProtocol):
         before: Optional[RunnableConfig] = None,
         limit: Optional[int] = None,
     ) -> AsyncIterator[StateSnapshot]:
-        config = ensure_config(config)
         """Get the history of the state of the graph."""
-        checkpointer: Optional[BaseCheckpointSaver] = ensure_config(config)[CONF].get(
+        checkpointer: Optional[BaseCheckpointSaver] = config[CONF].get(
             CONFIG_KEY_CHECKPOINTER, self.checkpointer
         )
         if not checkpointer:
@@ -857,7 +855,7 @@ class Pregel(PregelProtocol):
         node `as_node`. If `as_node` is not provided, it will be set to the last node
         that updated the state, if not ambiguous.
         """
-        checkpointer: Optional[BaseCheckpointSaver] = ensure_config(config)[CONF].get(
+        checkpointer: Optional[BaseCheckpointSaver] = config[CONF].get(
             CONFIG_KEY_CHECKPOINTER, self.checkpointer
         )
         if not checkpointer:
@@ -1132,7 +1130,7 @@ class Pregel(PregelProtocol):
         values: dict[str, Any] | Any,
         as_node: Optional[str] = None,
     ) -> RunnableConfig:
-        checkpointer: Optional[BaseCheckpointSaver] = ensure_config(config)[CONF].get(
+        checkpointer: Optional[BaseCheckpointSaver] = config[CONF].get(
             CONFIG_KEY_CHECKPOINTER, self.checkpointer
         )
         if not checkpointer:

libs/langgraph/langgraph/pregel/algo.py

@@ -1,4 +1,3 @@
-import sys
 from collections import defaultdict, deque
 from functools import partial
 from hashlib import sha1
@@ -37,13 +36,13 @@ from langgraph.constants import (
     CONFIG_KEY_CHECKPOINT_NS,
     CONFIG_KEY_CHECKPOINTER,
     CONFIG_KEY_READ,
-    CONFIG_KEY_SCRATCHPAD,
+    CONFIG_KEY_RESUME_VALUE,
     CONFIG_KEY_SEND,
     CONFIG_KEY_STORE,
     CONFIG_KEY_TASK_ID,
-    CONFIG_KEY_WRITES,
     EMPTY_SEQ,
     INTERRUPT,
+    MISSING,
     NO_WRITES,
     NS_END,
     NS_SEP,
@@ -67,7 +66,6 @@ from langgraph.types import All, LoopProtocol, PregelExecutableTask, PregelTask
 from langgraph.utils.config import merge_configs, patch_config
 
 GetNextVersion = Callable[[Optional[V], BaseChannel], V]
-SUPPORTS_EXC_NOTES = sys.version_info >= (3, 11)
 
 
 class WritesProtocol(Protocol):
@@ -589,13 +587,14 @@ def prepare_single_task(
                             },
                             CONFIG_KEY_CHECKPOINT_ID: None,
                             CONFIG_KEY_CHECKPOINT_NS: task_checkpoint_ns,
-                            CONFIG_KEY_WRITES: [
-                                w
-                                for w in pending_writes
-                                + configurable.get(CONFIG_KEY_WRITES, [])
-                                if w[0] in (NULL_TASK_ID, task_id)
-                            ],
-                            CONFIG_KEY_SCRATCHPAD: {},
+                            CONFIG_KEY_RESUME_VALUE: next(
+                                (
+                                    v
+                                    for tid, c, v in pending_writes
+                                    if tid in (NULL_TASK_ID, task_id) and c == RESUME
+                                ),
+                                MISSING,
+                            ),
                         },
                     ),
                     triggers,
@@ -603,7 +602,6 @@ def prepare_single_task(
                     None,
                     task_id,
                     task_path,
-                    writers=proc.flat_writers,
                 )
 
         else:
@@ -635,12 +633,6 @@ def prepare_single_task(
                 )
             except StopIteration:
                 return
-            except Exception as exc:
-                if SUPPORTS_EXC_NOTES:
-                    exc.add_note(
-                        f"Before task with name '{name}' and path '{task_path[:3]}'"
-                    )
-                raise
 
             # create task id
             checkpoint_ns = f"{parent_ns}{NS_SEP}{name}" if parent_ns else name
@@ -712,13 +704,15 @@ def prepare_single_task(
                                 },
                                 CONFIG_KEY_CHECKPOINT_ID: None,
                                 CONFIG_KEY_CHECKPOINT_NS: task_checkpoint_ns,
-                                CONFIG_KEY_WRITES: [
-                                    w
-                                    for w in pending_writes
-                                    + configurable.get(CONFIG_KEY_WRITES, [])
-                                    if w[0] in (NULL_TASK_ID, task_id)
-                                ],
-                                CONFIG_KEY_SCRATCHPAD: {},
+                                CONFIG_KEY_RESUME_VALUE: next(
+                                    (
+                                        v
+                                        for tid, c, v in pending_writes
+                                        if tid in (NULL_TASK_ID, task_id)
+                                        and c == RESUME
+                                    ),
+                                    MISSING,
+                                ),
                             },
                         ),
                         triggers,
@@ -726,7 +720,6 @@ def prepare_single_task(
                         None,
                         task_id,
                         task_path,
-                        writers=proc.flat_writers,
                     )
             else:
                 return PregelTask(task_id, name, task_path)

libs/langgraph/langgraph/pregel/executor.py

@@ -20,7 +20,7 @@ from langchain_core.runnables import RunnableConfig
 from langchain_core.runnables.config import get_executor_for_config
 from typing_extensions import ParamSpec
 
-from langgraph.errors import GraphBubbleUp
+from langgraph.errors import GraphInterrupt
 
 P = ParamSpec("P")
 T = TypeVar("T")
@@ -68,7 +68,7 @@ class BackgroundExecutor(ContextManager):
     def done(self, task: concurrent.futures.Future) -> None:
         try:
             task.result()
-        except GraphBubbleUp:
+        except GraphInterrupt:
             # This exception is an interruption signal, not an error
             # so we don't want to re-raise it on exit
             self.tasks.pop(task)
@@ -155,7 +155,7 @@ class AsyncBackgroundExecutor(AsyncContextManager):
             if exc := task.exception():
                 # This exception is an interruption signal, not an error
                 # so we don't want to re-raise it on exit
-                if isinstance(exc, GraphBubbleUp):
+                if isinstance(exc, GraphInterrupt):
                     self.tasks.pop(task)
             else:
                 self.tasks.pop(task)

libs/langgraph/langgraph/pregel/io.py

@@ -4,7 +4,6 @@ from uuid import UUID
 from langchain_core.runnables.utils import AddableDict
 
 from langgraph.channels.base import BaseChannel, EmptyChannelError
-from langgraph.checkpoint.base import PendingWrite
 from langgraph.constants import (
     EMPTY_SEQ,
     ERROR,
@@ -16,7 +15,6 @@ from langgraph.constants import (
     TAG_HIDDEN,
     TASKS,
 )
-from langgraph.errors import InvalidUpdateError
 from langgraph.pregel.log import logger
 from langgraph.types import Command, PregelExecutableTask, Send
 
@@ -67,31 +65,24 @@ def read_channels(
 
 
 def map_command(
-    cmd: Command, pending_writes: list[PendingWrite]
+    cmd: Command,
 ) -> Iterator[tuple[str, str, Any]]:
     """Map input chunk to a sequence of pending writes in the form (channel, value)."""
-    if cmd.graph == Command.PARENT:
-        raise InvalidUpdateError("There is not parent graph")
-    if cmd.goto:
-        if isinstance(cmd.goto, (tuple, list)):
-            sends = cmd.goto
+    if cmd.send:
+        if isinstance(cmd.send, (tuple, list)):
+            sends = cmd.send
         else:
-            sends = [cmd.goto]
+            sends = [cmd.send]
         for send in sends:
             if not isinstance(send, Send):
                 raise TypeError(
-                    f"In Command.goto, expected Send, got {type(send).__name__}"
+                    f"In Command.send, expected Send, got {type(send).__name__}"
                 )
             yield (NULL_TASK_ID, PUSH if FF_SEND_V2 else TASKS, send)
-        # TODO handle goto str for state graph
     if cmd.resume:
         if isinstance(cmd.resume, dict) and all(is_task_id(k) for k in cmd.resume):
             for tid, resume in cmd.resume.items():
-                existing: list[Any] = next(
-                    (w[2] for w in pending_writes if w[0] == tid and w[1] == RESUME), []
-                )
-                existing.append(resume)
-                yield (tid, RESUME, existing)
+                yield (tid, RESUME, resume)
         else:
             yield (NULL_TASK_ID, RESUME, cmd.resume)
     if cmd.update:

libs/langgraph/langgraph/pregel/loop.py

@@ -26,7 +26,6 @@ from typing_extensions import ParamSpec, Self
 
 from langgraph.channels.base import BaseChannel
 from langgraph.checkpoint.base import (
-    WRITES_IDX_MAP,
     BaseCheckpointSaver,
     ChannelVersions,
     Checkpoint,
@@ -264,28 +263,8 @@ class PregelLoop(LoopProtocol):
         """Put writes for a task, to be read by the next tick."""
         if not writes:
             return
-        # deduplicate writes to special channels, last write wins
-        if all(w[0] in WRITES_IDX_MAP for w in writes):
-            writes = list({w[0]: w for w in writes}.values())
         # save writes
-        for c, v in writes:
-            if (
-                c in WRITES_IDX_MAP
-                and (
-                    idx := next(
-                        (
-                            i
-                            for i, w in enumerate(self.checkpoint_pending_writes)
-                            if w[0] == task_id and w[1] == c
-                        ),
-                        None,
-                    )
-                )
-                is not None
-            ):
-                self.checkpoint_pending_writes[idx] = (task_id, c, v)
-            else:
-                self.checkpoint_pending_writes.append((task_id, c, v))
+        self.checkpoint_pending_writes.extend((task_id, k, v) for k, v in writes)
         if self.checkpointer_put_writes is not None:
             self.submit(
                 self.checkpointer_put_writes,
@@ -557,7 +536,7 @@ class PregelLoop(LoopProtocol):
         elif isinstance(self.input, Command):
             writes: defaultdict[str, list[tuple[str, Any]]] = defaultdict(list)
             # group writes by task ID
-            for tid, c, v in map_command(self.input, self.checkpoint_pending_writes):
+            for tid, c, v in map_command(self.input):
                 writes[tid].append((c, v))
             if not writes:
                 raise EmptyInputError("Received empty Command input")

libs/langgraph/langgraph/pregel/remote.py

@@ -1,4 +1,3 @@
-from dataclasses import asdict
 from typing import (
     Any,
     AsyncIterator,
@@ -28,7 +27,6 @@ from langgraph_sdk.client import (
     get_sync_client,
 )
 from langgraph_sdk.schema import Checkpoint, ThreadState
-from langgraph_sdk.schema import Command as CommandSDK
 from langgraph_sdk.schema import StreamMode as StreamModeSDK
 from typing_extensions import Self
 
@@ -43,7 +41,7 @@ from langgraph.constants import (
 from langgraph.errors import GraphInterrupt
 from langgraph.pregel.protocol import PregelProtocol
 from langgraph.pregel.types import All, PregelTask, StateSnapshot, StreamMode
-from langgraph.types import Command, Interrupt, StreamProtocol
+from langgraph.types import Interrupt, StreamProtocol
 from langgraph.utils.config import merge_configs
 
 
@@ -575,7 +573,6 @@ class RemoteGraph(PregelProtocol):
         interrupt_before: Optional[Union[All, Sequence[str]]] = None,
         interrupt_after: Optional[Union[All, Sequence[str]]] = None,
         subgraphs: bool = False,
-        **kwargs: Any,
     ) -> Iterator[Union[dict[str, Any], Any]]:
         """Create a run and stream the results.
 
@@ -590,7 +587,6 @@ class RemoteGraph(PregelProtocol):
             interrupt_before: Interrupt the graph before these nodes.
             interrupt_after: Interrupt the graph after these nodes.
             subgraphs: Stream from subgraphs.
-            **kwargs: Additional params to pass to client.runs.stream.
 
         Yields:
             The output of the graph.
@@ -601,24 +597,17 @@ class RemoteGraph(PregelProtocol):
         stream_modes, requested, req_single, stream = self._get_stream_modes(
             stream_mode, config
         )
-        if isinstance(input, Command):
-            command: Optional[CommandSDK] = cast(CommandSDK, asdict(input))
-            input = None
-        else:
-            command = None
 
         for chunk in sync_client.runs.stream(
             thread_id=sanitized_config["configurable"].get("thread_id"),
             assistant_id=self.name,
             input=input,
-            command=command,
             config=sanitized_config,
             stream_mode=stream_modes,
             interrupt_before=interrupt_before,
             interrupt_after=interrupt_after,
             stream_subgraphs=subgraphs or stream is not None,
             if_not_exists="create",
-            **kwargs,
         ):
             # split mode and ns
             if NS_SEP in chunk.event:
@@ -667,7 +656,6 @@ class RemoteGraph(PregelProtocol):
         interrupt_before: Optional[Union[All, Sequence[str]]] = None,
         interrupt_after: Optional[Union[All, Sequence[str]]] = None,
         subgraphs: bool = False,
-        **kwargs: Any,
     ) -> AsyncIterator[Union[dict[str, Any], Any]]:
         """Create a run and stream the results.
 
@@ -682,7 +670,6 @@ class RemoteGraph(PregelProtocol):
             interrupt_before: Interrupt the graph before these nodes.
             interrupt_after: Interrupt the graph after these nodes.
             subgraphs: Stream from subgraphs.
-            **kwargs: Additional params to pass to client.runs.stream.
 
         Yields:
             The output of the graph.
@@ -693,24 +680,17 @@ class RemoteGraph(PregelProtocol):
         stream_modes, requested, req_single, stream = self._get_stream_modes(
             stream_mode, config
         )
-        if isinstance(input, Command):
-            command: Optional[CommandSDK] = cast(CommandSDK, asdict(input))
-            input = None
-        else:
-            command = None
 
         async for chunk in client.runs.stream(
             thread_id=sanitized_config["configurable"].get("thread_id"),
             assistant_id=self.name,
             input=input,
-            command=command,
             config=sanitized_config,
             stream_mode=stream_modes,
             interrupt_before=interrupt_before,
             interrupt_after=interrupt_after,
             stream_subgraphs=subgraphs or stream is not None,
             if_not_exists="create",
-            **kwargs,
         ):
             # split mode and ns
             if NS_SEP in chunk.event:
@@ -773,16 +753,18 @@ class RemoteGraph(PregelProtocol):
         *,
         interrupt_before: Optional[Union[All, Sequence[str]]] = None,
         interrupt_after: Optional[Union[All, Sequence[str]]] = None,
-        **kwargs: Any,
     ) -> Union[dict[str, Any], Any]:
         """Create a run, wait until it finishes and return the final state.
 
+        This method calls `POST /threads/{thread_id}/runs/wait` if a `thread_id`
+        is speciffed in the `configurable` field of the config or
+        `POST /runs/wait` otherwise.
+
         Args:
             input: Input to the graph.
             config: A `RunnableConfig` for graph invocation.
             interrupt_before: Interrupt the graph before these nodes.
             interrupt_after: Interrupt the graph after these nodes.
-            **kwargs: Additional params to pass to RemoteGraph.stream.
 
         Returns:
             The output of the graph.
@@ -793,7 +775,6 @@ class RemoteGraph(PregelProtocol):
             interrupt_before=interrupt_before,
             interrupt_after=interrupt_after,
             stream_mode="values",
-            **kwargs,
         ):
             pass
         try:
@@ -808,16 +789,18 @@ class RemoteGraph(PregelProtocol):
         *,
         interrupt_before: Optional[Union[All, Sequence[str]]] = None,
         interrupt_after: Optional[Union[All, Sequence[str]]] = None,
-        **kwargs: Any,
     ) -> Union[dict[str, Any], Any]:
         """Create a run, wait until it finishes and return the final state.
 
+        This method calls `POST /threads/{thread_id}/runs/wait` if a `thread_id`
+        is speciffed in the `configurable` field of the config or
+        `POST /runs/wait` otherwise.
+
         Args:
             input: Input to the graph.
             config: A `RunnableConfig` for graph invocation.
             interrupt_before: Interrupt the graph before these nodes.
             interrupt_after: Interrupt the graph after these nodes.
-            **kwargs: Additional params to pass to RemoteGraph.astream.
 
         Returns:
             The output of the graph.
@@ -828,7 +811,6 @@ class RemoteGraph(PregelProtocol):
             interrupt_before=interrupt_before,
             interrupt_after=interrupt_after,
             stream_mode="values",
-            **kwargs,
         ):
             pass
         try:

libs/langgraph/langgraph/pregel/retry.py

@@ -1,9 +1,7 @@
 import asyncio
 import logging
 import random
-import sys
 import time
-from dataclasses import replace
 from functools import partial
 from typing import Any, Callable, Optional, Sequence
 
@@ -12,14 +10,12 @@ from langgraph.constants import (
     CONFIG_KEY_CHECKPOINT_NS,
     CONFIG_KEY_RESUMING,
     CONFIG_KEY_SEND,
-    NS_SEP,
 )
-from langgraph.errors import _SEEN_CHECKPOINT_NS, GraphBubbleUp, ParentCommand
-from langgraph.types import Command, PregelExecutableTask, RetryPolicy
+from langgraph.errors import _SEEN_CHECKPOINT_NS, GraphInterrupt
+from langgraph.types import PregelExecutableTask, RetryPolicy
 from langgraph.utils.config import patch_configurable
 
 logger = logging.getLogger(__name__)
-SUPPORTS_EXC_NOTES = sys.version_info >= (3, 11)
 
 
 def run_with_retry(
@@ -44,26 +40,10 @@ def run_with_retry(
             task.proc.invoke(task.input, config)
             # if successful, end
             break
-        except ParentCommand as exc:
-            ns: str = config[CONF][CONFIG_KEY_CHECKPOINT_NS]
-            cmd = exc.args[0]
-            if cmd.graph == ns:
-                # this command is for the current graph, handle it
-                for w in task.writers:
-                    w.invoke(cmd, config)
-                break
-            elif cmd.graph == Command.PARENT:
-                # this command is for the parent graph, assign it to the parent
-                parent_ns = NS_SEP.join(ns.split(NS_SEP)[:-1])
-                exc.args = (replace(cmd, graph=parent_ns),)
-            # bubble up
-            raise
-        except GraphBubbleUp:
+        except GraphInterrupt:
             # if interrupted, end
             raise
         except Exception as exc:
-            if SUPPORTS_EXC_NOTES:
-                exc.add_note(f"During task with name '{task.name}' and id '{task.id}'")
             if retry_policy is None:
                 raise
             # increment attempts
@@ -138,26 +118,10 @@ async def arun_with_retry(
                 await task.proc.ainvoke(task.input, config)
             # if successful, end
             break
-        except ParentCommand as exc:
-            ns: str = config[CONF][CONFIG_KEY_CHECKPOINT_NS]
-            cmd = exc.args[0]
-            if cmd.graph == ns:
-                # this command is for the current graph, handle it
-                for w in task.writers:
-                    w.invoke(cmd, config)
-                break
-            elif cmd.graph == Command.PARENT:
-                # this command is for the parent graph, assign it to the parent
-                parent_ns = NS_SEP.join(ns.split(NS_SEP)[:-1])
-                exc.args = (replace(cmd, graph=parent_ns),)
-            # bubble up
-            raise
-        except GraphBubbleUp:
+        except GraphInterrupt:
             # if interrupted, end
             raise
         except Exception as exc:
-            if SUPPORTS_EXC_NOTES:
-                exc.add_note(f"During task with name '{task.name}' and id '{task.id}'")
             if retry_policy is None:
                 raise
             # increment attempts

libs/langgraph/langgraph/pregel/runner.py

@@ -21,10 +21,9 @@ from langgraph.constants import (
     INTERRUPT,
     NO_WRITES,
     PUSH,
-    RESUME,
     TAG_HIDDEN,
 )
-from langgraph.errors import GraphBubbleUp, GraphInterrupt
+from langgraph.errors import GraphDelegate, GraphInterrupt
 from langgraph.pregel.executor import Submit
 from langgraph.pregel.retry import arun_with_retry, run_with_retry
 from langgraph.types import PregelExecutableTask, RetryPolicy
@@ -298,10 +297,8 @@ class PregelRunner:
             if isinstance(exception, GraphInterrupt):
                 # save interrupt to checkpointer
                 if interrupts := [(INTERRUPT, i) for i in exception.args[0]]:
-                    if resumes := [w for w in task.writes if w[0] == RESUME]:
-                        interrupts.extend(resumes)
                     self.put_writes(task.id, interrupts)
-            elif isinstance(exception, GraphBubbleUp):
+            elif isinstance(exception, GraphDelegate):
                 raise exception
             else:
                 # save error to checkpointer
@@ -327,7 +324,7 @@ def _should_stop_others(
         if fut.cancelled():
             return True
         if exc := fut.exception():
-            return not isinstance(exc, GraphBubbleUp)
+            return not isinstance(exc, GraphInterrupt)
     else:
         return False
 

libs/langgraph/langgraph/types.py

@@ -5,7 +5,6 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
-    ClassVar,
     Generic,
     Hashable,
     Literal,
@@ -13,7 +12,6 @@ from typing import (
     Optional,
     Sequence,
     Type,
-    TypedDict,
     TypeVar,
     Union,
     cast,
@@ -22,16 +20,11 @@ from typing import (
 from langchain_core.runnables import Runnable, RunnableConfig
 from typing_extensions import Self
 
-from langgraph.checkpoint.base import (
-    BaseCheckpointSaver,
-    CheckpointMetadata,
-    PendingWrite,
-)
+from langgraph.checkpoint.base import BaseCheckpointSaver, CheckpointMetadata
 
 if TYPE_CHECKING:
     from langgraph.store.base import BaseStore
 
-
 All = Literal["*"]
 """Special value to indicate that graph should interrupt on all nodes."""
 
@@ -147,7 +140,6 @@ class PregelExecutableTask(NamedTuple):
     id: str
     path: tuple[Union[str, int, tuple], ...]
     scheduled: bool = False
-    writers: Sequence[Runnable] = ()
 
 
 class StateSnapshot(NamedTuple):
@@ -245,27 +237,11 @@ N = TypeVar("N", bound=Hashable)
 
 @dataclasses.dataclass(**_DC_KWARGS)
 class Command(Generic[N]):
-    """One or more commands to update the graph's state and send messages to nodes.
+    """One or more commands to update the graph's state and send messages to nodes."""
 
-    Args:
-        graph: graph to send the command to. Supported values are:
-
-            - None: the current graph (default)
-            - GraphCommand.PARENT: closest parent graph
-        update: update to apply to the graph's state.
-        resume: value to resume execution with. To be used together with [`interrupt()`][langgraph.types.interrupt].
-        goto: can be one of the following:
-
-            - name of the node to navigate to next (any node that belongs to the specified `graph`)
-            - sequence of node names to navigate to next
-            - `Send` object (to execute a node with the input provided)
-            - sequence of `Send` objects
-    """
-
-    graph: Optional[str] = None
     update: Optional[dict[str, Any]] = None
+    send: Union[Send, Sequence[Send]] = ()
     resume: Optional[Union[Any, dict[str, Any]]] = None
-    goto: Union[Send, Sequence[Union[Send, str]], str] = ()
 
     def __repr__(self) -> str:
         # get all non-None values
@@ -276,8 +252,6 @@ class Command(Generic[N]):
         )
         return f"Command({contents})"
 
-    PARENT: ClassVar[Literal["__parent__"]] = "__parent__"
-
 
 StreamChunk = tuple[tuple[str, ...], str, Any]
 
@@ -321,59 +295,26 @@ class LoopProtocol:
         self.stop = stop
 
 
-class PregelScratchpad(TypedDict, total=False):
-    interrupt_counter: int
-    used_null_resume: bool
-    resume: list[Any]
-
-
 def interrupt(value: Any) -> Any:
     from langgraph.constants import (
         CONFIG_KEY_CHECKPOINT_NS,
-        CONFIG_KEY_SCRATCHPAD,
-        CONFIG_KEY_SEND,
-        CONFIG_KEY_TASK_ID,
-        CONFIG_KEY_WRITES,
+        CONFIG_KEY_RESUME_VALUE,
+        MISSING,
         NS_SEP,
-        NULL_TASK_ID,
-        RESUME,
     )
     from langgraph.errors import GraphInterrupt
     from langgraph.utils.config import get_configurable
 
     conf = get_configurable()
-    # track interrupt index
-    scratchpad: PregelScratchpad = conf[CONFIG_KEY_SCRATCHPAD]
-    if "interrupt_counter" not in scratchpad:
-        scratchpad["interrupt_counter"] = 0
+    if (resume := conf.get(CONFIG_KEY_RESUME_VALUE, MISSING)) and resume is not MISSING:
+        return resume
     else:
-        scratchpad["interrupt_counter"] += 1
-    idx = scratchpad["interrupt_counter"]
-    # find previous resume values
-    task_id = conf[CONFIG_KEY_TASK_ID]
-    writes: list[PendingWrite] = conf[CONFIG_KEY_WRITES]
-    scratchpad.setdefault(
-        "resume", next((w[2] for w in writes if w[0] == task_id and w[1] == RESUME), [])
-    )
-    if scratchpad["resume"]:
-        if idx < len(scratchpad["resume"]):
-            return scratchpad["resume"][idx]
-    # find current resume value
-    if not scratchpad.get("used_null_resume"):
-        scratchpad["used_null_resume"] = True
-        for tid, c, v in sorted(writes, key=lambda x: x[0], reverse=True):
-            if tid == NULL_TASK_ID and c == RESUME:
-                assert len(scratchpad["resume"]) == idx, (scratchpad["resume"], idx)
-                scratchpad["resume"].append(v)
-                conf[CONFIG_KEY_SEND]([(RESUME, scratchpad["resume"])])
-                return v
-    # no resume value found
-    raise GraphInterrupt(
-        (
-            Interrupt(
-                value=value,
-                resumable=True,
-                ns=cast(str, conf[CONFIG_KEY_CHECKPOINT_NS]).split(NS_SEP),
-            ),
+        raise GraphInterrupt(
+            (
+                Interrupt(
+                    value=value,
+                    resumable=True,
+                    ns=cast(str, conf[CONFIG_KEY_CHECKPOINT_NS]).split(NS_SEP),
+                ),
+            )
         )
-    )