feat: langgraph.json schema

.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/_lint.yml

@@ -42,6 +42,7 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
           poetry-version: ${{ env.POETRY_VERSION }}
+          working-directory: ${{ inputs.working-directory }}
           cache-key: lint-${{ inputs.working-directory }}
 
       - name: Check Poetry File

.github/workflows/_test.yml

@@ -31,6 +31,7 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
           poetry-version: ${{ env.POETRY_VERSION }}
+          working-directory: ${{ inputs.working-directory }}
           cache-key: test-${{ inputs.working-directory }}
       - name: Login to Docker Hub
         uses: docker/login-action@v3

.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/_test_release.yml

@@ -29,6 +29,7 @@ jobs:
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           poetry-version: ${{ env.POETRY_VERSION }}
+          working-directory: ${{ inputs.working-directory }}
           cache-key: release
 
       # We want to keep this build stage *separate* from the release stage,

.github/workflows/release.yml

@@ -31,6 +31,7 @@ jobs:
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           poetry-version: ${{ env.POETRY_VERSION }}
+          working-directory: ${{ inputs.working-directory }}
           cache-key: release
 
       # We want to keep this build stage *separate* from the release stage,
@@ -168,6 +169,7 @@ jobs:
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           poetry-version: ${{ env.POETRY_VERSION }}
+          working-directory: ${{ inputs.working-directory }}
 
       - name: Import published package
         shell: bash
@@ -254,6 +256,7 @@ jobs:
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           poetry-version: ${{ env.POETRY_VERSION }}
+          working-directory: ${{ inputs.working-directory }}
           cache-key: release
 
       - uses: actions/download-artifact@v4
@@ -295,6 +298,7 @@ jobs:
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           poetry-version: ${{ env.POETRY_VERSION }}
+          working-directory: ${{ inputs.working-directory }}
           cache-key: release
 
       - uses: actions/download-artifact@v4

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

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/deployment/setup.md

@@ -36,8 +36,8 @@ Dependencies can optionally be specified in one of the following files: `pyproje
 The dependencies below will be included in the image, you can also use them in your code, as long as with a compatible version range:
 
 ```
-langgraph>=0.2.56,<0.3.0
-langgraph-checkpoint>=2.0.5,<3.0
+langgraph>=0.2.30,<0.3.0
+langgraph-checkpoint>=1.0.14
 langchain-core>=0.2.38,<0.4.0
 langsmith>=0.1.63
 orjson>=3.9.7

docs/docs/cloud/deployment/setup_pyproject.md

@@ -36,8 +36,8 @@ Dependencies can optionally be specified in one of the following files: `pyproje
 The dependencies below will be included in the image, you can also use them in your code, as long as with a compatible version range:
 
 ```
-langgraph>=0.2.56,<0.3.0
-langgraph-checkpoint>=2.0.5,<3.0
+langgraph>=0.2.30,<0.3.0
+langgraph-checkpoint>=1.0.14
 langchain-core>=0.2.38,<0.4.0
 langsmith>=0.1.63
 orjson>=3.9.7

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/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`.
@@ -134,11 +82,6 @@ langgraph [OPTIONS] COMMAND [ARGS]
 
 Run LangGraph API server in development mode with hot reloading and debugging capabilities. This lightweight server requires no Docker installation and is suitable for development and testing. State is persisted to a local directory.
 
-!!! note "Python only"
-
-    Currently, the CLI only supports Python >= 3.11.
-    JS support is coming soon.
-
 **Installation**
 
 This command requires the "inmem" extra to be installed:
@@ -155,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`
 
@@ -179,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. |
@@ -198,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`
 
@@ -226,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/langgraph_cli.md

@@ -33,11 +33,6 @@ The `langgraph build` command builds a Docker image for the [LangGraph API serve
 !!! note "New in version 0.1.55"
     The `langgraph dev` command was introduced in langgraph-cli version 0.1.55.
 
-!!! note "Python only"
-
-    Currently, the CLI only supports Python >= 3.11.
-    JS support is coming soon.
-
 The `langgraph dev` command starts a lightweight development server that requires no Docker installation. This server is ideal for rapid development and testing, with features like:
 
 - Hot reloading: Changes to your code are automatically detected and reloaded

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,64 +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"
-    )
-```
-
-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["my_other_node"]]`. This is necessary for the graph rendering and tells LangGraph that `my_node` can navigate to `my_other_node`.
-
-Check out this [how-to guide](../how-tos/command.ipynb) for an end-to-end example of how to use `Command`.
-
-### When should I use Command instead of conditional edges?
-
-Use `Command` when you need to **both** update the graph state **and** route to a different node. For example, when implementing [multi-agent handoffs](./multi_agent.md#handoffs) where it's important to route to a different agent and pass some information to that agent.
-
-Use [conditional edges](#conditional-edges) to route between nodes conditionally without updating the state.
-
-### Using inside tools
-
-A common use case is updating graph state from inside a tool. For example, in a customer support application you might want to look up customer information based on their account number or ID in the beginning of the conversation. To update the graph state from the tool, you can return `Command(update={"my_custom_key": "foo", "messages": [...]})` from the tool:
-
-```python
-@tool
-def lookup_user_info(tool_call_id: Annotated[str, InjectedToolCallId], config: RunnableConfig):
-    """Use this to look up user information to better assist them with their questions."""
-    user_info = get_user_info(config.get("configurable", {}).get("user_id"))
-    return Command(
-        update={
-            # update the state keys
-            "user_info": user_info,
-            # update the message history
-            "messages": [ToolMessage("Successfully looked up user information", tool_call_id=tool_call_id)]
-        }
-    )
-```
-
-!!! important
-    You MUST include `messages` (or any state key used for the message history) in `Command.update` when returning `Command` from a tool and the list of messages in `messages` MUST contain a `ToolMessage`. This is necessary for the resulting message history to be valid (LLM providers require AI messages with tool calls to be followed by the tool result messages).
-
-If you are using tools that update state via `Command`, we recommend using prebuilt [`ToolNode`][langgraph.prebuilt.tool_node.ToolNode] which automatically handles tools returning `Command` objects and propagates them to the graph state. If you're writing a custom node that calls tools, you would need to manually propagate `Command` objects returned by the tools as the update from node.
-
 ## 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

@@ -26,88 +26,18 @@ There are several ways to connect agents in a multi-agent system:
 - **Hierarchical**: you can define a multi-agent system with [a supervisor of supervisors](https://langchain-ai.github.io/langgraph/tutorials/multi_agent/hierarchical_agent_teams/). This is a generalization of the supervisor architecture and allows for more complex control flows.
 - **Custom multi-agent workflow**: each agent communicates with only a subset of agents. Parts of the flow are deterministic, and only some agents can decide which other agents to call next.
 
-### Handoffs
-
-In multi-agent architectures, agents can be represented as graph nodes. Each agent node executes its step(s) and decides whether to finish execution or route to another agent, including potentially routing to itself (e.g., running in a loop). A common pattern in multi-agent interactions is handoffs, where one agent hands off control to another. Handoffs allow you to specify:
-
-- __destination__: target agent to navigate to (e.g., name of the node to go to)
-- __payload__: [information to pass to that agent](#communication-between-agents) (e.g., state update)
-
-To implement handoffs in LangGraph, agent nodes can return [`Command`](./low_level.md#command) object that allows you to combine both control flow and state updates:
-
-```python
-def agent(state) -> Command[Literal["agent", "another_agent"]]:
-    # the condition for routing/halting can be anything, e.g. LLM tool call / structured output, etc.
-    goto = get_next_agent(...)  # 'agent' / 'another_agent'
-    return Command(
-        # Specify which agent to call next
-        goto=goto,
-        # Update the graph state
-        update={"my_state_key": "my_state_value"}
-    )
-```
-
-In a more complex scenario where each agent node is itself a graph (i.e., a [subgraph](./low_level.md#subgraphs)), a node in one of the agent subgraphs might want to navigate to a different agent. For example, if you have two agents, `alice` and `bob` (subgraph nodes in a parent graph), and `alice` needs to navigate to `bob`, you can set `graph=Command.PARENT` in the `Command` object:
-
-```python
-def some_node_inside_alice(state)
-    return Command(
-        goto="bob",
-        update={"my_state_key": "my_state_value"},
-        # specify which graph to navigate to (defaults to the current graph)
-        graph=Command.PARENT,
-    )
-```
-
-!!! note
-    If you need to support visualization for subgraphs communicating using `Command(graph=Command.PARENT)` you would need to wrap them in a node function with `Command` annotation, e.g. instead of this:
-
-    ```python
-    builder.add_node(alice)
-    ```
-
-    you would need to do this:
-
-    ```python
-    def call_alice(state) -> Command[Literal["bob"]]:
-        return alice.invoke(state)
-
-    builder.add_node("alice", call_alice)
-    ```
-
-#### Handoffs as tools
-
-One of the most common agent types is a ReAct-style tool-calling agents. For those types of agents, a common pattern is wrapping a handoff in a tool call, e.g.:
-
-```python
-def transfer_to_bob(state):
-    """Transfer to bob."""
-    return Command(
-        goto="bob",
-        update={"my_state_key": "my_state_value"},
-        graph=Command.PARENT,
-    )
-```
-
-This is a special case of updating the graph state from tools where in addition the state update, the control flow is included as well.
-
-!!! important
-
-    If you want to use tools that return `Command`, you can either use prebuilt [`create_react_agent`][langgraph.prebuilt.chat_agent_executor.create_react_agent] / [`ToolNode`][langgraph.prebuilt.tool_node.ToolNode] components, or implement your own tool-executing node that collects `Command` objects returned by the tools and returns a list of them, e.g.:
-
-```python
-def call_tools(state):
-    ...
-    commands = [tools_by_name[call["name"].invoke(call, config={"coerce_tool_content": False}) for tool_call in tool_calls]
-    return commands
-```
-
-Let's now take a closer look at the different multi-agent architectures.
-
 ### 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
+
+In this architecture, we define agents as nodes and add a supervisor node (LLM) that decides which agent nodes should be called next. We use [conditional edges](./low_level.md#conditional-edges) to route execution to the appropriate agent node based on supervisor's decision. This architecture also lends itself well to running multiple agents in parallel or using [map-reduce](../how-tos/map-reduce.ipynb) pattern.
 
 ```python
 from typing import Literal
@@ -116,83 +46,39 @@ from langgraph.graph import StateGraph, MessagesState, START
 
 model = ChatOpenAI()
 
-def agent_1(state: MessagesState) -> Command[Literal["agent_2", "agent_3", END]]:
+class AgentState(MessagesState):
+    next: Literal["agent_1", "agent_2", "__end__"]
+
+def supervisor(state: AgentState):
     # you can pass relevant parts of the state to the LLM (e.g., state["messages"])
     # to determine which agent to call next. a common pattern is to call the model
     # with a structured output (e.g. force it to return an output with a "next_agent" field)
     response = model.invoke(...)
-    # route to one of the agents or exit based on the LLM's decision
-    # if the LLM returns "__end__", the graph will finish execution
-    return Command(
-        goto=response["next_agent"],
-        update={"messages": [response["content"]]},
-    )
+    # the "next" key will be used by the conditional edges to route execution
+    # to the appropriate agent
+    return {"next": response["next_agent"]}
 
-def agent_2(state: MessagesState) -> Command[Literal["agent_1", "agent_3", END]]:
-    response = model.invoke(...)
-    return Command(
-        goto=response["next_agent"],
-        update={"messages": [response["content"]]},
-    )
-
-def agent_3(state: MessagesState) -> Command[Literal["agent_1", "agent_2", END]]:
-    ...
-    return Command(
-        goto=response["next_agent"],
-        update={"messages": [response["content"]]},
-    )
-
-builder = StateGraph(MessagesState)
-builder.add_node(agent_1)
-builder.add_node(agent_2)
-builder.add_node(agent_3)
-
-builder.add_edge(START, "agent_1")
-network = builder.compile()
-```
-
-### Supervisor
-
-In this architecture, we define agents as nodes and add a supervisor node (LLM) that decides which agent nodes should be called next. We use [`Command`](./low_level.md#command) to route execution to the appropriate agent node based on supervisor's decision. This architecture also lends itself well to running multiple agents in parallel or using [map-reduce](../how-tos/map-reduce.ipynb) pattern.
-
-```python
-from typing import Literal
-from langchain_openai import ChatOpenAI
-from langgraph.graph import StateGraph, MessagesState, START, END
-
-model = ChatOpenAI()
-
-def supervisor(state: MessagesState) -> Command[Literal["agent_1", "agent_2", END]]:
-    # you can pass relevant parts of the state to the LLM (e.g., state["messages"])
-    # to determine which agent to call next. a common pattern is to call the model
-    # with a structured output (e.g. force it to return an output with a "next_agent" field)
-    response = model.invoke(...)
-    # route to one of the agents or exit based on the supervisor's decision
-    # if the supervisor returns "__end__", the graph will finish execution
-    return Command(goto=response["next_agent"])
-
-def agent_1(state: MessagesState) -> Command[Literal["supervisor"]]:
+def agent_1(state: AgentState):
     # you can pass relevant parts of the state to the LLM (e.g., state["messages"])
     # and add any additional logic (different models, custom prompts, structured output, etc.)
     response = model.invoke(...)
-    return Command(
-        goto="supervisor",
-        update={"messages": [response]},
-    )
+    return {"messages": [response]}
 
-def agent_2(state: MessagesState) -> Command[Literal["supervisor"]]:
+def agent_2(state: AgentState):
     response = model.invoke(...)
-    return Command(
-        goto="supervisor",
-        update={"messages": [response]},
-    )
+    return {"messages": [response]}
 
-builder = StateGraph(MessagesState)
+builder = StateGraph(AgentState)
 builder.add_node(supervisor)
 builder.add_node(agent_1)
 builder.add_node(agent_2)
 
 builder.add_edge(START, "supervisor")
+# route to one of the agents or exit based on the supervisor's decisiion
+# if the supervisor returns "__end__", the graph will finish execution
+builder.add_conditional_edges("supervisor", lambda state: state["next"])
+builder.add_edge("agent_1", "supervisor")
+builder.add_edge("agent_2", "supervisor")
 
 supervisor = builder.compile()
 ```
@@ -240,29 +126,37 @@ To address this, you can design your system _hierarchically_. For example, you c
 ```python
 from typing import Literal
 from langchain_openai import ChatOpenAI
-from langgraph.graph import StateGraph, MessagesState, START, END
+from langgraph.graph import StateGraph, MessagesState, START
 
 model = ChatOpenAI()
 
 # define team 1 (same as the single supervisor example above)
+class Team1State(MessagesState):
+    next: Literal["team_1_agent_1", "team_1_agent_2", "__end__"]
 
-def team_1_supervisor(state: MessagesState) -> Command[Literal["team_1_agent_1", "team_1_agent_2", END]]:
+def team_1_supervisor(state: Team1State):
     response = model.invoke(...)
-    return Command(goto=response["next_agent"])
+    return {"next": response["next_agent"]}
 
-def team_1_agent_1(state: MessagesState) -> Command[Literal["team_1_supervisor"]]:
+def team_1_agent_1(state: Team1State):
     response = model.invoke(...)
-    return Command(goto="team_1_supervisor", update={"messages": [response]})
+    return {"messages": [response]}
 
-def team_1_agent_2(state: MessagesState) -> Command[Literal["team_1_supervisor"]]:
+def team_1_agent_2(state: Team1State):
     response = model.invoke(...)
-    return Command(goto="team_1_supervisor", update={"messages": [response]})
+    return {"messages": [response]}
 
 team_1_builder = StateGraph(Team1State)
 team_1_builder.add_node(team_1_supervisor)
 team_1_builder.add_node(team_1_agent_1)
 team_1_builder.add_node(team_1_agent_2)
 team_1_builder.add_edge(START, "team_1_supervisor")
+# route to one of the agents or exit based on the supervisor's decisiion
+# if the supervisor returns "__end__", the graph will finish execution
+team_1_builder.add_conditional_edges("team_1_supervisor", lambda state: state["next"])
+team_1_builder.add_edge("team_1_agent_1", "team_1_supervisor")
+team_1_builder.add_edge("team_1_agent_2", "team_1_supervisor")
+
 team_1_graph = team_1_builder.compile()
 
 # define team 2 (same as the single supervisor example above)
@@ -285,22 +179,31 @@ team_2_graph = team_2_builder.compile()
 
 # define top-level supervisor
 
-builder = StateGraph(MessagesState)
-def top_level_supervisor(state: MessagesState):
+class TopLevelState(MessagesState):
+    next: Literal["team_1", "team_2", "__end__"]
+
+builder = StateGraph(TopLevelState)
+def top_level_supervisor(state: TopLevelState):
     # you can pass relevant parts of the state to the LLM (e.g., state["messages"])
     # to determine which team to call next. a common pattern is to call the model
     # with a structured output (e.g. force it to return an output with a "next_team" field)
     response = model.invoke(...)
-    # route to one of the teams or exit based on the supervisor's decision
-    # if the supervisor returns "__end__", the graph will finish execution
-    return Command(goto=response["next_team"])
+    # the "next" key will be used by the conditional edges to route execution
+    # to the appropriate team
+    return {"next": response["next_team"]}
 
-builder = StateGraph(MessagesState)
+builder = StateGraph(TopLevelState)
 builder.add_node(top_level_supervisor)
 builder.add_node(team_1_graph)
 builder.add_node(team_2_graph)
 
 builder.add_edge(START, "top_level_supervisor")
+# route to one of the teams or exit based on the supervisor's decision
+# if the top-level supervisor returns "__end__", the graph will finish execution
+builder.add_conditional_edges("top_level_supervisor", lambda state: state["next"])
+builder.add_edge("team_1_graph", "top_level_supervisor")
+builder.add_edge("team_2_graph", "top_level_supervisor")
+
 graph = builder.compile()
 ```
 
@@ -310,7 +213,7 @@ In this architecture we add individual agents as graph nodes and define the orde
 
 - **Explicit control flow (normal edges)**: LangGraph allows you to explicitly define the control flow of your application (i.e. the sequence of how agents communicate) explicitly, via [normal graph edges](./low_level.md#normal-edges). This is the most deterministic variant of this architecture above — we always know which agent will be called next ahead of time.
 
-- **Dynamic control flow (Command)**: in LangGraph you can allow LLMs to decide parts of your application control flow. This can be achieved by using [`Command`](./low_level.md#command). A special case of this is a [supervisor tool-calling](#supervisor-tool-calling) architecture. In that case, the tool-calling LLM powering the supervisor agent will make decisions about the order in which the tools (agents) are being called.
+- **Dynamic control flow (conditional edges)**: in LangGraph you can allow LLMs to decide parts of your application control flow. This can be achieved by using [conditional edges](./low_level.md#conditional-edges). A special case of this is a [supervisor tool-calling](#supervisor-tool-calling) architecture. In that case, the tool-calling LLM powering the supervisor agent will make decisions about the order in which the tools (agents) are being called.
 
 ```python
 from langchain_openai import ChatOpenAI

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/template_applications.md

@@ -1,21 +1,14 @@
 # Template Applications
 
+!!! note Prerequisites
+
+    - [LangGraph Studio](./langgraph_studio.md)
+
 Templates are open source reference applications designed to help you get started quickly when building with LangGraph. They provide working examples of common agentic workflows that can be customized to your needs.
 
-You can create an application from a template using the LangGraph CLI.
+Templates can be accessed via [LangGraph Studio (macOS only)](langgraph_studio.md), or cloned directly from Github. You can download LangGraph Studio and see available templates [here](https://studio.langchain.com/).
 
-!!! 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
-```
-
-## Available Templates
+## Available templates
 
 | Template                  | Description                                                                              | Python                                                           | JS/TS                                                               |
 |---------------------------|------------------------------------------------------------------------------------------|------------------------------------------------------------------|---------------------------------------------------------------------|
@@ -24,39 +17,3 @@ pip install "langgraph-cli[inmem]==0.1.58" python-dotenv
 | **Memory Agent**          | A ReAct-style agent with an additional tool to store memories for use across threads.    | [Repo](https://github.com/langchain-ai/memory-agent)             | [Repo](https://github.com/langchain-ai/memory-agent-js)             |
 | **Retrieval Agent**       | An agent that includes a retrieval-based question-answering system.                      | [Repo](https://github.com/langchain-ai/retrieval-agent-template) | [Repo](https://github.com/langchain-ai/retrieval-agent-template-js) |
 | **Data-Enrichment Agent** | An agent that performs web searches and organizes its findings into a structured format. | [Repo](https://github.com/langchain-ai/data-enrichment)          | [Repo](https://github.com/langchain-ai/data-enrichment-js)          |
-
-
-## 🌱 Create a LangGraph App
-
-To create a new app from a template, use the `langgraph new` command.
-
-```bash
-langgraph new
-```
-
-## Next Steps
-
-Review the `README.md` file in the root of your new LangGraph app for more information about the template and how to customize it.
-
-After configuring the app properly and adding your API keys, you can start the app using the LangGraph CLI:
-
-```bash
-langgraph dev 
-```
-
-See the following guides for more information on how to deploy your app:
-
-- **[Launch Local LangGraph Server](../tutorials/langgraph-platform/local-server.md)**: This quick start guide shows how to start a LangGraph Server locally for the **ReAct Agent** template. The steps are similar for other templates.
-- **[Deploy to LangGraph Cloud](../cloud/quick_start.md)**: Deploy your LangGraph app using LangGraph Cloud.
- 
-### LangGraph Framework
-
-- **[LangGraph Concepts](../concepts/index.md)**: Learn the foundational concepts of LangGraph.
-- **[LangGraph How-to Guides](../how-tos/index.md)**: Guides for common tasks with LangGraph.
-
-### 📚 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.

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/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:
 
@@ -81,7 +78,6 @@ These how-to guides show common patterns for tool calling with LangGraph:
 - [How to handle tool calling errors](tool-calling-errors.ipynb)
 - [How to pass runtime values to tools](pass-run-time-values-to-tools.ipynb)
 - [How to pass config to tools](pass-config-to-tools.ipynb)
-- [How to update graph state from tools](update-state-from-tools.ipynb)
 - [How to handle large numbers of tools](many-tools.ipynb)
 
 ### Subgraphs
@@ -92,12 +88,6 @@ These how-to guides show common patterns for tool calling with LangGraph:
 - [How to view and update state in subgraphs](subgraphs-manage-state.ipynb)
 - [How to transform inputs and outputs of a subgraph](subgraph-transform-state.ipynb)
 
-### Multi-agent
-
-- [How to build a multi-agent network](multi-agent-network.ipynb)
-
-See the [multi-agent tutorials](../tutorials/index.md#multi-agent-systems) for implementations of other multi-agent architectures.
-
 ### State Management
 
 - [How to use Pydantic model as state](state-model.ipynb)
@@ -128,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).
 
@@ -150,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)
@@ -162,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.
@@ -208,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)
@@ -228,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
@@ -242,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/how-tos/update-state-from-tools.ipynb

@@ -1,383 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "7c58c957-83d8-44ff-8580-a9b3dd39a0a9",
-   "metadata": {},
-   "source": [
-    "# How to update graph state from tools"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "95f30587-8dd2-40be-920d-59539089c09f",
-   "metadata": {},
-   "source": [
-    "!!! info \"Prerequisites\"\n",
-    "    This guide assumes familiarity with the following:\n",
-    "    \n",
-    "    - [Command](../../concepts/low_level/#command)\n",
-    "\n",
-    "A common use case is updating graph state from inside a tool. For example, in a customer support application you might want to look up customer account number or ID in the beginning of the conversation. To update the graph state from the tool, you can return `Command(update={\"my_custom_key\": \"foo\", \"messages\": [...]})` from the tool:\n",
-    "\n",
-    "```python\n",
-    "@tool\n",
-    "def lookup_user_info(tool_call_id: Annotated[str, InjectedToolCallId], config: RunnableConfig):\n",
-    "    \"\"\"Use this to look up user information to better assist them with their questions.\"\"\"\n",
-    "    user_info = get_user_info(config)\n",
-    "    return Command(\n",
-    "        update={\n",
-    "            # update the state keys\n",
-    "            \"user_info\": user_info,\n",
-    "            # update the message history\n",
-    "            \"messages\": [ToolMessage(\"Successfully looked up user information\", tool_call_id=tool_call_id)]\n",
-    "        }\n",
-    "    )\n",
-    "```\n",
-    "\n",
-    "!!! important\n",
-    "\n",
-    "    If you want to use tools that return `Command` and update graph state, you can either use prebuilt [`create_react_agent`][langgraph.prebuilt.chat_agent_executor.create_react_agent] / [`ToolNode`][langgraph.prebuilt.tool_node.ToolNode] components, or implement your own tool-executing node that collects `Command` objects returned by the tools and returns a list of them, e.g.:\n",
-    "    \n",
-    "    ```python\n",
-    "    def call_tools(state):\n",
-    "        ...\n",
-    "        commands = [tools_by_name[call[\"name\"].invoke(call, config={\"coerce_tool_content\": False}) for tool_call in tool_calls]\n",
-    "        return commands\n",
-    "    ```\n",
-    "\n",
-    "This guide shows how you can do this using LangGraph's prebuilt components ([`create_react_agent`][langgraph.prebuilt.chat_agent_executor.create_react_agent] / [`ToolNode`][langgraph.prebuilt.tool_node.ToolNode]).\n",
-    "\n",
-    "!!! note\n",
-    "\n",
-    "    Support for tools that return [`Command`][langgraph.types.Command] was added in LangGraph `v0.2.57`.\n",
-    "\n",
-    "## Setup\n",
-    "\n",
-    "First, let's install the required packages and set our API keys:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "64500eca-1cdc-43d9-9401-f4cd9999881f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%%capture --no-stderr\n",
-    "%pip install -U langgraph langchain-openai"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "a3f92fb2-9175-47fa-9c7d-ad5f44bfd20e",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Please provide your OPENAI_API_KEY ········\n"
-     ]
-    }
-   ],
-   "source": [
-    "import os\n",
-    "import getpass\n",
-    "\n",
-    "\n",
-    "def _set_if_undefined(var: str):\n",
-    "    if not os.environ.get(var):\n",
-    "        os.environ[var] = getpass.getpass(f\"Please provide your {var}\")\n",
-    "\n",
-    "\n",
-    "_set_if_undefined(\"OPENAI_API_KEY\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "caf6ff9f-c1e6-499e-a230-9fa231ea7d2f",
-   "metadata": {},
-   "source": [
-    "<div class=\"admonition tip\">\n",
-    "    <p class=\"admonition-title\">Set up <a href=\"https://smith.langchain.com\">LangSmith</a> for LangGraph development</p>\n",
-    "    <p style=\"padding-top: 5px;\">\n",
-    "        Sign up for LangSmith to quickly spot issues and improve the performance of your LangGraph projects. LangSmith lets you use trace data to debug, test, and monitor your LLM apps built with LangGraph — read more about how to get started <a href=\"https://docs.smith.langchain.com\">here</a>. \n",
-    "    </p>\n",
-    "</div>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "10e9a9c6-fa3f-416c-bac0-3e58d7259908",
-   "metadata": {},
-   "source": [
-    "Let's create a simple ReAct style agent that can look up user information and personalize the response based on the user info."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "4255b9b9-cf67-4cc3-8018-1708f5dfcfd2",
-   "metadata": {},
-   "source": [
-    "## Define tool"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "7de6b010-aab1-4fe8-8251-907fcae78583",
-   "metadata": {},
-   "source": [
-    "First, let's define the tool that we'll be using to look up user information. We'll use a naive implementation that simply looks user information up using a dictionary:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "8d070c9f-6e61-4724-85dc-ac4531b9c79a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "USER_INFO = [\n",
-    "    {\"user_id\": \"1\", \"name\": \"Bob Dylan\", \"location\": \"New York, NY\"},\n",
-    "    {\"user_id\": \"2\", \"name\": \"Taylor Swift\", \"location\": \"Beverly Hills, CA\"},\n",
-    "]\n",
-    "\n",
-    "USER_ID_TO_USER_INFO = {info[\"user_id\"]: info for info in USER_INFO}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "08d1ecca-ee57-4e97-b8d0-e09de85337d4",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langgraph.prebuilt.chat_agent_executor import AgentState\n",
-    "from langgraph.types import Command\n",
-    "from langchain_core.tools import tool\n",
-    "from langchain_core.tools.base import InjectedToolCallId\n",
-    "from langchain_core.messages import ToolMessage\n",
-    "from langchain_core.runnables import RunnableConfig\n",
-    "\n",
-    "from typing_extensions import Any, Annotated\n",
-    "\n",
-    "\n",
-    "class State(AgentState):\n",
-    "    # user provided\n",
-    "    last_name: str\n",
-    "    # updated by the tool\n",
-    "    user_info: dict[str, Any]\n",
-    "\n",
-    "\n",
-    "@tool\n",
-    "def lookup_user_info(\n",
-    "    tool_call_id: Annotated[str, InjectedToolCallId], config: RunnableConfig\n",
-    "):\n",
-    "    \"\"\"Use this to look up user information to better assist them with their questions.\"\"\"\n",
-    "    user_id = config.get(\"configurable\", {}).get(\"user_id\")\n",
-    "    if user_id is None:\n",
-    "        raise ValueError(\"Please provide user ID\")\n",
-    "\n",
-    "    if user_id not in USER_ID_TO_USER_INFO:\n",
-    "        raise ValueError(f\"User '{user_id}' not found\")\n",
-    "\n",
-    "    user_info = USER_ID_TO_USER_INFO[user_id]\n",
-    "    return Command(\n",
-    "        update={\n",
-    "            # update the state keys\n",
-    "            \"user_info\": user_info,\n",
-    "            # update the message history\n",
-    "            \"messages\": [\n",
-    "                ToolMessage(\n",
-    "                    \"Successfully looked up user information\", tool_call_id=tool_call_id\n",
-    "                )\n",
-    "            ],\n",
-    "        }\n",
-    "    )"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "b99e5f24-5e5e-4a34-baae-467182675bb5",
-   "metadata": {},
-   "source": [
-    "## Define prompt"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "cbb06aea-6654-4245-91f8-af6e8f2b5377",
-   "metadata": {},
-   "source": [
-    "Let's now add personalization: we'll respond differently to the user based on the state values AFTER the state has been updated from the tool. To achieve this, let's define a function that will dynamically construct the system prompt based on the graph state. It will be called ever time the LLM is called and the function output will be passed to the LLM:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "c553d062-d145-4145-84bd-9b798f7c95c2",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def state_modifier(state: State):\n",
-    "    user_info = state.get(\"user_info\")\n",
-    "    if user_info is None:\n",
-    "        return state[\"messages\"]\n",
-    "\n",
-    "    system_msg = (\n",
-    "        f\"User name is {user_info['name']}. User lives in {user_info['location']}\"\n",
-    "    )\n",
-    "    return [{\"role\": \"system\", \"content\": system_msg}] + state[\"messages\"]"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "c5acdd5d-68be-466b-9c21-46cbed91d2bc",
-   "metadata": {},
-   "source": [
-    "## Define graph"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "afb65028-0359-46c8-b09c-ffc90180f759",
-   "metadata": {},
-   "source": [
-    "Finally, let's combine this into a single graph using the prebuilt `create_react_agent`:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "2d59db29-fd51-4d29-9854-21763a4855e3",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langgraph.prebuilt import create_react_agent\n",
-    "from langchain_openai import ChatOpenAI\n",
-    "\n",
-    "model = ChatOpenAI(model=\"gpt-4o\")\n",
-    "\n",
-    "agent = create_react_agent(\n",
-    "    model,\n",
-    "    # pass the tool that can update state\n",
-    "    [lookup_user_info],\n",
-    "    state_schema=State,\n",
-    "    # pass dynamic prompt function\n",
-    "    state_modifier=state_modifier,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "0782b8ab-a603-47b8-9a76-77f593402678",
-   "metadata": {},
-   "source": [
-    "## Use it!"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "6165e153-ab28-4404-adea-796c7bd0701b",
-   "metadata": {},
-   "source": [
-    "Let's now try running our agent. We'll need to provide user ID in the config so that our tool knows what information to look up:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "de34a58b-1765-4b63-a232-d46790aff884",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'agent': {'messages': [AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_7LSUh6ZDvGJAUvlWvXiCK4Gf', 'function': {'arguments': '{}', 'name': 'lookup_user_info'}, 'type': 'function'}], 'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 11, 'prompt_tokens': 56, 'total_tokens': 67, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0}}, 'model_name': 'gpt-4o-2024-08-06', 'system_fingerprint': 'fp_9d50cd990b', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-57eeb216-e35d-4501-aaac-b5c6b26fb17c-0', tool_calls=[{'name': 'lookup_user_info', 'args': {}, 'id': 'call_7LSUh6ZDvGJAUvlWvXiCK4Gf', 'type': 'tool_call'}], usage_metadata={'input_tokens': 56, 'output_tokens': 11, 'total_tokens': 67, 'input_token_details': {'audio': 0, 'cache_read': 0}, 'output_token_details': {'audio': 0, 'reasoning': 0}})]}}\n",
-      "\n",
-      "\n",
-      "{'tools': {'user_info': {'user_id': '1', 'name': 'Bob Dylan', 'location': 'New York, NY'}, 'messages': [ToolMessage(content='Successfully looked up user information', name='lookup_user_info', id='168d8ff8-b021-4c8b-a11a-3b50c30a072c', tool_call_id='call_7LSUh6ZDvGJAUvlWvXiCK4Gf')]}}\n",
-      "\n",
-      "\n",
-      "{'agent': {'messages': [AIMessage(content=\"Hi Bob! Since you're in New York, NY, there are plenty of exciting things to do over the weekend. Here are some suggestions:\\n\\n1. **Explore Central Park**: Take a leisurely walk, rent a bike, or have a picnic in this iconic park.\\n\\n2. **Visit a Museum**: Check out The Metropolitan Museum of Art or the Museum of Modern Art (MoMA) for an enriching cultural experience.\\n\\n3. **Broadway Show**: Catch a Broadway show or an off-Broadway performance for some world-class entertainment.\\n\\n4. **Food Tour**: Explore different neighborhoods like Greenwich Village or Williamsburg for diverse culinary experiences.\\n\\n5. **Brooklyn Bridge Walk**: Take a walk across the Brooklyn Bridge for stunning views of the city skyline.\\n\\n6. **Visit a Rooftop Bar**: Enjoy a drink with a view at one of New York’s many rooftop bars.\\n\\n7. **Explore a New Neighborhood**: Discover the unique charm of areas like SoHo, Chelsea, or Astoria.\\n\\n8. **Live Music**: Check out live music venues for a night of great performances.\\n\\n9. **Art Galleries**: Visit some of the smaller art galleries around Chelsea or the Lower East Side.\\n\\n10. **Attend a Local Event**: Look up any local events or festivals happening this weekend.\\n\\nFeel free to let me know if you want more details on any of these activities!\", additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 285, 'prompt_tokens': 95, 'total_tokens': 380, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0}}, 'model_name': 'gpt-4o-2024-08-06', 'system_fingerprint': 'fp_9d50cd990b', 'finish_reason': 'stop', 'logprobs': None}, id='run-f13ce15b-02b6-40e6-8264-c4d9edd0d03a-0', usage_metadata={'input_tokens': 95, 'output_tokens': 285, 'total_tokens': 380, 'input_token_details': {'audio': 0, 'cache_read': 0}, 'output_token_details': {'audio': 0, 'reasoning': 0}})]}}\n",
-      "\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "for chunk in agent.stream(\n",
-    "    {\"messages\": [(\"user\", \"hi, what should i do this weekend?\")]},\n",
-    "    # provide user ID in the config\n",
-    "    {\"configurable\": {\"user_id\": \"1\"}},\n",
-    "):\n",
-    "    print(chunk)\n",
-    "    print(\"\\n\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "d9b2281f-269c-41dd-b6b2-4c743f11ffc9",
-   "metadata": {},
-   "source": [
-    "We can see that the model correctly recommended some New York activities for Bob Dylan! Let's try getting recommendations for Taylor Swift:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "9d71af94-572a-4961-88a7-665e792cf96a",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'agent': {'messages': [AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_5HLtJtzcgmKbtmK6By21wW5Y', 'function': {'arguments': '{}', 'name': 'lookup_user_info'}, 'type': 'function'}], 'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 11, 'prompt_tokens': 56, 'total_tokens': 67, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0}}, 'model_name': 'gpt-4o-2024-08-06', 'system_fingerprint': 'fp_c7ca0ebaca', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-bacacd7d-76cc-4f6b-9e9b-d9e6f00b9391-0', tool_calls=[{'name': 'lookup_user_info', 'args': {}, 'id': 'call_5HLtJtzcgmKbtmK6By21wW5Y', 'type': 'tool_call'}], usage_metadata={'input_tokens': 56, 'output_tokens': 11, 'total_tokens': 67, 'input_token_details': {'audio': 0, 'cache_read': 0}, 'output_token_details': {'audio': 0, 'reasoning': 0}})]}}\n",
-      "\n",
-      "\n",
-      "{'tools': {'user_info': {'user_id': '2', 'name': 'Taylor Swift', 'location': 'Beverly Hills, CA'}, 'messages': [ToolMessage(content='Successfully looked up user information', name='lookup_user_info', id='d81ef31e-6d77-4f13-ae86-e2e6ba567e3d', tool_call_id='call_5HLtJtzcgmKbtmK6By21wW5Y')]}}\n",
-      "\n",
-      "\n",
-      "{'agent': {'messages': [AIMessage(content=\"Hi Taylor! Since you're in Beverly Hills, here are a few suggestions for a fun weekend:\\n\\n1. **Hiking at Runyon Canyon**: Enjoy a scenic hike with beautiful views of Los Angeles. It's a great way to get some exercise and enjoy the outdoors.\\n\\n2. **Visit Rodeo Drive**: Spend some time shopping or window shopping at the famous Rodeo Drive. You might even spot some celebrities!\\n\\n3. **Explore the Getty Center**: Check out the art collections and beautiful gardens at the Getty Center. The architecture and views are stunning.\\n\\n4. **Relax at a Spa**: Treat yourself to a relaxing day at one of Beverly Hills' luxurious spas.\\n\\n5. **Dining Out**: Try a new restaurant or visit your favorite spot for a delicious meal. Beverly Hills has a fantastic dining scene.\\n\\n6. **Attend a Local Event**: Check out any local events or concerts happening this weekend. Beverly Hills often hosts exciting events.\\n\\nEnjoy your weekend!\", additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 198, 'prompt_tokens': 95, 'total_tokens': 293, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0}}, 'model_name': 'gpt-4o-2024-08-06', 'system_fingerprint': 'fp_c7ca0ebaca', 'finish_reason': 'stop', 'logprobs': None}, id='run-2057df76-f192-4c69-a66a-1f0a86bf5d66-0', usage_metadata={'input_tokens': 95, 'output_tokens': 198, 'total_tokens': 293, 'input_token_details': {'audio': 0, 'cache_read': 0}, 'output_token_details': {'audio': 0, 'reasoning': 0}})]}}\n",
-      "\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "for chunk in agent.stream(\n",
-    "    {\"messages\": [(\"user\", \"hi, what should i do this weekend?\")]},\n",
-    "    {\"configurable\": {\"user_id\": \"2\"}},\n",
-    "):\n",
-    "    print(chunk)\n",
-    "    print(\"\\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.12.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/reference/types.md

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

docs/docs/tutorials/index.md

@@ -13,7 +13,6 @@ New to LangGraph or LLM app development? Read this material to get up and runnin
 - [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.
-- [LangGraph Template Quickstart](../concepts/template_applications.md): Quickly start building with LangGraph Platform using a template application.
 
 ## Use cases 🛠️
 

docs/docs/tutorials/introduction.ipynb

@@ -19,7 +19,7 @@
     "\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": [
+    "In this tutorial, we'll be "
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 2,

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

@@ -10,7 +10,7 @@ This is a quick start guide to help you get a LangGraph app up and running local
 ## Install the LangGraph CLI
 
 ```bash
-pip install -U "langgraph-cli[inmem]" python-dotenv
+pip install "langgraph-cli[inmem]==0.1.58" python-dotenv
 ```
 
 ## 🌱 Create a LangGraph App
@@ -35,10 +35,10 @@ Create a new app from the `react-agent` template. This template is a simple agen
 
 ## 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:
+In the root of your new LangGraph app, install the dependencies:
 
 ```shell
-pip install -e .
+pip install .
 ```
 
 ## Create a `.env` file
@@ -250,4 +250,4 @@ 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.
+- **[JS/TS SDK Reference](../../cloud/reference/sdk/js_ts_sdk_ref.md)**: Explore the Python SDK API Reference.

docs/docs/tutorials/multi_agent/hierarchical_agent_teams.ipynb

@@ -289,10 +289,15 @@
     "from langchain_core.language_models.chat_models import BaseChatModel\n",
     "\n",
     "from langgraph.graph import StateGraph, MessagesState, START, END\n",
-    "from langgraph.types import Command\n",
     "from langchain_core.messages import HumanMessage, trim_messages\n",
     "\n",
     "\n",
+    "# The agent state is the input to each node in the graph\n",
+    "class AgentState(MessagesState):\n",
+    "    # The 'next' field indicates where to route to next\n",
+    "    next: str\n",
+    "\n",
+    "\n",
     "def make_supervisor_node(llm: BaseChatModel, members: list[str]) -> str:\n",
     "    options = [\"FINISH\"] + members\n",
     "    system_prompt = (\n",
@@ -308,17 +313,17 @@
     "\n",
     "        next: Literal[*options]\n",
     "\n",
-    "    def supervisor_node(state: MessagesState) -> Command[Literal[*members, \"__end__\"]]:\n",
+    "    def supervisor_node(state: MessagesState) -> MessagesState:\n",
     "        \"\"\"An LLM-based router.\"\"\"\n",
     "        messages = [\n",
     "            {\"role\": \"system\", \"content\": system_prompt},\n",
     "        ] + state[\"messages\"]\n",
     "        response = llm.with_structured_output(Router).invoke(messages)\n",
-    "        goto = response[\"next\"]\n",
-    "        if goto == \"FINISH\":\n",
-    "            goto = END\n",
+    "        next_ = response[\"next\"]\n",
+    "        if next_ == \"FINISH\":\n",
+    "            next_ = END\n",
     "\n",
-    "        return Command(goto=goto)\n",
+    "        return {\"next\": next_}\n",
     "\n",
     "    return supervisor_node"
    ]
@@ -358,33 +363,25 @@
     "search_agent = create_react_agent(llm, tools=[tavily_tool])\n",
     "\n",
     "\n",
-    "def search_node(state: MessagesState) -> Command[Literal[\"supervisor\"]]:\n",
+    "def search_node(state: AgentState) -> AgentState:\n",
     "    result = search_agent.invoke(state)\n",
-    "    return Command(\n",
-    "        update={\n",
-    "            \"messages\": [\n",
-    "                HumanMessage(content=result[\"messages\"][-1].content, name=\"search\")\n",
-    "            ]\n",
-    "        },\n",
-    "        # We want our workers to ALWAYS \"report back\" to the supervisor when done\n",
-    "        goto=\"supervisor\",\n",
-    "    )\n",
+    "    return {\n",
+    "        \"messages\": [\n",
+    "            HumanMessage(content=result[\"messages\"][-1].content, name=\"search\")\n",
+    "        ]\n",
+    "    }\n",
     "\n",
     "\n",
     "web_scraper_agent = create_react_agent(llm, tools=[scrape_webpages])\n",
     "\n",
     "\n",
-    "def web_scraper_node(state: MessagesState) -> Command[Literal[\"supervisor\"]]:\n",
+    "def web_scraper_node(state: AgentState) -> AgentState:\n",
     "    result = web_scraper_agent.invoke(state)\n",
-    "    return Command(\n",
-    "        update={\n",
-    "            \"messages\": [\n",
-    "                HumanMessage(content=result[\"messages\"][-1].content, name=\"web_scraper\")\n",
-    "            ]\n",
-    "        },\n",
-    "        # We want our workers to ALWAYS \"report back\" to the supervisor when done\n",
-    "        goto=\"supervisor\",\n",
-    "    )\n",
+    "    return {\n",
+    "        \"messages\": [\n",
+    "            HumanMessage(content=result[\"messages\"][-1].content, name=\"web_scraper\")\n",
+    "        ]\n",
+    "    }\n",
     "\n",
     "\n",
     "research_supervisor_node = make_supervisor_node(llm, [\"search\", \"web_scraper\"])"
@@ -415,7 +412,14 @@
     "research_builder.add_node(\"search\", search_node)\n",
     "research_builder.add_node(\"web_scraper\", web_scraper_node)\n",
     "\n",
+    "# Define the control flow\n",
     "research_builder.add_edge(START, \"supervisor\")\n",
+    "# We want our workers to ALWAYS \"report back\" to the supervisor when done\n",
+    "research_builder.add_edge(\"search\", \"supervisor\")\n",
+    "research_builder.add_edge(\"web_scraper\", \"supervisor\")\n",
+    "# Add the edges where routing applies\n",
+    "research_builder.add_conditional_edges(\"supervisor\", lambda state: state[\"next\"])\n",
+    "\n",
     "research_graph = research_builder.compile()"
    ]
   },
@@ -528,17 +532,13 @@
     ")\n",
     "\n",
     "\n",
-    "def doc_writing_node(state: MessagesState) -> Command[Literal[\"supervisor\"]]:\n",
+    "def doc_writing_node(state: AgentState) -> AgentState:\n",
     "    result = doc_writer_agent.invoke(state)\n",
-    "    return Command(\n",
-    "        update={\n",
-    "            \"messages\": [\n",
-    "                HumanMessage(content=result[\"messages\"][-1].content, name=\"doc_writer\")\n",
-    "            ]\n",
-    "        },\n",
-    "        # We want our workers to ALWAYS \"report back\" to the supervisor when done\n",
-    "        goto=\"supervisor\",\n",
-    "    )\n",
+    "    return {\n",
+    "        \"messages\": [\n",
+    "            HumanMessage(content=result[\"messages\"][-1].content, name=\"doc_writer\")\n",
+    "        ]\n",
+    "    }\n",
     "\n",
     "\n",
     "note_taking_agent = create_react_agent(\n",
@@ -551,17 +551,13 @@
     ")\n",
     "\n",
     "\n",
-    "def note_taking_node(state: MessagesState) -> Command[Literal[\"supervisor\"]]:\n",
+    "def note_taking_node(state: AgentState) -> AgentState:\n",
     "    result = note_taking_agent.invoke(state)\n",
-    "    return Command(\n",
-    "        update={\n",
-    "            \"messages\": [\n",
-    "                HumanMessage(content=result[\"messages\"][-1].content, name=\"note_taker\")\n",
-    "            ]\n",
-    "        },\n",
-    "        # We want our workers to ALWAYS \"report back\" to the supervisor when done\n",
-    "        goto=\"supervisor\",\n",
-    "    )\n",
+    "    return {\n",
+    "        \"messages\": [\n",
+    "            HumanMessage(content=result[\"messages\"][-1].content, name=\"note_taker\")\n",
+    "        ]\n",
+    "    }\n",
     "\n",
     "\n",
     "chart_generating_agent = create_react_agent(\n",
@@ -569,19 +565,13 @@
     ")\n",
     "\n",
     "\n",
-    "def chart_generating_node(state: MessagesState) -> Command[Literal[\"supervisor\"]]:\n",
+    "def chart_generating_node(state: AgentState) -> AgentState:\n",
     "    result = chart_generating_agent.invoke(state)\n",
-    "    return Command(\n",
-    "        update={\n",
-    "            \"messages\": [\n",
-    "                HumanMessage(\n",
-    "                    content=result[\"messages\"][-1].content, name=\"chart_generator\"\n",
-    "                )\n",
-    "            ]\n",
-    "        },\n",
-    "        # We want our workers to ALWAYS \"report back\" to the supervisor when done\n",
-    "        goto=\"supervisor\",\n",
-    "    )\n",
+    "    return {\n",
+    "        \"messages\": [\n",
+    "            HumanMessage(content=result[\"messages\"][-1].content, name=\"chart_generator\")\n",
+    "        ]\n",
+    "    }\n",
     "\n",
     "\n",
     "doc_writing_supervisor_node = make_supervisor_node(\n",
@@ -610,13 +600,21 @@
    "outputs": [],
    "source": [
     "# Create the graph here\n",
-    "paper_writing_builder = StateGraph(MessagesState)\n",
+    "paper_writing_builder = StateGraph(AgentState)\n",
     "paper_writing_builder.add_node(\"supervisor\", doc_writing_supervisor_node)\n",
     "paper_writing_builder.add_node(\"doc_writer\", doc_writing_node)\n",
     "paper_writing_builder.add_node(\"note_taker\", note_taking_node)\n",
     "paper_writing_builder.add_node(\"chart_generator\", chart_generating_node)\n",
     "\n",
+    "# Define the control flow\n",
     "paper_writing_builder.add_edge(START, \"supervisor\")\n",
+    "# We want our workers to ALWAYS \"report back\" to the supervisor when done\n",
+    "paper_writing_builder.add_edge(\"doc_writer\", \"supervisor\")\n",
+    "paper_writing_builder.add_edge(\"note_taker\", \"supervisor\")\n",
+    "paper_writing_builder.add_edge(\"chart_generator\", \"supervisor\")\n",
+    "# Add the edges where routing applies\n",
+    "paper_writing_builder.add_conditional_edges(\"supervisor\", lambda state: state[\"next\"])\n",
+    "\n",
     "paper_writing_graph = paper_writing_builder.compile()"
    ]
   },
@@ -730,41 +728,37 @@
    },
    "outputs": [],
    "source": [
-    "def call_research_team(state: MessagesState) -> Command[Literal[\"supervisor\"]]:\n",
+    "def call_research_team(state: AgentState) -> AgentState:\n",
     "    response = research_graph.invoke({\"messages\": state[\"messages\"][-1]})\n",
-    "    return Command(\n",
-    "        update={\n",
-    "            \"messages\": [\n",
-    "                HumanMessage(\n",
-    "                    content=response[\"messages\"][-1].content, name=\"research_team\"\n",
-    "                )\n",
-    "            ]\n",
-    "        },\n",
-    "        goto=\"supervisor\",\n",
-    "    )\n",
+    "    return {\n",
+    "        \"messages\": [\n",
+    "            HumanMessage(content=response[\"messages\"][-1].content, name=\"research_team\")\n",
+    "        ]\n",
+    "    }\n",
     "\n",
     "\n",
-    "def call_paper_writing_team(state: MessagesState) -> Command[Literal[\"supervisor\"]]:\n",
+    "def call_paper_writing_team(state: AgentState) -> AgentState:\n",
     "    response = paper_writing_graph.invoke({\"messages\": state[\"messages\"][-1]})\n",
-    "    return Command(\n",
-    "        update={\n",
-    "            \"messages\": [\n",
-    "                HumanMessage(\n",
-    "                    content=response[\"messages\"][-1].content, name=\"writing_team\"\n",
-    "                )\n",
-    "            ]\n",
-    "        },\n",
-    "        goto=\"supervisor\",\n",
-    "    )\n",
+    "    return {\n",
+    "        \"messages\": [\n",
+    "            HumanMessage(content=response[\"messages\"][-1].content, name=\"writing_team\")\n",
+    "        ]\n",
+    "    }\n",
     "\n",
     "\n",
     "# Define the graph.\n",
-    "super_builder = StateGraph(MessagesState)\n",
+    "super_builder = StateGraph(AgentState)\n",
     "super_builder.add_node(\"supervisor\", teams_supervisor_node)\n",
     "super_builder.add_node(\"research_team\", call_research_team)\n",
     "super_builder.add_node(\"writing_team\", call_paper_writing_team)\n",
     "\n",
+    "# Define the control flow\n",
     "super_builder.add_edge(START, \"supervisor\")\n",
+    "# We want our teams to ALWAYS \"report back\" to the top-level supervisor when done\n",
+    "super_builder.add_edge(\"research_team\", \"supervisor\")\n",
+    "super_builder.add_edge(\"writing_team\", \"supervisor\")\n",
+    "# Add the edges where routing applies\n",
+    "super_builder.add_conditional_edges(\"supervisor\", lambda state: state[\"next\"])\n",
     "super_graph = super_builder.compile()"
    ]
   },

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

@@ -151,7 +151,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 +164,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
@@ -192,7 +190,6 @@ nav:
             - how-tos/tool-calling.ipynb
             - how-tos/tool-calling-errors.ipynb
             - how-tos/pass-run-time-values-to-tools.ipynb
-            - how-tos/update-state-from-tools.ipynb
             - how-tos/pass-config-to-tools.ipynb
             - how-tos/many-tools.ipynb
         - Subgraphs:
@@ -200,8 +197,6 @@ nav:
             - how-tos/subgraph.ipynb
             - how-tos/subgraphs-manage-state.ipynb
             - how-tos/subgraph-transform-state.ipynb
-        - Multi-agent:
-            - how-tos/multi-agent-network.ipynb
         - State Management:
             - State Management: how-tos#state-management
             - how-tos/state-model.ipynb
@@ -230,7 +225,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

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
 
 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
@@ -75,15 +75,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 :],
@@ -377,19 +378,15 @@ 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:

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

@@ -1,8 +1,7 @@
 """Shared async utility functions for the Postgres checkpoint & storage classes."""
 
-from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
-from typing import Union
+from typing import AsyncIterator, Union
 
 from psycopg import AsyncConnection
 from psycopg.rows import DictRow

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

@@ -1,8 +1,7 @@
 """Shared utility functions for the Postgres checkpoint & storage classes."""
 
-from collections.abc import Iterator
 from contextlib import contextmanager
-from typing import Union
+from typing import Iterator, Union
 
 from psycopg import Connection
 from psycopg.rows import DictRow

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
 
 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
@@ -54,7 +54,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.
@@ -80,15 +80,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 :],
@@ -336,25 +338,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 +380,7 @@ class AsyncPostgresSaver(BasePostgresSaver):
         while True:
             try:
                 yield asyncio.run_coroutine_threadsafe(
-                    anext(aiter_),  # noqa: F821
+                    anext(aiter_),
                     self.loop,
                 ).result()
             except StopAsyncIteration:

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
@@ -57,17 +56,6 @@ MIGRATIONS = [
     PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id, task_id, idx)
 );""",
     "ALTER TABLE checkpoint_blobs ALTER COLUMN blob DROP not null;",
-    """
-    """,
-    """
-    CREATE INDEX CONCURRENTLY IF NOT EXISTS checkpoints_thread_id_idx ON checkpoints(thread_id);
-    """,
-    """
-    CREATE INDEX CONCURRENTLY IF NOT EXISTS checkpoint_blobs_thread_id_idx ON checkpoint_blobs(thread_id);
-    """,
-    """
-    CREATE INDEX CONCURRENTLY IF NOT EXISTS checkpoint_writes_thread_id_idx ON checkpoint_writes(thread_id);
-    """,
 ]
 
 SELECT_SQL = f"""
@@ -261,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,118 +1,40 @@
 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.errors import UndefinedTable
 from psycopg.rows import DictRow, dict_row
 from psycopg_pool import AsyncConnectionPool
 
 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",
-    )
+    __slots__ = ("_deserializer", "pipe", "lock", "supports_pipeline")
 
     def __init__(
         self,
@@ -122,7 +44,6 @@ class AsyncPostgresStore(AsyncBatchedBaseStore, BasePostgresStore[_ainternal.Con
         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(
@@ -135,12 +56,6 @@ class AsyncPostgresStore(AsyncBatchedBaseStore, BasePostgresStore[_ainternal.Con
         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)
@@ -155,111 +70,13 @@ class AsyncPostgresStore(AsyncBatchedBaseStore, BasePostgresStore[_ainternal.Con
 
         return results
 
-    @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:
-            await cur.execute(
-                f"""
-                CREATE TABLE IF NOT EXISTS {table} (
-                    v INTEGER PRIMARY KEY
-                )
-            """
-            )
-            await cur.execute(f"SELECT v FROM {table} ORDER BY v DESC LIMIT 1")
-            row = cast(dict, await cur.fetchone())
-            if row is None:
-                version = -1
-            else:
-                version = row["v"]
-            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:
+        async with self._cursor(conn, pipeline=True) as cur:
             if GetOp in grouped_ops:
                 await self._batch_get_ops(
                     cast(Sequence[tuple[int, GetOp]], grouped_ops[GetOp]),
@@ -314,31 +131,7 @@ class AsyncPostgresStore(AsyncBatchedBaseStore, BasePostgresStore[_ainternal.Con
         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:
             await cur.execute(query, params)
 
@@ -348,23 +141,12 @@ class AsyncPostgresStore(AsyncBatchedBaseStore, BasePostgresStore[_ainternal.Con
         results: list[Result],
         cur: AsyncCursor[DictRow],
     ) -> None:
-        queries, embedding_requests = self._prepare_batch_search_queries(search_ops)
-
-        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):
+        queries = self._get_batch_search_queries(search_ops)
+        for (query, params), (idx, _) in zip(queries, search_ops):
             await cur.execute(query, params)
             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
@@ -386,46 +168,127 @@ class AsyncPostgresStore(AsyncBatchedBaseStore, BasePostgresStore[_ainternal.Con
 
     @asynccontextmanager
     async def _cursor(
-        self, *, pipeline: bool = False
-    ) -> AsyncIterator[AsyncCursor[DictRow]]:
+        self, conn: AsyncConnection[DictRow], *, pipeline: bool = False
+    ) -> AsyncIterator[AsyncCursor[Any]]:
         """Create a database cursor as a context manager.
 
         Args:
+            conn: The database connection to use
             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.
         """
-        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
+        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
+            async with conn.cursor(binary=True) as cur:
                 try:
-                    async with conn.cursor(binary=True, row_factory=dict_row) as cur:
-                        yield cur
+                    yield cur
                 finally:
                     if pipeline:
                         await self.pipe.sync()
-            elif pipeline:
-                # a connection not in pipeline mode can only be used by one
-                # thread/coroutine at a time, so we acquire a lock
-                if self.supports_pipeline:
-                    async with (
-                        self.lock,
-                        conn.pipeline(),
-                        conn.cursor(binary=True, row_factory=dict_row) as cur,
-                    ):
-                        yield cur
-                else:
-                    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,
-                ):
+        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) as cur:
                     yield cur
+            else:
+                async with self.lock, conn.transaction(), conn.cursor(
+                    binary=True
+                ) as cur:
+                    yield cur
+        else:
+            async with conn.cursor(binary=True) as cur:
+                yield cur
+
+    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,
+    ) -> 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.
+
+        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)
+        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)
+                else:
+                    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 _ainternal.get_connection(self.conn) as conn:
+            async with 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:
+                        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,)
+                    )
+            if self.pipe:
+                await self.pipe.sync()

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

@@ -3,17 +3,16 @@ import json
 import logging
 import threading
 from collections import defaultdict
-from collections.abc import Iterable, Iterator, Sequence
 from contextlib import contextmanager
 from datetime import datetime
 from typing import (
-    TYPE_CHECKING,
     Any,
     Callable,
     Generic,
-    Literal,
-    NamedTuple,
+    Iterable,
+    Iterator,
     Optional,
+    Sequence,
     TypeVar,
     Union,
     cast,
@@ -21,6 +20,7 @@ from typing import (
 
 import orjson
 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
@@ -31,34 +31,18 @@ from langgraph.checkpoint.postgres import _internal as _pg_internal
 from langgraph.store.base import (
     BaseStore,
     GetOp,
-    IndexConfig,
     Item,
     ListNamespacesOp,
     Op,
     PutOp,
     Result,
-    SearchItem,
     SearchOp,
-    ensure_embeddings,
-    get_text_at_path,
-    tokenize_path,
 )
 
-if TYPE_CHECKING:
-    from langchain_core.embeddings import Embeddings
-
 logger = logging.getLogger(__name__)
 
 
-class Migration(NamedTuple):
-    """A database migration with optional conditions and parameters."""
-
-    sql: str
-    params: Optional[dict[str, Any]] = None
-    condition: Optional[Callable[["BasePostgresStore"], bool]] = None
-
-
-MIGRATIONS: Sequence[str] = [
+MIGRATIONS = [
     """
 CREATE TABLE IF NOT EXISTS store (
     -- 'prefix' represents the doc's 'namespace'
@@ -72,61 +56,10 @@ CREATE TABLE IF NOT EXISTS store (
 """,
     """
 -- For faster lookups by prefix
-CREATE INDEX CONCURRENTLY IF NOT EXISTS store_prefix_idx ON store USING btree (prefix text_pattern_ops);
+CREATE INDEX IF NOT EXISTS store_prefix_idx ON store USING btree (prefix text_pattern_ops);
 """,
 ]
 
-VECTOR_MIGRATIONS: Sequence[Migration] = [
-    Migration(
-        """
-CREATE EXTENSION IF NOT EXISTS vector;
-""",
-    ),
-    Migration(
-        """
-CREATE TABLE IF NOT EXISTS store_vectors (
-    prefix text NOT NULL,
-    key text NOT NULL,
-    field_name text NOT NULL,
-    embedding %(vector_type)s(%(dims)s),
-    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
-    PRIMARY KEY (prefix, key, field_name),
-    FOREIGN KEY (prefix, key) REFERENCES store(prefix, key) ON DELETE CASCADE
-);
-""",
-        params={
-            "dims": lambda store: store.index_config["dims"],
-            "vector_type": lambda store: (
-                cast(PostgresIndexConfig, store.index_config)
-                .get("ann_index_config", {})
-                .get("vector_type", "vector")
-            ),
-        },
-    ),
-    Migration(
-        """
-CREATE INDEX CONCURRENTLY IF NOT EXISTS store_vectors_embedding_idx ON store_vectors 
-    USING %(index_type)s (embedding %(ops)s)%(index_params)s;
-""",
-        condition=lambda store: bool(
-            store.index_config and _get_index_params(store)[0] != "flat"
-        ),
-        params={
-            "index_type": lambda store: _get_index_params(store)[0],
-            "ops": lambda store: _get_vector_type_ops(store),
-            "index_params": lambda store: (
-                " WITH ("
-                + ", ".join(f"{k}={v}" for k, v in _get_index_params(store)[1].items())
-                + ")"
-                if _get_index_params(store)[1]
-                else ""
-            ),
-        },
-    ),
-]
-
-
 C = TypeVar("C", bound=Union[_pg_internal.Conn, _ainternal.Conn])
 
 
@@ -155,70 +88,10 @@ class PoolConfig(TypedDict, total=False):
     """
 
 
-class ANNIndexConfig(TypedDict, total=False):
-    """Configuration for vector index in PostgreSQL store."""
-
-    kind: Literal["hnsw", "ivfflat", "flat"]
-    """Type of index to use: 'hnsw' for Hierarchical Navigable Small World, or 'ivfflat' for Inverted File Flat."""
-    vector_type: Literal["vector", "halfvec"]
-    """Type of vector storage to use.
-    Options:
-    - 'vector': Regular vectors (default)
-    - 'halfvec': Half-precision vectors for reduced memory usage
-    """
-
-
-class HNSWConfig(ANNIndexConfig, total=False):
-    """Configuration for HNSW (Hierarchical Navigable Small World) index."""
-
-    kind: Literal["hnsw"]  # type: ignore[misc]
-    m: int
-    """Maximum number of connections per layer. Default is 16."""
-    ef_construction: int
-    """Size of dynamic candidate list for index construction. Default is 64."""
-
-
-class IVFFlatConfig(ANNIndexConfig, total=False):
-    """IVFFlat index divides vectors into lists, and then searches a subset of those lists that are closest to the query vector. It has faster build times and uses less memory than HNSW, but has lower query performance (in terms of speed-recall tradeoff).
-
-    Three keys to achieving good recall are:
-    1. Create the index after the table has some data
-    2. Choose an appropriate number of lists - a good place to start is rows / 1000 for up to 1M rows and sqrt(rows) for over 1M rows
-    3. When querying, specify an appropriate number of probes (higher is better for recall, lower is better for speed) - a good place to start is sqrt(lists)
-    """
-
-    kind: Literal["ivfflat"]  # type: ignore[misc]
-    nlist: int
-    """Number of inverted lists (clusters) for IVF index.
-    
-    Determines the number of clusters used in the index structure.
-    Higher values can improve search speed but increase index size and build time.
-    Typically set to the square root of the number of vectors in the index.
-    """
-
-
-class PostgresIndexConfig(IndexConfig, total=False):
-    """Configuration for vector embeddings in PostgreSQL store with pgvector-specific options.
-
-    Extends EmbeddingConfig with additional configuration for pgvector index and vector types.
-    """
-
-    ann_index_config: ANNIndexConfig
-    """Specific configuration for the chosen index type (HNSW or IVF Flat)."""
-    distance_type: Literal["l2", "inner_product", "cosine"]
-    """Distance metric to use for vector similarity search:
-    - 'l2': Euclidean distance
-    - 'inner_product': Dot product
-    - 'cosine': Cosine similarity
-    """
-
-
 class BasePostgresStore(Generic[C]):
     MIGRATIONS = MIGRATIONS
-    VECTOR_MIGRATIONS = VECTOR_MIGRATIONS
     conn: C
     _deserializer: Optional[Callable[[Union[bytes, orjson.Fragment]], dict[str, Any]]]
-    index_config: Optional[PostgresIndexConfig]
 
     def _get_batch_GET_ops_queries(
         self,
@@ -240,13 +113,10 @@ class BasePostgresStore(Generic[C]):
             results.append((query, params, namespace, items))
         return results
 
-    def _prepare_batch_PUT_queries(
+    def _get_batch_PUT_queries(
         self,
         put_ops: Sequence[tuple[int, PutOp]],
-    ) -> tuple[
-        list[tuple[str, Sequence]],
-        Optional[tuple[str, Sequence[tuple[str, str, str, str]]]],
-    ]:
+    ) -> list[tuple[str, Sequence]]:
         # Last-write wins
         dedupped_ops: dict[tuple[tuple[str, ...], str], PutOp] = {}
         for _, op in put_ops:
@@ -273,192 +143,60 @@ class BasePostgresStore(Generic[C]):
                 )
                 params = (_namespace_to_text(namespace), *keys)
                 queries.append((query, params))
-        embedding_request: Optional[tuple[str, Sequence[tuple[str, str, str, str]]]] = (
-            None
-        )
         if inserts:
             values = []
             insertion_params = []
-            vector_values = []
-            embedding_request_params = []
-
-            # First handle main store insertions
             for op in inserts:
                 values.append("(%s, %s, %s, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)")
                 insertion_params.extend(
                     [
                         _namespace_to_text(op.namespace),
                         op.key,
-                        Jsonb(cast(dict, op.value)),
+                        Jsonb(op.value),
                     ]
                 )
-
-            # Then handle embeddings if configured
-            if self.index_config:
-                for op in inserts:
-                    if op.index is False:
-                        continue
-                    value = op.value
-                    ns = _namespace_to_text(op.namespace)
-                    k = op.key
-
-                    if op.index is None:
-                        paths = self.index_config["__tokenized_fields"]
-                    else:
-                        paths = [(ix, tokenize_path(ix)) for ix in op.index]
-
-                    for path, tokenized_path in paths:
-                        texts = get_text_at_path(value, tokenized_path)
-                        for i, text in enumerate(texts):
-                            pathname = f"{path}.{i}" if len(texts) > 1 else path
-                            vector_values.append(
-                                "(%s, %s, %s, %s, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)"
-                            )
-                            embedding_request_params.append((ns, k, pathname, text))
-
             values_str = ",".join(values)
             query = f"""
                 INSERT INTO store (prefix, key, value, created_at, updated_at)
                 VALUES {values_str}
                 ON CONFLICT (prefix, key) DO UPDATE
-                SET value = EXCLUDED.value,
-                    updated_at = CURRENT_TIMESTAMP
+                SET value = EXCLUDED.value, updated_at = CURRENT_TIMESTAMP
             """
             queries.append((query, insertion_params))
 
-            if vector_values:
-                values_str = ",".join(vector_values)
-                query = f"""
-                    INSERT INTO store_vectors (prefix, key, field_name, embedding, created_at, updated_at)
-                    VALUES {values_str}
-                    ON CONFLICT (prefix, key, field_name) DO UPDATE
-                    SET embedding = EXCLUDED.embedding,
-                        updated_at = CURRENT_TIMESTAMP
-                """
-                embedding_request = (query, embedding_request_params)
+        return queries
 
-        return queries, embedding_request
-
-    def _prepare_batch_search_queries(
+    def _get_batch_search_queries(
         self,
         search_ops: Sequence[tuple[int, SearchOp]],
-    ) -> tuple[
-        list[tuple[str, list[Union[None, str, list[float]]]]],  # queries, params
-        list[tuple[int, str]],  # idx, query_text pairs to embed
-    ]:
-        queries = []
-        embedding_requests = []
+    ) -> list[tuple[str, Sequence]]:
+        queries: list[tuple[str, Sequence]] = []
+        for _, op in search_ops:
+            query = """
+                SELECT prefix, key, value, created_at, updated_at
+                FROM store
+                WHERE prefix LIKE %s
+            """
+            params: list = [f"{_namespace_to_text(op.namespace_prefix)}%"]
 
-        for idx, (_, op) in enumerate(search_ops):
-            # Build filter conditions first
-            filter_params = []
-            filter_conditions = []
             if op.filter:
+                filter_conditions = []
                 for key, value in op.filter.items():
-                    if isinstance(value, dict):
-                        for op_name, val in value.items():
-                            condition, filter_params_ = self._get_filter_condition(
-                                key, op_name, val
-                            )
-                            filter_conditions.append(condition)
-                            filter_params.extend(filter_params_)
+                    if isinstance(value, list):
+                        filter_conditions.append("value->%s @> %s::jsonb")
+                        params.extend([key, json.dumps(value)])
                     else:
                         filter_conditions.append("value->%s = %s::jsonb")
-                        filter_params.extend([key, json.dumps(value)])
+                        params.extend([key, json.dumps(value)])
+                query += " AND " + " AND ".join(filter_conditions)
 
-            # Vector search branch
-            if op.query and self.index_config:
-                embedding_requests.append((idx, op.query))
+            # Note: we will need to not do this if sim/keyword search
+            # is used
+            query += " ORDER BY updated_at DESC LIMIT %s OFFSET %s"
+            params.extend([op.limit, op.offset])
 
-                score_operator, post_operator = _get_distance_operator(self)
-                vector_type = (
-                    cast(PostgresIndexConfig, self.index_config)
-                    .get("ann_index_config", {})
-                    .get("vector_type", "vector")
-                )
-
-                if (
-                    vector_type == "bit"
-                    and self.index_config.get("distance_type") == "hamming"
-                ):
-                    score_operator = score_operator % (
-                        "%s",
-                        self.index_config["dims"],
-                    )
-                else:
-                    score_operator = score_operator % (
-                        "%s",
-                        vector_type,
-                    )
-
-                vectors_per_doc_estimate = self.index_config["__estimated_num_vectors"]
-                expanded_limit = (op.limit * vectors_per_doc_estimate * 2) + 1
-
-                # Vector search with CTE for proper score handling
-                filter_str = (
-                    ""
-                    if not filter_conditions
-                    else " AND " + " AND ".join(filter_conditions)
-                )
-                if op.namespace_prefix:
-                    prefix_filter_str = f"WHERE s.prefix LIKE %s {filter_str} "
-                    ns_args: Sequence = (f"{_namespace_to_text(op.namespace_prefix)}%",)
-                else:
-                    ns_args = ()
-                    if filter_str:
-                        prefix_filter_str = f"WHERE {filter_str} "
-                    else:
-                        prefix_filter_str = ""
-
-                base_query = f"""
-                    WITH scored AS (
-                        SELECT s.prefix, s.key, s.value, s.created_at, s.updated_at, {score_operator} AS neg_score
-                        FROM store s
-                        JOIN store_vectors sv ON s.prefix = sv.prefix AND s.key = sv.key
-                        {prefix_filter_str}
-                        ORDER BY {score_operator} ASC 
-                        LIMIT %s
-                    )
-                    SELECT * FROM (
-                        SELECT DISTINCT ON (prefix, key) 
-                            prefix, key, value, created_at, updated_at, {post_operator} as score 
-                        FROM scored 
-                        ORDER BY prefix, key, score DESC
-                    ) AS unique_docs
-                    ORDER BY score DESC
-                    LIMIT %s
-                    OFFSET %s
-                """
-                params = [
-                    _PLACEHOLDER,  # Vector placeholder
-                    *ns_args,
-                    *filter_params,
-                    _PLACEHOLDER,
-                    expanded_limit,
-                    op.limit,
-                    op.offset,
-                ]
-
-            # Regular search branch
-            else:
-                base_query = """
-                    SELECT prefix, key, value, created_at, updated_at
-                    FROM store
-                    WHERE prefix LIKE %s
-                """
-                params = [f"{_namespace_to_text(op.namespace_prefix)}%"]
-
-                if filter_conditions:
-                    params.extend(filter_params)
-                    base_query += " AND " + " AND ".join(filter_conditions)
-
-                base_query += " ORDER BY updated_at DESC"
-                base_query += " LIMIT %s OFFSET %s"
-                params.extend([op.limit, op.offset])
-
-            queries.append((base_query, params))
-
-        return queries, embedding_requests
+            queries.append((query, params))
+        return queries
 
     def _get_batch_list_namespaces_queries(
         self,
@@ -510,89 +248,13 @@ class BasePostgresStore(Generic[C]):
 
             query += " ORDER BY truncated_prefix LIMIT %s OFFSET %s"
             params.extend([op.limit, op.offset])
-            queries.append((query, tuple(params)))
+            queries.append((query, params))
 
         return queries
 
-    def _get_filter_condition(self, key: str, op: str, value: Any) -> tuple[str, list]:
-        """Helper to generate filter conditions."""
-        if op == "$eq":
-            return "value->%s = %s::jsonb", [key, json.dumps(value)]
-        elif op == "$gt":
-            return "value->>%s > %s", [key, str(value)]
-        elif op == "$gte":
-            return "value->>%s >= %s", [key, str(value)]
-        elif op == "$lt":
-            return "value->>%s < %s", [key, str(value)]
-        elif op == "$lte":
-            return "value->>%s <= %s", [key, str(value)]
-        elif op == "$ne":
-            return "value->%s != %s::jsonb", [key, json.dumps(value)]
-        else:
-            raise ValueError(f"Unsupported operator: {op}")
-
 
 class PostgresStore(BaseStore, BasePostgresStore[_pg_internal.Conn]):
-    """Postgres-backed store with optional vector search using pgvector.
-
-    !!! example "Examples"
-        Basic setup and key-value storage:
-        ```python
-        from langgraph.store.postgres import PostgresStore
-
-        store = PostgresStore(
-            connection_string="postgresql://user:pass@localhost:5432/dbname"
-        )
-        store.setup()
-
-        # Store and retrieve data
-        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.postgres import PostgresStore
-
-        store = PostgresStore(
-            connection_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
-            }
-        )
-        store.setup() # Do this once to run migrations
-
-        # Store documents
-        store.put(("docs",), "doc1", {"text": "Python tutorial"})
-        store.put(("docs",), "doc2", {"text": "TypeScript guide"})
-        store.put(("docs",), "doc2", {"text": "Other guide"}, index=False) # don't index
-
-        # 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:
-        Make sure to call `setup()` before first use to create necessary tables and indexes.
-        The pgvector extension must be available to use vector search.
-
-    """
-
-    __slots__ = (
-        "_deserializer",
-        "pipe",
-        "lock",
-        "supports_pipeline",
-        "index_config",
-        "embeddings",
-    )
+    __slots__ = ("_deserializer", "pipe", "lock", "supports_pipeline")
 
     def __init__(
         self,
@@ -602,7 +264,6 @@ class PostgresStore(BaseStore, BasePostgresStore[_pg_internal.Conn]):
         deserializer: Optional[
             Callable[[Union[bytes, orjson.Fragment]], dict[str, Any]]
         ] = None,
-        index: Optional[PostgresIndexConfig] = None,
     ) -> None:
         super().__init__()
         self._deserializer = deserializer
@@ -610,11 +271,6 @@ class PostgresStore(BaseStore, BasePostgresStore[_pg_internal.Conn]):
         self.pipe = pipe
         self.supports_pipeline = Capabilities().has_pipeline()
         self.lock = threading.Lock()
-        self.index_config = index
-        if self.index_config:
-            self.embeddings, self.index_config = _ensure_index_config(self.index_config)
-        else:
-            self.embeddings = None
 
     @classmethod
     @contextmanager
@@ -624,18 +280,15 @@ class PostgresStore(BaseStore, BasePostgresStore[_pg_internal.Conn]):
         *,
         pipeline: bool = False,
         pool_config: Optional[PoolConfig] = None,
-        index: Optional[PostgresIndexConfig] = None,
     ) -> Iterator["PostgresStore"]:
         """Create a new PostgresStore instance from a connection string.
 
         Args:
             conn_string (str): The Postgres connection info string.
-            pipeline (bool): whether to use Pipeline
+            pipeline (bool): whether to use Pipeline (only for single connections)
             pool_config (Optional[PoolArgs]): 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 index configuration for the store.
-
         Returns:
             PostgresStore: A new PostgresStore instance.
         """
@@ -656,16 +309,16 @@ class PostgresStore(BaseStore, BasePostgresStore[_pg_internal.Conn]):
                     **cast(dict, pc),
                 ),
             ) as pool:
-                yield cls(conn=pool, index=index)
+                yield cls(conn=pool)
         else:
             with Connection.connect(
                 conn_string, autocommit=True, prepare_threshold=0, row_factory=dict_row
             ) as conn:
                 if pipeline:
                     with conn.pipeline() as pipe:
-                        yield cls(conn, pipe=pipe, index=index)
+                        yield cls(conn, pipe=pipe)
                 else:
-                    yield cls(conn, index=index)
+                    yield cls(conn)
 
     @contextmanager
     def _cursor(self, *, pipeline: bool = False) -> Iterator[Cursor[DictRow]]:
@@ -691,18 +344,14 @@ class PostgresStore(BaseStore, BasePostgresStore[_pg_internal.Conn]):
                 # 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:
-                    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 conn.cursor(binary=True, row_factory=dict_row) as cur:
@@ -765,32 +414,7 @@ class PostgresStore(BaseStore, BasePostgresStore[_pg_internal.Conn]):
         put_ops: Sequence[tuple[int, PutOp]],
         cur: Cursor[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 Embeddings when initializing the {self.__class__.__name__}."
-                )
-            query, txt_params = embedding_request
-            # Update the params to replace the raw text with the vectors
-            vectors = self.embeddings.embed_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.execute(query, params)
 
@@ -800,23 +424,13 @@ class PostgresStore(BaseStore, BasePostgresStore[_pg_internal.Conn]):
         results: list[Result],
         cur: Cursor[DictRow],
     ) -> None:
-        queries, embedding_requests = self._prepare_batch_search_queries(search_ops)
-
-        if embedding_requests and self.embeddings:
-            embeddings = self.embeddings.embed_documents(
-                [query for _, query in embedding_requests]
-            )
-            for (idx, _), embedding in zip(embedding_requests, embeddings):
-                _paramslist = queries[idx][1]
-                for i in range(len(_paramslist)):
-                    if _paramslist[i] is _PLACEHOLDER:
-                        _paramslist[i] = embedding
-
-        for (idx, _), (query, params) in zip(search_ops, queries):
+        for (query, params), (idx, _) in zip(
+            self._get_batch_search_queries(search_ops), search_ops
+        ):
             cur.execute(query, params)
             rows = cast(list[Row], cur.fetchall())
             results[idx] = [
-                _row_to_search_item(
+                _row_to_item(
                     _decode_ns_bytes(row["prefix"]), row, loader=self._deserializer
                 )
                 for row in rows
@@ -844,46 +458,29 @@ class PostgresStore(BaseStore, BasePostgresStore[_pg_internal.Conn]):
         already exist and runs database migrations. It MUST be called directly by the user
         the first time the store is used.
         """
-
-        def _get_version(cur: Cursor[dict[str, Any]], table: str) -> int:
-            cur.execute(
-                f"""
-                CREATE TABLE IF NOT EXISTS {table} (
-                    v INTEGER PRIMARY KEY
-                )
-            """
-            )
-            cur.execute(f"SELECT v FROM {table} ORDER BY v DESC LIMIT 1")
-            row = cast(dict, cur.fetchone())
-            if row is None:
-                version = -1
-            else:
-                version = row["v"]
-            return version
-
         with self._cursor() as cur:
-            version = _get_version(cur, table="store_migrations")
-            for v, sql in enumerate(self.MIGRATIONS[version + 1 :], start=version + 1):
-                cur.execute(sql)
+            try:
+                cur.execute("SELECT v FROM store_migrations ORDER BY v DESC LIMIT 1")
+                row = cast(dict, cur.fetchone())
+                if row is None:
+                    version = -1
+                else:
+                    version = row["v"]
+            except UndefinedTable:
+                version = -1
+                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
+            ):
+                cur.execute(migration)
                 cur.execute("INSERT INTO store_migrations (v) VALUES (%s)", (v,))
 
-            if self.index_config:
-                version = _get_version(cur, table="vector_migrations")
-                for v, migration in enumerate(
-                    self.VECTOR_MIGRATIONS[version + 1 :], start=version + 1
-                ):
-                    if migration.condition and not migration.condition(self):
-                        continue
-                    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
-                    cur.execute(sql)
-                    cur.execute("INSERT INTO vector_migrations (v) VALUES (%s)", (v,))
-
 
 class Row(TypedDict):
     key: str
@@ -893,57 +490,6 @@ class Row(TypedDict):
     updated_at: datetime
 
 
-# Private utilities
-
-_DEFAULT_ANN_CONFIG = ANNIndexConfig(
-    vector_type="vector",
-)
-
-
-def _get_vector_type_ops(store: BasePostgresStore) -> str:
-    """Get the vector type operator class based on config."""
-    if not store.index_config:
-        return "vector_cosine_ops"
-
-    config = cast(PostgresIndexConfig, store.index_config)
-    index_config = config.get("ann_index_config", _DEFAULT_ANN_CONFIG).copy()
-    vector_type = cast(str, index_config.get("vector_type", "vector"))
-    if vector_type not in ("vector", "halfvec"):
-        raise ValueError(
-            f"Vector type must be 'vector' or 'halfvec', got {vector_type}"
-        )
-
-    distance_type = config.get("distance_type", "cosine")
-
-    # For regular vectors
-    type_prefix = {"vector": "vector", "halfvec": "halfvec"}[vector_type]
-
-    if distance_type not in ("l2", "inner_product", "cosine"):
-        raise ValueError(
-            f"Vector type {vector_type} only supports 'l2', 'inner_product', or 'cosine' distance, got {distance_type}"
-        )
-
-    distance_suffix = {
-        "l2": "l2_ops",
-        "inner_product": "ip_ops",
-        "cosine": "cosine_ops",
-    }[distance_type]
-
-    return f"{type_prefix}_{distance_suffix}"
-
-
-def _get_index_params(store: Any) -> tuple[str, dict[str, Any]]:
-    """Get the index type and configuration based on config."""
-    if not store.index_config:
-        return "hnsw", {}
-
-    config = cast(PostgresIndexConfig, store.index_config)
-    index_config = config.get("ann_index_config", _DEFAULT_ANN_CONFIG).copy()
-    kind = index_config.pop("kind", "hnsw")
-    index_config.pop("vector_type", None)
-    return kind, index_config
-
-
 def _namespace_to_text(
     namespace: tuple[str, ...], handle_wildcards: bool = False
 ) -> str:
@@ -959,51 +505,15 @@ def _row_to_item(
     *,
     loader: Optional[Callable[[Union[bytes, orjson.Fragment]], dict[str, Any]]] = None,
 ) -> Item:
-    """Convert a row from the database into an Item.
-
-    Args:
-        namespace: Item namespace
-        row: Database row
-        loader: Optional value loader for non-dict values
-    """
-    val = row["value"]
-    if not isinstance(val, dict):
-        val = (loader or _json_loads)(val)
-
-    kwargs = {
-        "key": row["key"],
-        "namespace": namespace,
-        "value": val,
-        "created_at": row["created_at"],
-        "updated_at": row["updated_at"],
-    }
-
-    return Item(**kwargs)
-
-
-def _row_to_search_item(
-    namespace: tuple[str, ...],
-    row: Row,
-    *,
-    loader: Optional[Callable[[Union[bytes, orjson.Fragment]], dict[str, Any]]] = None,
-) -> SearchItem:
     """Convert a row from the database into an Item."""
     loader = loader or _json_loads
     val = row["value"]
-    score = row.get("score")
-    if score is not None:
-        try:
-            score = float(score)  # type: ignore[arg-type]
-        except ValueError:
-            logger.warning("Invalid score: %s", score)
-            score = None
-    return SearchItem(
+    return Item(
         value=val if isinstance(val, dict) else loader(val),
         key=row["key"],
         namespace=namespace,
         created_at=row["created_at"],
         updated_at=row["updated_at"],
-        score=score,
     )
 
 
@@ -1034,72 +544,3 @@ def _decode_ns_bytes(namespace: Union[str, bytes, list]) -> tuple[str, ...]:
     if isinstance(namespace, bytes):
         namespace = namespace.decode()[1:]
     return tuple(namespace.split("."))
-
-
-def _get_distance_operator(store: Any) -> tuple[str, str]:
-    """Get the distance operator and score expression based on config."""
-    # Note: Today, we are not using ANN indices due to restrictions
-    # on PGVector's support for mixing vector and non-vector filters
-    # To use the index, PGVector expects:
-    #  - ORDER BY the operator NOT an expression (even negation blocks it)
-    #  - ASCENDING order
-    #  - Any WHERE clause should be over a partial index.
-    # If we violate any of these, it will use a sequential scan
-    # See https://github.com/pgvector/pgvector/issues/216 and the
-    # pgvector documentation for more details.
-    if not store.index_config:
-        raise ValueError(
-            "Embedding configuration is required for vector operations "
-            f"(for semantic search). "
-            f"Please provide an Embeddings when initializing the {store.__class__.__name__}."
-        )
-
-    config = cast(PostgresIndexConfig, store.index_config)
-    distance_type = config.get("distance_type", "cosine")
-
-    # Return the operator and the score expression
-    # The operator is used in the CTE and will be compatible with an ASCENDING ORDER
-    # sort clause.
-    # The score expression is used in the final query and will be compatible with
-    # a DESCENDING ORDER sort clause and the user's expectations of what the similarity score
-    # should be.
-    if distance_type == "l2":
-        # Final: "-(sv.embedding <-> %s::%s)"
-        # We return the "l2 similarity" so that the sorting order is the same
-        return "sv.embedding <-> %s::%s", "-scored.neg_score"
-    elif distance_type == "inner_product":
-        # Final: "-(sv.embedding <#> %s::%s)"
-        return "sv.embedding <#> %s::%s", "-(scored.neg_score)"
-    else:  # cosine similarity
-        # Final:  "1 - (sv.embedding <=> %s::%s)"
-        return "sv.embedding <=> %s::%s", "1 - scored.neg_score"
-
-
-def _ensure_index_config(
-    index_config: PostgresIndexConfig,
-) -> tuple[Optional["Embeddings"], PostgresIndexConfig]:
-    index_config = index_config.copy()
-    tokenized: list[tuple[str, Union[Literal["$"], list[str]]]] = []
-    tot = 0
-    text_fields = index_config.get("text_fields") or ["$"]
-    if isinstance(text_fields, str):
-        text_fields = [text_fields]
-    if not isinstance(text_fields, list):
-        raise ValueError(f"Text fields must be a list or a string. Got {text_fields}")
-    for p in text_fields:
-        if p == "$":
-            tokenized.append((p, "$"))
-            tot += 1
-        else:
-            toks = tokenize_path(p)
-            tokenized.append((p, toks))
-            tot += len(toks)
-    index_config["__tokenized_fields"] = tokenized
-    index_config["__estimated_num_vectors"] = tot
-    embeddings = ensure_embeddings(
-        index_config.get("embed"),
-    )
-    return embeddings, index_config
-
-
-_PLACEHOLDER = object()

libs/checkpoint-postgres/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langgraph-checkpoint-postgres"
-version = "2.0.8"
+version = "2.0.4"
 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"
 
 
@@ -34,11 +31,3 @@ async def clear_test_db(conn: AsyncConnection[DictRow]) -> None:
         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,211 +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:
-            checkpointer = AsyncPostgresSaver(conn)
-            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,30 +1,14 @@
 # type: ignore
-import asyncio
-import itertools
 import sys
 import uuid
-from collections.abc import AsyncIterator
-from concurrent.futures import ThreadPoolExecutor
-from contextlib import asynccontextmanager
-from typing import Any, Optional
+from typing import AsyncIterator
 
 import pytest
-from langchain_core.embeddings import Embeddings
+from conftest import DEFAULT_URI  # type: ignore
 from psycopg import AsyncConnection
 
-from langgraph.store.base import (
-    GetOp,
-    Item,
-    ListNamespacesOp,
-    PutOp,
-    SearchOp,
-)
+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"])
@@ -71,128 +55,6 @@ async def store(request) -> AsyncIterator[AsyncPostgresStore]:
             await conn.execute(f"DROP DATABASE {database}")
 
 
-async def test_no_running_loop(store: AsyncPostgresStore) -> None:
-    with pytest.raises(asyncio.InvalidStateError):
-        store.put(("foo", "bar"), "baz", {"val": "baz"})
-    with pytest.raises(asyncio.InvalidStateError):
-        store.get(("foo", "bar"), "baz")
-    with pytest.raises(asyncio.InvalidStateError):
-        store.delete(("foo", "bar"), "baz")
-    with pytest.raises(asyncio.InvalidStateError):
-        store.search(("foo", "bar"))
-    with pytest.raises(asyncio.InvalidStateError):
-        store.list_namespaces(prefix=("foo",))
-    with pytest.raises(asyncio.InvalidStateError):
-        store.batch([PutOp(namespace=("foo", "bar"), key="baz", value={"val": "baz"})])
-    with ThreadPoolExecutor(max_workers=1) as executor:
-        future = executor.submit(store.put, ("foo", "bar"), "baz", {"val": "baz"})
-        result = await asyncio.wrap_future(future)
-        assert result is None
-        future = executor.submit(store.get, ("foo", "bar"), "baz")
-        result = await asyncio.wrap_future(future)
-        assert result.value == {"val": "baz"}
-        result = await asyncio.wrap_future(
-            executor.submit(store.list_namespaces, prefix=("foo",))
-        )
-
-
-async def test_large_batches(request: Any, store: AsyncPostgresStore) -> None:
-    N = 100  # less important that we are performant here
-    M = 10
-
-    with ThreadPoolExecutor(max_workers=10) as executor:
-        futures = []
-        for m in range(M):
-            for i in range(N):
-                futures += [
-                    executor.submit(
-                        store.put,
-                        ("test", "foo", "bar", "baz", str(m % 2)),
-                        f"key{i}",
-                        value={"foo": "bar" + str(i)},
-                    ),
-                    executor.submit(
-                        store.get,
-                        ("test", "foo", "bar", "baz", str(m % 2)),
-                        f"key{i}",
-                    ),
-                    executor.submit(
-                        store.list_namespaces,
-                        prefix=None,
-                        max_depth=m + 1,
-                    ),
-                    executor.submit(
-                        store.search,
-                        ("test",),
-                    ),
-                    executor.submit(
-                        store.put,
-                        ("test", "foo", "bar", "baz", str(m % 2)),
-                        f"key{i}",
-                        value={"foo": "bar" + str(i)},
-                    ),
-                    executor.submit(
-                        store.put,
-                        ("test", "foo", "bar", "baz", str(m % 2)),
-                        f"key{i}",
-                        None,
-                    ),
-                ]
-
-        results = await asyncio.gather(
-            *(asyncio.wrap_future(future) for future in futures)
-        )
-    assert len(results) == M * N * 6
-
-
-async def test_large_batches_async(store: AsyncPostgresStore) -> None:
-    N = 1000
-    M = 10
-    coros = []
-    for m in range(M):
-        for i in range(N):
-            coros.append(
-                store.aput(
-                    ("test", "foo", "bar", "baz", str(m % 2)),
-                    f"key{i}",
-                    value={"foo": "bar" + str(i)},
-                )
-            )
-            coros.append(
-                store.aget(
-                    ("test", "foo", "bar", "baz", str(m % 2)),
-                    f"key{i}",
-                )
-            )
-            coros.append(
-                store.alist_namespaces(
-                    prefix=None,
-                    max_depth=m + 1,
-                )
-            )
-            coros.append(
-                store.asearch(
-                    ("test",),
-                )
-            )
-            coros.append(
-                store.aput(
-                    ("test", "foo", "bar", "baz", str(m % 2)),
-                    f"key{i}",
-                    value={"foo": "bar" + str(i)},
-                )
-            )
-            coros.append(
-                store.adelete(
-                    ("test", "foo", "bar", "baz", str(m % 2)),
-                    f"key{i}",
-                )
-            )
-
-    results = await asyncio.gather(*coros)
-    assert len(results) == M * N * 6
-
-
 async def test_abatch_order(store: AsyncPostgresStore) -> None:
     # Setup test data
     await store.aput(("test", "foo"), "key1", {"data": "value1"})
@@ -319,319 +181,272 @@ async def test_batch_list_namespaces_ops(store: AsyncPostgresStore) -> None:
     assert ("test", "namespace2") in results[0]
 
 
-@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+")
-
-    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_store.py

@@ -1,11 +1,9 @@
 # type: ignore
 
-from contextlib import contextmanager
-from typing import Any, Optional
 from uuid import uuid4
 
 import pytest
-from langchain_core.embeddings import Embeddings
+from conftest import DEFAULT_URI  # type: ignore
 from psycopg import Connection
 
 from langgraph.store.base import (
@@ -17,11 +15,6 @@ from langgraph.store.base import (
     SearchOp,
 )
 from langgraph.store.postgres import PostgresStore
-from tests.conftest import (
-    DEFAULT_URI,
-    VECTOR_TYPES,
-    CharacterEmbeddings,
-)
 
 
 @pytest.fixture(scope="function", params=["default", "pipe", "pool"])
@@ -347,438 +340,3 @@ class TestPostgresStore:
             # Cleanup
             for namespace, key, _ in test_data:
                 store.delete(namespace, key)
-
-
-@contextmanager
-def _create_vector_store(
-    vector_type: str,
-    distance_type: str,
-    fake_embeddings: Embeddings,
-    text_fields: Optional[list[str]] = None,
-) -> PostgresStore:
-    """Create a store with vector search enabled."""
-    database = f"test_{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,
-    }
-
-    with Connection.connect(admin_conn_string, autocommit=True) as conn:
-        conn.execute(f"CREATE DATABASE {database}")
-    try:
-        with PostgresStore.from_conn_string(
-            conn_string,
-            index=index_config,
-        ) as store:
-            store.setup()
-            yield store
-    finally:
-        with Connection.connect(admin_conn_string, autocommit=True) as conn:
-            conn.execute(f"DROP DATABASE {database}")
-
-
-@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]}",
-)
-def vector_store(
-    request,
-    fake_embeddings: Embeddings,
-) -> PostgresStore:
-    """Create a store with vector search enabled."""
-    vector_type, distance_type = request.param
-    with _create_vector_store(vector_type, distance_type, fake_embeddings) as store:
-        yield store
-
-
-def test_vector_store_initialization(
-    vector_store: PostgresStore, fake_embeddings: CharacterEmbeddings
-) -> None:
-    """Test store initialization with embedding config."""
-    # Store should be initialized with embedding config
-    assert vector_store.index_config is not None
-    assert vector_store.index_config["dims"] == fake_embeddings.dims
-    assert vector_store.index_config["embed"] == fake_embeddings
-
-
-def test_vector_insert_with_auto_embedding(vector_store: PostgresStore) -> 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"}),
-    ]
-
-    for key, value in docs:
-        vector_store.put(("test",), key, value)
-
-    results = vector_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
-
-
-def test_vector_update_with_embedding(vector_store: PostgresStore) -> None:
-    """Test that updating items properly updates their embeddings."""
-    vector_store.put(("test",), "doc1", {"text": "zany zebra Xerxes"})
-    vector_store.put(("test",), "doc2", {"text": "something about dogs"})
-    vector_store.put(("test",), "doc3", {"text": "text about birds"})
-
-    results_initial = vector_store.search(("test",), query="Zany Xerxes")
-    assert len(results_initial) > 0
-    assert results_initial[0].key == "doc1"
-    initial_score = results_initial[0].score
-
-    vector_store.put(("test",), "doc1", {"text": "new text about dogs"})
-
-    results_after = vector_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 < initial_score
-
-    results_new = vector_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
-    vector_store.put(("test",), "doc4", {"text": "new text about dogs"}, index=False)
-    results_new = vector_store.search(("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(vector_store: PostgresStore) -> None:
-    """Test combining vector search with filters."""
-    # 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:
-        vector_store.put(("test",), key, value)
-
-    results = vector_store.search(("test",), query="apple", filter={"color": "red"})
-    assert len(results) == 2
-    assert results[0].key == "doc1"
-
-    results = vector_store.search(("test",), query="car", filter={"color": "red"})
-    assert len(results) == 2
-    assert results[0].key == "doc2"
-
-    results = vector_store.search(
-        ("test",), query="bbbbluuu", filter={"score": {"$gt": 3.2}}
-    )
-    assert len(results) == 3
-    assert results[0].key == "doc4"
-
-    # Multiple filters
-    results = vector_store.search(
-        ("test",), query="apple", filter={"score": {"$gte": 4.0}, "color": "green"}
-    )
-    assert len(results) == 1
-    assert results[0].key == "doc3"
-
-
-def test_vector_search_pagination(vector_store: PostgresStore) -> None:
-    """Test pagination with vector search."""
-    # Insert multiple similar documents
-    for i in range(5):
-        vector_store.put(("test",), f"doc{i}", {"text": f"test document number {i}"})
-
-    # Test with different page sizes
-    results_page1 = vector_store.search(("test",), query="test", limit=2)
-    results_page2 = vector_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
-
-    # Get all results
-    all_results = vector_store.search(("test",), query="test", limit=10)
-    assert len(all_results) == 5
-
-
-def test_vector_search_edge_cases(vector_store: PostgresStore) -> None:
-    """Test edge cases in vector search."""
-    vector_store.put(("test",), "doc1", {"text": "test document"})
-
-    results = vector_store.search(("test",), query="")
-    assert len(results) == 1
-
-    results = vector_store.search(("test",), query=None)
-    assert len(results) == 1
-
-    long_query = "test " * 100
-    results = vector_store.search(("test",), query=long_query)
-    assert len(results) == 1
-
-    special_query = "test!@#$%^&*()"
-    results = vector_store.search(("test",), query=special_query)
-    assert len(results) == 1
-
-
-@pytest.mark.parametrize(
-    "vector_type,distance_type",
-    [
-        ("vector", "cosine"),
-        ("vector", "inner_product"),
-        ("halfvec", "cosine"),
-        ("halfvec", "inner_product"),
-    ],
-)
-def test_embed_with_path_sync(
-    request: Any,
-    fake_embeddings: CharacterEmbeddings,
-    vector_type: str,
-    distance_type: str,
-) -> None:
-    """Test vector search with specific text fields in Postgres store."""
-    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",
-        }
-        store.put(("test",), "doc1", doc1)
-        store.put(("test",), "doc2", doc2)
-
-        # doc2.key3 and doc1.key1 both would have the highest score
-        results = store.search(("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)
-
-        # ~Only match doc2
-        results = store.search(("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)
-
-        # ~Only match doc1
-        results = store.search(("test",), query="zzz")
-        assert len(results) == 2
-        assert results[0].key != results[1].key
-        assert results[0].key == "doc1"
-        assert results[0].score > results[1].score
-        assert ascore == pytest.approx(results[0].score, abs=1e-3)
-
-        # Un-indexed - will have low results for both. Not zero (because we're projecting)
-        # but less than the above.
-        results = store.search(("test",), query="www")
-        assert len(results) == 2
-        assert results[0].key != results[1].key
-        assert results[0].score < ascore
-        assert results[1].score < ascore
-
-
-@pytest.mark.parametrize(
-    "vector_type,distance_type",
-    [
-        ("vector", "cosine"),
-        ("vector", "inner_product"),
-        ("halfvec", "cosine"),
-        ("halfvec", "inner_product"),
-    ],
-)
-def test_embed_with_path_operation_config(
-    request: Any,
-    fake_embeddings: CharacterEmbeddings,
-    vector_type: str,
-    distance_type: str,
-) -> None:
-    """Test operation-level field configuration for vector search."""
-
-    with _create_vector_store(
-        vector_type,
-        distance_type,
-        fake_embeddings,
-        text_fields=["key17"],  # Default fields that won't match our test data
-    ) as store:
-        doc3 = {
-            "key0": "aaa",
-            "key1": "bbb",
-            "key2": "ccc",
-            "key3": "ddd",
-        }
-        doc4 = {
-            "key0": "eee",
-            "key1": "bbb",  # Same as doc3.key1
-            "key2": "fff",
-            "key3": "ggg",
-        }
-
-        store.put(("test",), "doc3", doc3, index=["key0", "key1"])
-        store.put(("test",), "doc4", doc4, index=["key1", "key3"])
-
-        results = store.search(("test",), query="aaa")
-        assert len(results) == 2
-        assert results[0].key == "doc3"
-        assert len(set(r.key for r in results)) == 2
-        assert results[0].score > results[1].score
-
-        results = store.search(("test",), query="ggg")
-        assert len(results) == 2
-        assert results[0].key == "doc4"
-        assert results[0].score > results[1].score
-
-        results = store.search(("test",), query="bbb")
-        assert len(results) == 2
-        assert results[0].key != results[1].key
-        assert results[0].score == pytest.approx(results[1].score, abs=1e-3)
-
-        results = store.search(("test",), query="ccc")
-        assert len(results) == 2
-        assert all(
-            r.score < 0.9 for r in results
-        )  # Unindexed field should have low scores
-
-        # Test index=False behavior
-        doc5 = {
-            "key0": "hhh",
-            "key1": "iii",
-        }
-        store.put(("test",), "doc5", doc5, index=False)
-        results = store.search(("test",))
-        assert len(results) == 3
-        assert all(r.score is None for r in results)
-        assert any(r.key == "doc5" for r in results)
-
-        results = store.search(("test",), query="hhh")
-        # TODO: We don't currently fill in additional results if there are not enough
-        # returned during vector search.
-        # assert len(results) == 3
-        # doc5_result = next(r for r in results if r.key == "doc5")
-        # assert doc5_result.score is None
-
-
-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.
-    """
-
-    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 _inner_product(X: list[float], Y: list[list[float]]) -> list[float]:
-    """
-    Compute inner product between a vector X and a matrix Y.
-    Lazy import numpy for efficiency.
-    """
-
-    similarities = []
-    for y in Y:
-        similarity = sum(a * b for a, b in zip(X, y))
-        similarities.append(similarity)
-
-    return similarities
-
-
-def _neg_l2_distance(X: list[float], Y: list[list[float]]) -> list[float]:
-    """
-    Compute l2 distance between a vector X and a matrix Y.
-    Lazy import numpy for efficiency.
-    """
-
-    similarities = []
-    for y in Y:
-        similarity = sum((a - b) ** 2 for a, b in zip(X, y)) ** 0.5
-        similarities.append(-similarity)
-
-    return similarities
-
-
-@pytest.mark.parametrize(
-    "vector_type,distance_type",
-    [
-        ("vector", "cosine"),
-        ("vector", "inner_product"),
-        ("halfvec", "l2"),
-    ],
-)
-@pytest.mark.parametrize("query", ["aaa", "bbb", "ccc", "abcd", "poisson"])
-def test_scores(
-    fake_embeddings: CharacterEmbeddings,
-    vector_type: str,
-    distance_type: str,
-    query: str,
-) -> None:
-    """Test operation-level field configuration for vector search."""
-    with _create_vector_store(
-        vector_type,
-        distance_type,
-        fake_embeddings,
-        text_fields=["key0"],
-    ) as store:
-        doc = {
-            "key0": "aaa",
-        }
-        store.put(("test",), "doc", doc, index=["key0", "key1"])
-
-        results = store.search((), query=query)
-        vec0 = fake_embeddings.embed_query(doc["key0"])
-        vec1 = fake_embeddings.embed_query(query)
-        if distance_type == "cosine":
-            similarities = _cosine_similarity(vec1, [vec0])
-        elif distance_type == "inner_product":
-            similarities = _inner_product(vec1, [vec0])
-        elif distance_type == "l2":
-            similarities = _neg_l2_distance(vec1, [vec0])
-
-        assert len(results) == 1
-        assert results[0].score == pytest.approx(similarities[0], abs=1e-3)

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,198 +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:
-            checkpointer = PostgresSaver(conn)
-            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/checkpoint/memory/__init__.py

@@ -1,3 +1,4 @@
+import asyncio
 import logging
 import os
 import pickle
@@ -5,6 +6,7 @@ import random
 import shutil
 from collections import defaultdict
 from contextlib import AbstractAsyncContextManager, AbstractContextManager, ExitStack
+from functools import partial
 from types import TracebackType
 from typing import Any, AsyncIterator, Dict, Iterator, Optional, Sequence, Tuple, Type
 
@@ -393,7 +395,9 @@ class MemorySaver(
         Returns:
             Optional[CheckpointTuple]: The retrieved checkpoint tuple, or None if no matching checkpoint was found.
         """
-        return self.get_tuple(config)
+        return await asyncio.get_running_loop().run_in_executor(
+            None, self.get_tuple, config
+        )
 
     async def alist(
         self,
@@ -414,8 +418,24 @@ class MemorySaver(
         Yields:
             AsyncIterator[CheckpointTuple]: An asynchronous iterator of checkpoint tuples.
         """
-        for item in self.list(config, filter=filter, before=before, limit=limit):
-            yield item
+        loop = asyncio.get_running_loop()
+        iter = await loop.run_in_executor(
+            None,
+            partial(
+                self.list,
+                before=before,
+                limit=limit,
+                filter=filter,
+            ),
+            config,
+        )
+        while True:
+            # handling StopIteration exception inside coroutine won't work
+            # as expected, so using next() with default value to break the loop
+            if item := await loop.run_in_executor(None, next, iter, None):
+                yield item
+            else:
+                break
 
     async def aput(
         self,
@@ -435,7 +455,9 @@ class MemorySaver(
         Returns:
             RunnableConfig: The updated config containing the saved checkpoint's timestamp.
         """
-        return self.put(config, checkpoint, metadata, new_versions)
+        return await asyncio.get_running_loop().run_in_executor(
+            None, self.put, config, checkpoint, metadata, new_versions
+        )
 
     async def aput_writes(
         self,
@@ -452,9 +474,10 @@ class MemorySaver(
             config (RunnableConfig): The config to associate with the writes.
             writes (List[Tuple[str, Any]]): The writes to save, each as a (channel, value) pair.
             task_id (str): Identifier for the task creating the writes.
-        return self.put_writes(config, writes, task_id)
         """
-        return self.put_writes(config, writes, task_id)
+        return await asyncio.get_running_loop().run_in_executor(
+            None, self.put_writes, config, writes, task_id
+        )
 
     def get_next_version(self, current: Optional[str], channel: ChannelProtocol) -> str:
         if current is None:

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

@@ -1,7 +1,6 @@
 import asyncio
-import functools
 import weakref
-from typing import Any, Callable, Iterable, Literal, Optional, TypeVar, Union
+from typing import Any, Optional
 
 from langgraph.store.base import (
     BaseStore,
@@ -9,42 +8,13 @@ from langgraph.store.base import (
     Item,
     ListNamespacesOp,
     MatchCondition,
-    NamespacePath,
+    NameSpacePath,
     Op,
     PutOp,
-    Result,
-    SearchItem,
     SearchOp,
     _validate_namespace,
 )
 
-F = TypeVar("F", bound=Callable)
-
-
-def _check_loop(func: F) -> F:
-    @functools.wraps(func)
-    def wrapper(store: "AsyncBatchedBaseStore", *args: Any, **kwargs: Any) -> Any:
-        method_name: str = func.__name__
-        try:
-            current_loop = asyncio.get_running_loop()
-            if current_loop is store._loop:
-                replacement_str = (
-                    f"Specifically, replace `store.{method_name}(...)` with `await store.a{method_name}(...)"
-                    if method_name
-                    else "For example, replace `store.get(...)` with `await store.aget(...)`"
-                )
-                raise asyncio.InvalidStateError(
-                    f"Synchronous calls to {store.__class__.__name__} detected in the main event loop. "
-                    "This can lead to deadlocks or performance issues. "
-                    "Please use the asynchronous interface for main thread operations. "
-                    f"{replacement_str} "
-                )
-        except RuntimeError:
-            pass
-        return func(store, *args, **kwargs)
-
-    return wrapper
-
 
 class AsyncBatchedBaseStore(BaseStore):
     """Efficiently batch operations in a background task."""
@@ -52,7 +22,6 @@ class AsyncBatchedBaseStore(BaseStore):
     __slots__ = ("_loop", "_aqueue", "_task")
 
     def __init__(self) -> None:
-        super().__init__()
         self._loop = asyncio.get_running_loop()
         self._aqueue: dict[asyncio.Future, Op] = {}
         self._task = self._loop.create_task(_run(self._aqueue, weakref.ref(self)))
@@ -74,13 +43,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(
@@ -88,11 +56,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(
@@ -107,8 +74,8 @@ class AsyncBatchedBaseStore(BaseStore):
     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,
@@ -129,82 +96,6 @@ class AsyncBatchedBaseStore(BaseStore):
         self._aqueue[fut] = op
         return await fut
 
-    @_check_loop
-    def batch(self, ops: Iterable[Op]) -> list[Result]:
-        return asyncio.run_coroutine_threadsafe(self.abatch(ops), self._loop).result()
-
-    @_check_loop
-    def get(
-        self,
-        namespace: tuple[str, ...],
-        key: str,
-    ) -> Optional[Item]:
-        return asyncio.run_coroutine_threadsafe(
-            self.aget(namespace, key=key), self._loop
-        ).result()
-
-    @_check_loop
-    def search(
-        self,
-        namespace_prefix: tuple[str, ...],
-        /,
-        *,
-        query: Optional[str] = None,
-        filter: Optional[dict[str, Any]] = None,
-        limit: int = 10,
-        offset: int = 0,
-    ) -> list[SearchItem]:
-        return asyncio.run_coroutine_threadsafe(
-            self.asearch(
-                namespace_prefix, query=query, filter=filter, limit=limit, offset=offset
-            ),
-            self._loop,
-        ).result()
-
-    @_check_loop
-    def put(
-        self,
-        namespace: tuple[str, ...],
-        key: str,
-        value: dict[str, Any],
-        index: Optional[Union[Literal[False], list[str]]] = None,
-    ) -> None:
-        _validate_namespace(namespace)
-        asyncio.run_coroutine_threadsafe(
-            self.aput(namespace, key=key, value=value, index=index), self._loop
-        ).result()
-
-    @_check_loop
-    def delete(
-        self,
-        namespace: tuple[str, ...],
-        key: str,
-    ) -> None:
-        asyncio.run_coroutine_threadsafe(
-            self.adelete(namespace, key=key), self._loop
-        ).result()
-
-    @_check_loop
-    def list_namespaces(
-        self,
-        *,
-        prefix: Optional[NamespacePath] = None,
-        suffix: Optional[NamespacePath] = None,
-        max_depth: Optional[int] = None,
-        limit: int = 100,
-        offset: int = 0,
-    ) -> list[tuple[str, ...]]:
-        return asyncio.run_coroutine_threadsafe(
-            self.alist_namespaces(
-                prefix=prefix,
-                suffix=suffix,
-                max_depth=max_depth,
-                limit=limit,
-                offset=offset,
-            ),
-            self._loop,
-        ).result()
-
 
 def _dedupe_ops(values: list[Op]) -> tuple[Optional[list[int]], list[Op]]:
     """Dedupe operations while preserving order for results.
@@ -250,8 +141,7 @@ def _dedupe_ops(values: list[Op]) -> tuple[Optional[list[int]], list[Op]]:
 
 
 async def _run(
-    aqueue: dict[asyncio.Future, Op],
-    store: weakref.ReferenceType[BaseStore],
+    aqueue: dict[asyncio.Future, Op], store: weakref.ReferenceType[BaseStore]
 ) -> None:
     while True:
         await asyncio.sleep(0)

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.6"
 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,30 +1,19 @@
-# 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:
+    def __init__(self) -> None:
         super().__init__()
-        self._store = InMemoryStore(**kwargs)
+        self._store = InMemoryStore()
 
     def batch(self, ops: Iterable[Op]) -> list[Result]:
         return self._store.batch(ops)
@@ -33,74 +22,6 @@ class MockAsyncBatchedStore(AsyncBatchedBaseStore):
         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:
     abatch = mocker.stub()
 
@@ -383,14 +304,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
 
@@ -426,9 +345,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
 
@@ -504,446 +420,3 @@ async def test_async_batch_store_deduplication(mocker: MockerFixture) -> None:
     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/langgraph_cli/cli.py

@@ -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:
@@ -602,7 +608,6 @@ def dev(
             sys.path.append(str(dep_path))
 
     graphs = config_json.get("graphs", {})
-
     run_server(
         host,
         port,
@@ -611,25 +616,10 @@ 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,
+        env=config_json.get("env", None),
     )
 
 
-@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

@@ -10,44 +10,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 +18,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 +49,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 +58,6 @@ def validate_config(config: Config) -> Config:
             "dependencies": config.get("dependencies", []),
             "graphs": config.get("graphs", {}),
             "env": config.get("env", {}),
-            "store": config.get("store"),
         }
     )
 
@@ -392,14 +352,7 @@ RUN set -ex && \\
             ],
         )
     )
-    store_config = config.get("store")
-    env_additional_config = (
-        ""
-        if not store_config
-        else f"""
-ENV LANGGRAPH_STORE='{json.dumps(store_config)}'
-"""
-    )
+
     return f"""FROM {base_image}:{config['python_version']}
 
 {os.linesep.join(config["dockerfile_lines"])}
@@ -407,7 +360,7 @@ ENV LANGGRAPH_STORE='{json.dumps(store_config)}'
 {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 ""}"""
@@ -437,14 +390,7 @@ 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)}'
-"""
-    )
+
     return f"""FROM {base_image}:{config['node_version']}
 
 {os.linesep.join(config["dockerfile_lines"])}
@@ -452,7 +398,7 @@ ENV LANGGRAPH_STORE='{json.dumps(store_config)}'
 ADD . {faux_path}
 
 RUN cd {faux_path} && {install_cmd}
-{env_additional_config}
+
 ENV LANGSERVE_GRAPHS='{json.dumps(config["graphs"])}'
 
 WORKDIR {faux_path}

libs/cli/langgraph_cli/langgraph-api-schema.json

@@ -0,0 +1,104 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "LangGraph Configuration Schema",
+  "description": "Schema for LangGraph configuration file (langgraph.json)",
+  "type": "object",
+  "oneOf": [
+    {
+      "type": "object",
+      "required": ["node_version", "graphs"],
+      "properties": {
+        "node_version": {
+          "type": "string",
+          "pattern": "^[0-9]+$",
+          "description": "Node.js major version number (e.g. '20'). Must be >= 20."
+        },
+        "dockerfile_lines": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "Additional lines to add to the Dockerfile"
+        },
+        "graphs": {
+          "type": "object",
+          "minProperties": 1,
+          "additionalProperties": {
+            "type": "string",
+            "pattern": "^[^:]+:[^:]+$",
+            "description": "Import string in format '<module>:<attribute>'"
+          },
+          "description": "Dictionary mapping graph IDs to import strings"
+        },
+        "env": {
+          "oneOf": [
+            {
+              "type": "object",
+              "additionalProperties": {
+                "type": "string"
+              }
+            },
+            {
+              "type": "string"
+            }
+          ],
+          "description": "Environment variables as object or path to .env file"
+        }
+      }
+    },
+    {
+      "type": "object",
+      "required": ["dependencies", "graphs"],
+      "properties": {
+        "python_version": {
+          "type": "string",
+          "pattern": "^[0-9]+\\.[0-9]+$",
+          "description": "Python version in 'major.minor' format (e.g. '3.11'). Must be >= 3.11."
+        },
+        "pip_config_file": {
+          "type": "string",
+          "description": "Path to pip configuration file"
+        },
+        "dockerfile_lines": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "Additional lines to add to the Dockerfile"
+        },
+        "dependencies": {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "type": "string"
+          },
+          "description": "List of dependencies (PyPI packages or local paths)"
+        },
+        "graphs": {
+          "type": "object",
+          "minProperties": 1,
+          "additionalProperties": {
+            "type": "string",
+            "pattern": "^[^:]+:[^:]+$",
+            "description": "Import string in format '<module>:<attribute>'"
+          },
+          "description": "Dictionary mapping graph IDs to import strings"
+        },
+        "env": {
+          "oneOf": [
+            {
+              "type": "object",
+              "additionalProperties": {
+                "type": "string"
+              }
+            },
+            {
+              "type": "string"
+            }
+          ],
+          "description": "Environment variables as object or path to .env file"
+        }
+      }
+    }
+  ]
+}

libs/cli/poetry.lock

@@ -565,13 +565,13 @@ langgraph-sdk = ">=0.1.32,<0.2.0"
 
 [[package]]
 name = "langgraph-api"
-version = "0.0.6"
+version = "0.0.2"
 description = ""
 optional = true
 python-versions = "<4.0,>=3.11.0"
 files = [
-    {file = "langgraph_api-0.0.6-py3-none-any.whl", hash = "sha256:f64b13959d721143f6a023af5b9ffc9aa054064af98d21d5d8090cda7e7bffd2"},
-    {file = "langgraph_api-0.0.6.tar.gz", hash = "sha256:badac44fa1ec979509e56fc0da57eeb5f278ee5871f27803f73ea6d8822c21b9"},
+    {file = "langgraph_api-0.0.2-py3-none-any.whl", hash = "sha256:7a30fb21987572eacc93dd1c69c2155c17957afed71dde18d6f47992b3124d65"},
+    {file = "langgraph_api-0.0.2.tar.gz", hash = "sha256:b751afca96cb6db67fe2f48e798ada27a4df068f0df86b36d2b8eee52344bbf0"},
 ]
 
 [package.dependencies]
@@ -579,8 +579,8 @@ cryptography = ">=43.0.3,<44.0.0"
 httpx = ">=0.27.0"
 jsonschema-rs = ">=0.25.0,<0.26.0"
 langchain-core = ">=0.2.38,<0.4.0"
-langgraph = ">=0.2.52,<0.3.0"
-langgraph-checkpoint = ">=2.0.7,<3.0"
+langgraph = ">=0.2.52"
+langgraph-checkpoint = ">=2.0.5,<3.0"
 langsmith = ">=0.1.63,<0.2.0"
 orjson = ">=3.10.1"
 pyjwt = ">=2.9.0,<3.0.0"
@@ -593,13 +593,13 @@ watchfiles = ">=0.13"
 
 [[package]]
 name = "langgraph-checkpoint"
-version = "2.0.7"
+version = "2.0.6"
 description = "Library with base interfaces for LangGraph checkpoint savers."
 optional = true
 python-versions = "<4.0.0,>=3.9.0"
 files = [
-    {file = "langgraph_checkpoint-2.0.7-py3-none-any.whl", hash = "sha256:9709f672e1c5a47e13352067c2ffa114dd91d443967b7ce8a1d36d6fc170370e"},
-    {file = "langgraph_checkpoint-2.0.7.tar.gz", hash = "sha256:88d648a331d20aa8ce65280de34a34a9190380b004f6afcc5f9894fe3abeed08"},
+    {file = "langgraph_checkpoint-2.0.6-py3-none-any.whl", hash = "sha256:2878283c3ee2519bf180df9b7b7155b73fa05eb63b1af9600a03e03a930d8c53"},
+    {file = "langgraph_checkpoint-2.0.6.tar.gz", hash = "sha256:69ab9c61c4e2992264671f55579c24070b7b6cedc105a33da3fba6526df248cf"},
 ]
 
 [package.dependencies]
@@ -608,13 +608,13 @@ msgpack = ">=1.1.0,<2.0.0"
 
 [[package]]
 name = "langgraph-sdk"
-version = "0.1.40"
+version = "0.1.36"
 description = "SDK for interacting with LangGraph API"
 optional = true
 python-versions = "<4.0.0,>=3.9.0"
 files = [
-    {file = "langgraph_sdk-0.1.40-py3-none-any.whl", hash = "sha256:8810cca5e4144cf3a5441fc76b4ee6e658ec95f932d3a0bf9ad63de117e925b9"},
-    {file = "langgraph_sdk-0.1.40.tar.gz", hash = "sha256:ab2719ac7274612a791a7a0ad9395d250357106cba8ba81bca9968fc91009af2"},
+    {file = "langgraph_sdk-0.1.36-py3-none-any.whl", hash = "sha256:b11e1f0bc67631134d09d50c812dc73f9eb30394764ae1144d7d2a786a715355"},
+    {file = "langgraph_sdk-0.1.36.tar.gz", hash = "sha256:2a2c651b7851ba15aeaab7e4e3ea7fd8357ef1cb0b592f264916fa990cdda6e7"},
 ]
 
 [package.dependencies]
@@ -624,13 +624,13 @@ orjson = ">=3.10.1"
 
 [[package]]
 name = "langsmith"
-version = "0.1.147"
+version = "0.1.146"
 description = "Client library to connect to the LangSmith LLM Tracing and Evaluation Platform."
 optional = true
 python-versions = "<4.0,>=3.8.1"
 files = [
-    {file = "langsmith-0.1.147-py3-none-any.whl", hash = "sha256:7166fc23b965ccf839d64945a78e9f1157757add228b086141eb03a60d699a15"},
-    {file = "langsmith-0.1.147.tar.gz", hash = "sha256:2e933220318a4e73034657103b3b1a3a6109cc5db3566a7e8e03be8d6d7def7a"},
+    {file = "langsmith-0.1.146-py3-none-any.whl", hash = "sha256:9d062222f1a32c9b047dab0149b24958f988989cd8d4a5f9139ff959a51e59d8"},
+    {file = "langsmith-0.1.146.tar.gz", hash = "sha256:ead8b0b9d5b6cd3ac42937ec48bdf09d4afe7ca1bba22dc05eb65591a18106f8"},
 ]
 
 [package.dependencies]
@@ -643,9 +643,6 @@ pydantic = [
 requests = ">=2,<3"
 requests-toolbelt = ">=1.0.0,<2.0.0"
 
-[package.extras]
-langsmith-pyo3 = ["langsmith-pyo3 (>=0.1.0rc2,<0.2.0)"]
-
 [[package]]
 name = "msgpack"
 version = "1.1.0"
@@ -1038,13 +1035,13 @@ typing-extensions = ">=4.6.0,<4.7.0 || >4.7.0"
 
 [[package]]
 name = "pyjwt"
-version = "2.10.1"
+version = "2.10.0"
 description = "JSON Web Token implementation in Python"
 optional = true
 python-versions = ">=3.9"
 files = [
-    {file = "PyJWT-2.10.1-py3-none-any.whl", hash = "sha256:dcdd193e30abefd5debf142f9adfcdd2b58004e644f25406ffaebd50bd98dacb"},
-    {file = "pyjwt-2.10.1.tar.gz", hash = "sha256:3cc5772eb20009233caf06e9d8a0577824723b44e6648ee0a2aedb6cf9381953"},
+    {file = "PyJWT-2.10.0-py3-none-any.whl", hash = "sha256:543b77207db656de204372350926bed5a86201c4cbff159f623f79c7bb487a15"},
+    {file = "pyjwt-2.10.0.tar.gz", hash = "sha256:7628a7eb7938959ac1b26e819a1df0fd3259505627b575e4bad6d08f76db695c"},
 ]
 
 [package.extras]
@@ -1345,43 +1342,13 @@ test = ["pytest", "tornado (>=4.5)", "typeguard"]
 
 [[package]]
 name = "tomli"
-version = "2.2.1"
+version = "2.1.0"
 description = "A lil' TOML parser"
 optional = false
 python-versions = ">=3.8"
 files = [
-    {file = "tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249"},
-    {file = "tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6"},
-    {file = "tomli-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a"},
-    {file = "tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee"},
-    {file = "tomli-2.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e"},
-    {file = "tomli-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4"},
-    {file = "tomli-2.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106"},
-    {file = "tomli-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8"},
-    {file = "tomli-2.2.1-cp311-cp311-win32.whl", hash = "sha256:465af0e0875402f1d226519c9904f37254b3045fc5084697cefb9bdde1ff99ff"},
-    {file = "tomli-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b"},
-    {file = "tomli-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea"},
-    {file = "tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8"},
-    {file = "tomli-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192"},
-    {file = "tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222"},
-    {file = "tomli-2.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77"},
-    {file = "tomli-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6"},
-    {file = "tomli-2.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd"},
-    {file = "tomli-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e"},
-    {file = "tomli-2.2.1-cp312-cp312-win32.whl", hash = "sha256:889f80ef92701b9dbb224e49ec87c645ce5df3fa2cc548664eb8a25e03127a98"},
-    {file = "tomli-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4"},
-    {file = "tomli-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f4039b9cbc3048b2416cc57ab3bda989a6fcf9b36cf8937f01a6e731b64f80d7"},
-    {file = "tomli-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:286f0ca2ffeeb5b9bd4fcc8d6c330534323ec51b2f52da063b11c502da16f30c"},
-    {file = "tomli-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a92ef1a44547e894e2a17d24e7557a5e85a9e1d0048b0b5e7541f76c5032cb13"},
-    {file = "tomli-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9316dc65bed1684c9a98ee68759ceaed29d229e985297003e494aa825ebb0281"},
-    {file = "tomli-2.2.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e85e99945e688e32d5a35c1ff38ed0b3f41f43fad8df0bdf79f72b2ba7bc5272"},
-    {file = "tomli-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac065718db92ca818f8d6141b5f66369833d4a80a9d74435a268c52bdfa73140"},
-    {file = "tomli-2.2.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d920f33822747519673ee656a4b6ac33e382eca9d331c87770faa3eef562aeb2"},
-    {file = "tomli-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a198f10c4d1b1375d7687bc25294306e551bf1abfa4eace6650070a5c1ae2744"},
-    {file = "tomli-2.2.1-cp313-cp313-win32.whl", hash = "sha256:d3f5614314d758649ab2ab3a62d4f2004c825922f9e370b29416484086b264ec"},
-    {file = "tomli-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:a38aa0308e754b0e3c67e344754dff64999ff9b513e691d0e786265c93583c69"},
-    {file = "tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc"},
-    {file = "tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff"},
+    {file = "tomli-2.1.0-py3-none-any.whl", hash = "sha256:a5c57c3d1c56f5ccdf89f6523458f60ef716e210fc47c4cfb188c5ba473e0391"},
+    {file = "tomli-2.1.0.tar.gz", hash = "sha256:3f646cae2aec94e17d04973e4249548320197cfabdf130015d023de4b74d8ab8"},
 ]
 
 [[package]]
@@ -1561,4 +1528,4 @@ inmem = ["langgraph-api", "python-dotenv"]
 [metadata]
 lock-version = "2.0"
 python-versions = "^3.9.0,<4.0"
-content-hash = "8eaaa66d9e6e447699e3bcee336dfe779b58c956f8c2ad6678008a07be935838"
+content-hash = "3d655bb578e20219e19152d4a3d86be370fe3be61b5559847f0204dfff499b4a"

libs/cli/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langgraph-cli"
-version = "0.1.61"
+version = "0.1.59"
 description = "CLI for interacting with LangGraph API"
 authors = []
 license = "MIT"
@@ -14,7 +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" }
+langgraph-api = { version = ">=0.0.2,<0.1.0", optional = true, python = ">=3.11,<4.0" }
 python-dotenv = { version = ">=0.8.0", optional = true }
 
 [tool.poetry.group.dev.dependencies]

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,12 +48,6 @@ 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 ?=

libs/langgraph/langgraph/channels/base.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Any, Generic, Optional, Sequence, TypeVar
+from typing import Any, Generic, Optional, Sequence, Type, TypeVar
 
 from typing_extensions import Self
 
@@ -13,7 +13,7 @@ C = TypeVar("C")
 class BaseChannel(Generic[Value, Update, C], ABC):
     __slots__ = ("key", "typ")
 
-    def __init__(self, typ: Any, key: str = "") -> None:
+    def __init__(self, typ: Type[Any], key: str = "") -> None:
         self.typ = typ
         self.key = key
 

libs/langgraph/langgraph/constants.py

@@ -40,16 +40,12 @@ SCHEDULED = sys.intern("__scheduled__")
 # marker to signal node was scheduled (in distributed mode)
 TASKS = sys.intern("__pregel_tasks")
 # for Send objects returned by nodes/edges, corresponds to PUSH below
-RETURN = sys.intern("__return__")
-# for writes of a task where we simply record the return value
 
 # --- Reserved config.configurable keys ---
 CONFIG_KEY_SEND = sys.intern("__pregel_send")
 # holds the `write` function that accepts writes to state/edges/reserved keys
 CONFIG_KEY_READ = sys.intern("__pregel_read")
 # holds the `read` function that returns a copy of the current state
-CONFIG_KEY_CALL = sys.intern("__pregel_call")
-# holds the `call` function that accepts a node/func, args and returns a future
 CONFIG_KEY_CHECKPOINTER = sys.intern("__pregel_checkpointer")
 # holds a `BaseCheckpointSaver` passed from parent graph to child graphs
 CONFIG_KEY_STREAM = sys.intern("__pregel_stream")
@@ -76,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/func/__init__.py

@@ -1,120 +0,0 @@
-import asyncio
-import concurrent
-import concurrent.futures
-import inspect
-import types
-from functools import partial, update_wrapper
-from typing import (
-    Any,
-    Awaitable,
-    Callable,
-    Optional,
-    TypeVar,
-    Union,
-    overload,
-)
-
-from typing_extensions import ParamSpec
-
-from langgraph.channels.ephemeral_value import EphemeralValue
-from langgraph.channels.last_value import LastValue
-from langgraph.checkpoint.base import BaseCheckpointSaver
-from langgraph.constants import END, START, TAG_HIDDEN
-from langgraph.pregel import Pregel
-from langgraph.pregel.call import get_runnable_for_func
-from langgraph.pregel.read import PregelNode
-from langgraph.pregel.write import ChannelWrite, ChannelWriteEntry
-from langgraph.store.base import BaseStore
-from langgraph.types import RetryPolicy, StreamMode, StreamWriter
-
-P = ParamSpec("P")
-P1 = TypeVar("P1")
-T = TypeVar("T")
-
-
-def call(
-    func: Callable[[P1], T],
-    input: P1,
-    *,
-    retry: Optional[RetryPolicy] = None,
-) -> concurrent.futures.Future[T]:
-    from langgraph.constants import CONFIG_KEY_CALL
-    from langgraph.utils.config import get_configurable
-
-    conf = get_configurable()
-    impl = conf[CONFIG_KEY_CALL]
-    fut = impl(func, input, retry=retry)
-    return fut
-
-
-@overload
-def task(
-    *, retry: Optional[RetryPolicy] = None
-) -> Callable[[Callable[P, Awaitable[T]]], Callable[P, asyncio.Future[T]]]: ...
-
-
-@overload
-def task(  # type: ignore[overload-cannot-match]
-    *, retry: Optional[RetryPolicy] = None
-) -> Callable[[Callable[P, T]], Callable[P, concurrent.futures.Future[T]]]: ...
-
-
-def task(
-    *, retry: Optional[RetryPolicy] = None
-) -> Union[
-    Callable[[Callable[P, Awaitable[T]]], Callable[P, asyncio.Future[T]]],
-    Callable[[Callable[P, T]], Callable[P, concurrent.futures.Future[T]]],
-]:
-    def _task(func: Callable[P, T]) -> Callable[P, concurrent.futures.Future[T]]:
-        return update_wrapper(partial(call, func, retry=retry), func)
-
-    return _task
-
-
-def entrypoint(
-    *,
-    checkpointer: Optional[BaseCheckpointSaver] = None,
-    store: Optional[BaseStore] = None,
-) -> Callable[[types.FunctionType], Pregel]:
-    def _imp(func: types.FunctionType) -> Pregel:
-        if inspect.isgeneratorfunction(func):
-
-            def gen_wrapper(*args: Any, writer: StreamWriter, **kwargs: Any) -> Any:
-                for chunk in func(*args, **kwargs):
-                    writer(chunk)
-
-            bound = get_runnable_for_func(gen_wrapper)
-            stream_mode: StreamMode = "custom"
-        elif inspect.isasyncgenfunction(func):
-
-            async def agen_wrapper(
-                *args: Any, writer: StreamWriter, **kwargs: Any
-            ) -> Any:
-                async for chunk in func(*args, **kwargs):
-                    writer(chunk)
-
-            bound = get_runnable_for_func(agen_wrapper)
-            stream_mode = "custom"
-        else:
-            bound = get_runnable_for_func(func)
-            stream_mode = "updates"
-
-        return Pregel(
-            nodes={
-                func.__name__: PregelNode(
-                    bound=bound,
-                    triggers=[START],
-                    channels=[START],
-                    writers=[ChannelWrite([ChannelWriteEntry(END)], tags=[TAG_HIDDEN])],
-                )
-            },
-            channels={START: EphemeralValue(Any), END: LastValue(Any, END)},
-            input_channels=START,
-            output_channels=END,
-            stream_channels=END,
-            stream_mode=stream_mode,
-            checkpointer=checkpointer,
-            store=store,
-        )
-
-    return _imp

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}`")
@@ -629,10 +628,3 @@ class CompiledGraph(Pregel):
                     add_edge(key, end, conditional=True)
 
         return graph
-
-    def _repr_mimebundle_(self, **kwargs: Any) -> dict[str, Any]:
-        """Mime bundle used by Jupyter to display the graph"""
-        return {
-            "text/plain": repr(self),
-            "image/png": self.get_graph().draw_mermaid_png(),
-        }

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,
@@ -51,13 +53,9 @@ from langgraph.managed.base import (
     is_writable_managed_value,
 )
 from langgraph.pregel.read import ChannelRead, PregelNode
-from langgraph.pregel.write import (
-    ChannelWrite,
-    ChannelWriteEntry,
-    ChannelWriteTupleEntry,
-)
+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
@@ -86,6 +84,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]]
@@ -378,7 +392,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]))
@@ -559,7 +573,6 @@ class StateGraph(Graph):
         for key, node in self.nodes.items():
             compiled.attach_node(key, node)
 
-        compiled.attach_branch(START, SELF, CONTROL_BRANCH, with_reader=False)
         for key, node in self.nodes.items():
             compiled.attach_branch(key, SELF, CONTROL_BRANCH, with_reader=False)
 
@@ -613,59 +626,33 @@ class CompiledStateGraph(CompiledGraph):
                 if is_writable_managed_value(v)
             ]
 
-        def _get_root(input: Any) -> Optional[Sequence[tuple[str, Any]]]:
+        def _get_root(input: Any) -> Any:
             if isinstance(input, Command):
                 if input.graph == Command.PARENT:
-                    return ()
-                return input._update_as_tuples()
-            elif (
-                isinstance(input, (list, tuple))
-                and input
-                and any(isinstance(i, Command) for i in input)
-            ):
-                updates: list[tuple[str, Any]] = []
-                for i in input:
-                    if isinstance(i, Command):
-                        if i.graph == Command.PARENT:
-                            continue
-                        updates.extend(i._update_as_tuples())
-                    else:
-                        updates.append(("__root__", i))
-                return updates
-            elif input is not None:
-                return [("__root__", input)]
+                    return SKIP_WRITE
+                return input.update
+            else:
+                return input
 
-        def _get_updates(
-            input: Union[None, dict, Any],
-        ) -> Optional[Sequence[tuple[str, Any]]]:
+        # 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 None
+                return SKIP_WRITE
             elif isinstance(input, dict):
-                return [(k, v) for k, v in input.items() if k in output_keys]
+                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}"
+                    )
+                return input.get(key, SKIP_WRITE)
             elif isinstance(input, Command):
                 if input.graph == Command.PARENT:
-                    return None
-                return input._update_as_tuples()
-            elif (
-                isinstance(input, (list, tuple))
-                and input
-                and any(isinstance(i, Command) for i in input)
-            ):
-                updates: list[tuple[str, Any]] = []
-                for i in input:
-                    if isinstance(i, Command):
-                        if i.graph == Command.PARENT:
-                            continue
-                        updates.extend(i._update_as_tuples())
-                    else:
-                        updates.extend(_get_updates(i) or ())
-                return updates
+                    return SKIP_WRITE
+                return _get_state_key(input.update, key=key)
             elif get_type_hints(type(input)):
-                return [
-                    (k, getattr(input, k))
-                    for k in output_keys
-                    if getattr(input, k, None) is not None
-                ]
+                value = getattr(input, key, SKIP_WRITE)
+                return value if value is not None else SKIP_WRITE
             else:
                 msg = create_error_message(
                     message=f"Expected dict, got {input}",
@@ -674,11 +661,14 @@ class CompiledStateGraph(CompiledGraph):
                 raise InvalidUpdateError(msg)
 
         # state updaters
-        write_entries: list[Union[ChannelWriteEntry, ChannelWriteTupleEntry]] = [
-            ChannelWriteTupleEntry(
-                mapper=_get_root if output_keys == ["__root__"] else _get_updates
-            )
-        ]
+        write_entries = (
+            [ChannelWriteEntry("__root__", skip_none=True, mapper=_get_root)]
+            if output_keys == ["__root__"]
+            else [
+                ChannelWriteEntry(key, mapper=partial(_get_state_key, key=key))
+                for key in output_keys
+            ]
+        )
 
         # add node and output channel
         if key == START:
@@ -713,7 +703,7 @@ class CompiledStateGraph(CompiledGraph):
                 writers=[
                     # publish to this channel and state keys
                     ChannelWrite(
-                        write_entries + [ChannelWriteEntry(key, key)],
+                        [ChannelWriteEntry(key, key)] + write_entries,
                         tags=[TAG_HIDDEN],
                     ),
                 ],
@@ -839,54 +829,38 @@ 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]
-    commands: list[Command] = []
-    if isinstance(value, Command):
-        commands.append(value)
-    elif (
-        isinstance(value, (list, tuple))
-        and value
-        and all(isinstance(i, Command) for i in value)
-    ):
-        commands.extend(value)
-    else:
+    if not isinstance(value, GraphCommand):
         return EMPTY_SEQ
+    if value.graph == Command.PARENT:
+        raise ParentCommand(value)
     rtn: list[Union[str, Send]] = []
-    for command in commands:
-        if command.graph == Command.PARENT:
-            raise ParentCommand(command)
-        if isinstance(command.goto, Send):
-            rtn.append(command.goto)
-        elif isinstance(command.goto, str):
-            rtn.append(command.goto)
-        else:
-            rtn.extend(command.goto)
+    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]
-    commands: list[Command] = []
-    if isinstance(value, Command):
-        commands.append(value)
-    elif (
-        isinstance(value, (list, tuple))
-        and value
-        and all(isinstance(i, Command) for i in value)
-    ):
-        commands.extend(value)
-    else:
+    if not isinstance(value, GraphCommand):
         return EMPTY_SEQ
+    if value.graph == Command.PARENT:
+        raise ParentCommand(value)
     rtn: list[Union[str, Send]] = []
-    for command in commands:
-        if command.graph == Command.PARENT:
-            raise ParentCommand(command)
-        if isinstance(command.goto, Send):
-            rtn.append(command.goto)
-        elif isinstance(command.goto, str):
-            rtn.append(command.goto)
-        else:
-            rtn.extend(command.goto)
+    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
 
 
@@ -959,12 +933,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

@@ -1,10 +1,15 @@
+from __future__ import annotations
+
 import asyncio
 import inspect
 import json
-from copy import copy, deepcopy
+from copy import copy
 from typing import (
+    TYPE_CHECKING,
     Any,
     Callable,
+    Dict,
+    List,
     Literal,
     Optional,
     Sequence,
@@ -20,7 +25,6 @@ from langchain_core.messages import (
     AnyMessage,
     ToolCall,
     ToolMessage,
-    convert_to_messages,
 )
 from langchain_core.runnables import RunnableConfig
 from langchain_core.runnables.config import (
@@ -31,25 +35,26 @@ from langchain_core.runnables.utils import Input
 from langchain_core.tools import BaseTool, InjectedToolArg
 from langchain_core.tools import tool as create_tool
 from langchain_core.tools.base import get_all_basemodel_annotations
-from pydantic import BaseModel
 from typing_extensions import Annotated, get_args, get_origin
 
 from langgraph.errors import GraphBubbleUp
 from langgraph.store.base import BaseStore
-from langgraph.types import Command
 from langgraph.utils.runnable import RunnableCallable
 
+if TYPE_CHECKING:
+    from pydantic import BaseModel
+
 INVALID_TOOL_NAME_ERROR_TEMPLATE = (
     "Error: {requested_tool} is not a valid tool, try one of [{available_tools}]."
 )
 TOOL_CALL_ERROR_TEMPLATE = "Error: {error}\n Please fix your mistakes."
 
 
-def msg_content_output(output: Any) -> Union[str, list[dict]]:
+def msg_content_output(output: Any) -> str | List[dict]:
     recognized_content_block_types = ("image", "image_url", "text", "json")
     if isinstance(output, str):
         return output
-    elif isinstance(output, list) and all(
+    elif all(
         [
             isinstance(x, dict) and x.get("type") in recognized_content_block_types
             for x in output
@@ -90,7 +95,7 @@ def _handle_tool_error(
     return content
 
 
-def _infer_handled_types(handler: Callable[..., str]) -> tuple[type[Exception], ...]:
+def _infer_handled_types(handler: Callable[..., str]) -> tuple[type[Exception]]:
     sig = inspect.signature(handler)
     params = list(sig.parameters.values())
     if params:
@@ -189,9 +194,9 @@ class ToolNode(RunnableCallable):
         messages_key: str = "messages",
     ) -> None:
         super().__init__(self._func, self._afunc, name=name, tags=tags, trace=False)
-        self.tools_by_name: dict[str, BaseTool] = {}
-        self.tool_to_state_args: dict[str, dict[str, Optional[str]]] = {}
-        self.tool_to_store_arg: dict[str, Optional[str]] = {}
+        self.tools_by_name: Dict[str, BaseTool] = {}
+        self.tool_to_state_args: Dict[str, Dict[str, Optional[str]]] = {}
+        self.tool_to_store_arg: Dict[str, Optional[str]] = {}
         self.handle_tool_errors = handle_tool_errors
         self.messages_key = messages_key
         for tool_ in tools:
@@ -212,31 +217,12 @@ class ToolNode(RunnableCallable):
         *,
         store: BaseStore,
     ) -> Any:
-        tool_calls, input_type = self._parse_input(input, store)
+        tool_calls, output_type = self._parse_input(input, store)
         config_list = get_config_list(config, len(tool_calls))
-        input_types = [input_type] * len(tool_calls)
         with get_executor_for_config(config) as executor:
-            outputs = [
-                *executor.map(self._run_one, tool_calls, input_types, config_list)
-            ]
-
-        # preserve existing behavior for non-command tool outputs for backwards compatibility
-        if not any(isinstance(output, Command) for output in outputs):
-            # TypedDict, pydantic, dataclass, etc. should all be able to load from dict
-            return outputs if input_type == "list" else {self.messages_key: outputs}
-
-        # LangGraph will automatically handle list of Command and non-command node updates
-        combined_outputs: list[
-            Command | list[ToolMessage] | dict[str, list[ToolMessage]]
-        ] = []
-        for output in outputs:
-            if isinstance(output, Command):
-                combined_outputs.append(output)
-            else:
-                combined_outputs.append(
-                    [output] if input_type == "list" else {self.messages_key: [output]}
-                )
-        return combined_outputs
+            outputs = [*executor.map(self._run_one, tool_calls, config_list)]
+        # TypedDict, pydantic, dataclass, etc. should all be able to load from dict
+        return outputs if output_type == "list" else {self.messages_key: outputs}
 
     def invoke(
         self, input: Input, config: Optional[RunnableConfig] = None, **kwargs: Any
@@ -263,97 +249,67 @@ class ToolNode(RunnableCallable):
         *,
         store: BaseStore,
     ) -> Any:
-        tool_calls, input_type = self._parse_input(input, store)
+        tool_calls, output_type = self._parse_input(input, store)
         outputs = await asyncio.gather(
-            *(self._arun_one(call, input_type, config) for call in tool_calls)
+            *(self._arun_one(call, config) for call in tool_calls)
+        )
+        # TypedDict, pydantic, dataclass, etc. should all be able to load from dict
+        return outputs if output_type == "list" else {self.messages_key: outputs}
+
+    def _run_one(self, call: ToolCall, config: RunnableConfig) -> ToolMessage:
+        if invalid_tool_message := self._validate_tool_call(call):
+            return invalid_tool_message
+
+        try:
+            input = {**call, **{"type": "tool_call"}}
+            tool_message: ToolMessage = self.tools_by_name[call["name"]].invoke(
+                input, config
+            )
+            tool_message.content = cast(
+                Union[str, list], msg_content_output(tool_message.content)
+            )
+            return tool_message
+        # GraphInterrupt is a special exception that will always be raised.
+        # It can be triggered in the following scenarios:
+        # (1) a NodeInterrupt is raised inside a tool
+        # (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:
+            raise e
+        except Exception as e:
+            if isinstance(self.handle_tool_errors, tuple):
+                handled_types: tuple = self.handle_tool_errors
+            elif callable(self.handle_tool_errors):
+                handled_types = _infer_handled_types(self.handle_tool_errors)
+            else:
+                # default behavior is catching all exceptions
+                handled_types = (Exception,)
+
+            # Unhandled
+            if not self.handle_tool_errors or not isinstance(e, handled_types):
+                raise e
+            # Handled
+            else:
+                content = _handle_tool_error(e, flag=self.handle_tool_errors)
+
+        return ToolMessage(
+            content=content, name=call["name"], tool_call_id=call["id"], status="error"
         )
 
-        # preserve existing behavior for non-command tool outputs for backwards compatibility
-        if not any(isinstance(output, Command) for output in outputs):
-            # TypedDict, pydantic, dataclass, etc. should all be able to load from dict
-            return outputs if input_type == "list" else {self.messages_key: outputs}
-
-        # LangGraph will automatically handle list of Command and non-command node updates
-        combined_outputs: list[
-            Command | list[ToolMessage] | dict[str, list[ToolMessage]]
-        ] = []
-        for output in outputs:
-            if isinstance(output, Command):
-                combined_outputs.append(output)
-            else:
-                combined_outputs.append(
-                    [output] if input_type == "list" else {self.messages_key: [output]}
-                )
-        return combined_outputs
-
-    def _run_one(
-        self,
-        call: ToolCall,
-        input_type: Literal["list", "dict"],
-        config: RunnableConfig,
-    ) -> ToolMessage:
+    async def _arun_one(self, call: ToolCall, config: RunnableConfig) -> ToolMessage:
         if invalid_tool_message := self._validate_tool_call(call):
             return invalid_tool_message
 
         try:
             input = {**call, **{"type": "tool_call"}}
-            response = self.tools_by_name[call["name"]].invoke(input)
-
-        # GraphInterrupt is a special exception that will always be raised.
-        # It can be triggered in the following scenarios:
-        # (1) a NodeInterrupt is raised inside a tool
-        # (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:
-            raise e
-        except Exception as e:
-            if isinstance(self.handle_tool_errors, tuple):
-                handled_types: tuple = self.handle_tool_errors
-            elif callable(self.handle_tool_errors):
-                handled_types = _infer_handled_types(self.handle_tool_errors)
-            else:
-                # default behavior is catching all exceptions
-                handled_types = (Exception,)
-
-            # Unhandled
-            if not self.handle_tool_errors or not isinstance(e, handled_types):
-                raise e
-            # Handled
-            else:
-                content = _handle_tool_error(e, flag=self.handle_tool_errors)
-            return ToolMessage(
-                content=content,
-                name=call["name"],
-                tool_call_id=call["id"],
-                status="error",
+            tool_message: ToolMessage = await self.tools_by_name[call["name"]].ainvoke(
+                input, config
             )
-
-        if isinstance(response, Command):
-            return self._validate_tool_command(response, call, input_type)
-        elif isinstance(response, ToolMessage):
-            response.content = cast(
-                Union[str, list], msg_content_output(response.content)
+            tool_message.content = cast(
+                Union[str, list], msg_content_output(tool_message.content)
             )
-            return response
-        else:
-            raise TypeError(
-                f"Tool {call['name']} returned unexpected type: {type(response)}"
-            )
-
-    async def _arun_one(
-        self,
-        call: ToolCall,
-        input_type: Literal["list", "dict"],
-        config: RunnableConfig,
-    ) -> ToolMessage:
-        if invalid_tool_message := self._validate_tool_call(call):
-            return invalid_tool_message
-
-        try:
-            input = {**call, **{"type": "tool_call"}}
-            response = await self.tools_by_name[call["name"]].ainvoke(input)
-
+            return tool_message
         # GraphInterrupt is a special exception that will always be raised.
         # It can be triggered in the following scenarios:
         # (1) a NodeInterrupt is raised inside a tool
@@ -378,24 +334,9 @@ class ToolNode(RunnableCallable):
             else:
                 content = _handle_tool_error(e, flag=self.handle_tool_errors)
 
-            return ToolMessage(
-                content=content,
-                name=call["name"],
-                tool_call_id=call["id"],
-                status="error",
-            )
-
-        if isinstance(response, Command):
-            return self._validate_tool_command(response, call, input_type)
-        elif isinstance(response, ToolMessage):
-            response.content = cast(
-                Union[str, list], msg_content_output(response.content)
-            )
-            return response
-        else:
-            raise TypeError(
-                f"Tool {call['name']} returned unexpected type: {type(response)}"
-            )
+        return ToolMessage(
+            content=content, name=call["name"], tool_call_id=call["id"], status="error"
+        )
 
     def _parse_input(
         self,
@@ -405,16 +346,16 @@ class ToolNode(RunnableCallable):
             BaseModel,
         ],
         store: BaseStore,
-    ) -> Tuple[list[ToolCall], Literal["list", "dict"]]:
+    ) -> Tuple[List[ToolCall], Literal["list", "dict"]]:
         if isinstance(input, list):
-            input_type = "list"
+            output_type = "list"
             message: AnyMessage = input[-1]
         elif isinstance(input, dict) and (messages := input.get(self.messages_key, [])):
-            input_type = "dict"
+            output_type = "dict"
             message = messages[-1]
         elif messages := getattr(input, self.messages_key, None):
             # Assume dataclass-like state that can coerce from dict
-            input_type = "dict"
+            output_type = "dict"
             message = messages[-1]
         else:
             raise ValueError("No message found in input")
@@ -425,7 +366,7 @@ class ToolNode(RunnableCallable):
         tool_calls = [
             self._inject_tool_args(call, input, store) for call in message.tool_calls
         ]
-        return tool_calls, input_type
+        return tool_calls, output_type
 
     def _validate_tool_call(self, call: ToolCall) -> Optional[ToolMessage]:
         if (requested_tool := call["name"]) not in self.tools_by_name:
@@ -519,67 +460,6 @@ class ToolNode(RunnableCallable):
         tool_call_with_store = self._inject_store(tool_call_with_state, store)
         return tool_call_with_store
 
-    def _validate_tool_command(
-        self, command: Command, call: ToolCall, input_type: Literal["list", "dict"]
-    ) -> Command:
-        if isinstance(command.update, dict):
-            # input type is dict when ToolNode is invoked with a dict input (e.g. {"messages": [AIMessage(..., tool_calls=[...])]})
-            if input_type != "dict":
-                raise ValueError(
-                    f"Tools can provide a dict in Command.update only when using dict with '{self.messages_key}' key as ToolNode input, "
-                    f"got: {command.update} for tool '{call['name']}'"
-                )
-
-            updated_command = deepcopy(command)
-            state_update = cast(dict[str, Any], updated_command.update) or {}
-            messages_update = state_update.get(self.messages_key, [])
-        elif isinstance(command.update, list):
-            # input type is list when ToolNode is invoked with a list input (e.g. [AIMessage(..., tool_calls=[...])])
-            if input_type != "list":
-                raise ValueError(
-                    f"Tools can provide a list of messages in Command.update only when using list of messages as ToolNode input, "
-                    f"got: {command.update} for tool '{call['name']}'"
-                )
-
-            updated_command = deepcopy(command)
-            messages_update = updated_command.update
-        else:
-            return command
-
-        # convert to message objects if updates are in a dict format
-        messages_update = convert_to_messages(messages_update)
-        have_seen_tool_messages = False
-        for message in messages_update:
-            if not isinstance(message, ToolMessage):
-                continue
-
-            if have_seen_tool_messages:
-                raise ValueError(
-                    f"Expected at most one ToolMessage in Command.update for tool '{call['name']}', got multiple: {messages_update}."
-                )
-
-            if message.tool_call_id != call["id"]:
-                raise ValueError(
-                    f"ToolMessage.tool_call_id must match the tool call id. Expected: {call['id']}, got: {message.tool_call_id} for tool '{call['name']}'."
-                )
-
-            message.name = call["name"]
-            have_seen_tool_messages = True
-
-        # validate that we always have exactly one ToolMessage in Command.update if command is sent to the CURRENT graph
-        if updated_command.graph is None and not have_seen_tool_messages:
-            example_update = (
-                '`Command(update={"messages": [ToolMessage("Success", tool_call_id=tool_call_id), ...]}, ...)`'
-                if input_type == "dict"
-                else '`Command(update=[ToolMessage("Success", tool_call_id=tool_call_id), ...], ...)`'
-            )
-            raise ValueError(
-                f"Expected exactly one message (ToolMessage) in Command.update for tool '{call['name']}', got: {messages_update}. "
-                "Every tool call (LLM requesting to call a tool) in the message history MUST have a corresponding ToolMessage. "
-                f"You can fix it by modifying the tool to return {example_update}."
-            )
-        return updated_command
-
 
 def tools_condition(
     state: Union[list[AnyMessage], dict[str, Any], BaseModel],
@@ -776,9 +656,9 @@ def _is_injection(
     return False
 
 
-def _get_state_args(tool: BaseTool) -> dict[str, Optional[str]]:
+def _get_state_args(tool: BaseTool) -> Dict[str, Optional[str]]:
     full_schema = tool.get_input_schema()
-    tool_args_to_state_fields: dict = {}
+    tool_args_to_state_fields: Dict = {}
 
     for name, type_ in get_all_basemodel_annotations(full_schema).items():
         injections = [

libs/langgraph/langgraph/pregel/__init__.py

@@ -18,6 +18,7 @@ from typing import (
     Type,
     Union,
     cast,
+    get_type_hints,
     overload,
 )
 from uuid import UUID, uuid5
@@ -116,7 +117,6 @@ from langgraph.utils.config import (
     patch_config,
     patch_configurable,
 )
-from langgraph.utils.fields import get_enhanced_type_hints
 from langgraph.utils.pydantic import create_model
 from langgraph.utils.queue import AsyncQueue, SyncQueue  # type: ignore[attr-defined]
 
@@ -319,15 +319,8 @@ class Pregel(PregelProtocol):
                 )
                 + (
                     [
-                        ConfigurableFieldSpec(
-                            id=name,
-                            annotation=typ,
-                            default=default,
-                            description=description,
-                        )
-                        for name, typ, default, description in get_enhanced_type_hints(
-                            self.config_type
-                        )
+                        ConfigurableFieldSpec(id=name, annotation=typ)
+                        for name, typ in get_type_hints(self.config_type).items()
                     ]
                     if self.config_type is not None
                     else []
@@ -680,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:
@@ -717,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:
@@ -758,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:
@@ -808,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:
@@ -864,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:
@@ -1139,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,14 +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,
-    ERROR,
     INTERRUPT,
+    MISSING,
     NO_WRITES,
     NS_END,
     NS_SEP,
@@ -53,30 +51,21 @@ from langgraph.constants import (
     PUSH,
     RESERVED,
     RESUME,
-    RETURN,
     TAG_HIDDEN,
     TASKS,
     Send,
 )
 from langgraph.errors import EmptyChannelError, InvalidUpdateError
 from langgraph.managed.base import ManagedValueMapping
-from langgraph.pregel.call import get_runnable_for_func
 from langgraph.pregel.io import read_channel, read_channels
 from langgraph.pregel.log import logger
 from langgraph.pregel.manager import ChannelsManager
 from langgraph.pregel.read import PregelNode
 from langgraph.store.base import BaseStore
-from langgraph.types import (
-    All,
-    LoopProtocol,
-    PregelExecutableTask,
-    PregelTask,
-    RetryPolicy,
-)
+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):
@@ -106,21 +95,6 @@ class PregelTaskWrites(NamedTuple):
     triggers: Sequence[str]
 
 
-class Call:
-    __slots__ = ("func", "input", "retry")
-
-    func: Callable
-    input: Any
-    retry: Optional[RetryPolicy]
-
-    def __init__(
-        self, func: Callable, input: Any, *, retry: Optional[RetryPolicy]
-    ) -> None:
-        self.func = func
-        self.input = input
-        self.retry = retry
-
-
 def should_interrupt(
     checkpoint: Checkpoint,
     interrupt_nodes: Union[All, Sequence[str]],
@@ -203,7 +177,7 @@ def local_write(
     """Function injected under CONFIG_KEY_SEND in task config, to write to channels.
     Validates writes and forwards them to `commit` function."""
     for chan, value in writes:
-        if chan in (PUSH, TASKS) and value is not None:
+        if chan in (PUSH, TASKS):
             if not isinstance(value, Send):
                 raise InvalidUpdateError(f"Expected Send, got {value}")
             if value.node not in process_keys:
@@ -271,7 +245,7 @@ def apply_writes(
     pending_writes_by_managed: dict[str, list[Any]] = defaultdict(list)
     for task in tasks:
         for chan, val in task.writes:
-            if chan in (NO_WRITES, PUSH, RESUME, INTERRUPT, RETURN, ERROR):
+            if chan in (NO_WRITES, PUSH, RESUME, INTERRUPT):
                 pass
             elif chan == TASKS:  # TODO: remove branch in 1.0
                 checkpoint["pending_sends"].append(val)
@@ -462,7 +436,7 @@ def prepare_next_tasks(
 
 
 def prepare_single_task(
-    task_path: tuple[Any, ...],
+    task_path: tuple[Union[str, int, tuple], ...],
     task_id_checksum: Optional[str],
     *,
     checkpoint: Checkpoint,
@@ -483,94 +457,7 @@ def prepare_single_task(
     configurable = config.get(CONF, {})
     parent_ns = configurable.get(CONFIG_KEY_CHECKPOINT_NS, "")
 
-    if task_path[0] == PUSH and isinstance(task_path[-1], Call):
-        # (PUSH, parent task path, idx of PUSH write, id of parent task, Call)
-        task_path_t = cast(tuple[str, tuple, int, str, Call], task_path)
-        call = task_path_t[-1]
-        proc_ = get_runnable_for_func(call.func)
-        name = proc_.name
-        if name is None:
-            raise ValueError("`call` functions must have a `__name__` attribute")
-        # create task id
-        triggers = [PUSH]
-        checkpoint_ns = f"{parent_ns}{NS_SEP}{name}" if parent_ns else name
-        task_id = _uuid5_str(
-            checkpoint_id,
-            checkpoint_ns,
-            str(step),
-            name,
-            PUSH,
-            _tuple_str(task_path[1]),
-            str(task_path[2]),
-        )
-        task_checkpoint_ns = f"{checkpoint_ns}:{task_id}"
-        metadata = {
-            "langgraph_step": step,
-            "langgraph_node": name,
-            "langgraph_triggers": triggers,
-            "langgraph_path": task_path[:3],
-            "langgraph_checkpoint_ns": task_checkpoint_ns,
-        }
-        if task_id_checksum is not None:
-            assert task_id == task_id_checksum, f"{task_id} != {task_id_checksum}"
-        if for_execution:
-            writes: deque[tuple[str, Any]] = deque()
-            return PregelExecutableTask(
-                name,
-                call.input,
-                proc_,
-                writes,
-                patch_config(
-                    merge_configs(config, {"metadata": metadata}),
-                    run_name=name,
-                    callbacks=(
-                        manager.get_child(f"graph:step:{step}") if manager else None
-                    ),
-                    configurable={
-                        CONFIG_KEY_TASK_ID: task_id,
-                        # deque.extend is thread-safe
-                        CONFIG_KEY_SEND: partial(
-                            local_write,
-                            writes.extend,
-                            processes.keys(),
-                        ),
-                        CONFIG_KEY_READ: partial(
-                            local_read,
-                            step,
-                            checkpoint,
-                            channels,
-                            managed,
-                            PregelTaskWrites(task_path[:3], name, writes, triggers),
-                            config,
-                        ),
-                        CONFIG_KEY_STORE: (store or configurable.get(CONFIG_KEY_STORE)),
-                        CONFIG_KEY_CHECKPOINTER: (
-                            checkpointer or configurable.get(CONFIG_KEY_CHECKPOINTER)
-                        ),
-                        CONFIG_KEY_CHECKPOINT_MAP: {
-                            **configurable.get(CONFIG_KEY_CHECKPOINT_MAP, {}),
-                            parent_ns: checkpoint["id"],
-                        },
-                        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: {},
-                    },
-                ),
-                triggers,
-                call.retry,
-                None,
-                task_id,
-                task_path[:3],
-            )
-        else:
-            return PregelTask(task_id, name, task_path[:3])
-    elif task_path[0] == PUSH:
+    if task_path[0] == PUSH:
         if len(task_path) == 2:  # TODO: remove branch in 1.0
             # legacy SEND tasks, executed in superstep n+1
             # (PUSH, idx of pending send)
@@ -601,19 +488,17 @@ def prepare_single_task(
                 PUSH,
                 str(idx),
             )
-        elif len(task_path) >= 4:
+        elif len(task_path) == 4:
             # new PUSH tasks, executed in superstep n
             # (PUSH, parent task path, idx of PUSH write, id of parent task)
-            task_path_tt = cast(tuple[str, tuple, int, str], task_path)
-            writes_for_path = [w for w in pending_writes if w[0] == task_path_tt[3]]
-            if task_path_tt[2] >= len(writes_for_path):
+            task_path_t = cast(tuple[str, tuple, int, str], task_path)
+            writes_for_path = [w for w in pending_writes if w[0] == task_path_t[3]]
+            if task_path_t[2] >= len(writes_for_path):
                 logger.warning(
                     f"Ignoring invalid write index {task_path[2]} in pending writes"
                 )
                 return
-            packet = writes_for_path[task_path_tt[2]][2]
-            if packet is None:
-                return
+            packet = writes_for_path[task_path_t[2]][2]
             if not isinstance(packet, Send):
                 logger.warning(
                     f"Ignoring invalid packet type {type(packet)} in pending writes"
@@ -646,7 +531,7 @@ def prepare_single_task(
             "langgraph_step": step,
             "langgraph_node": packet.node,
             "langgraph_triggers": triggers,
-            "langgraph_path": task_path[:3],
+            "langgraph_path": task_path,
             "langgraph_checkpoint_ns": task_checkpoint_ns,
         }
         if task_id_checksum is not None:
@@ -656,7 +541,7 @@ def prepare_single_task(
             if node := proc.node:
                 if proc.metadata:
                     metadata.update(proc.metadata)
-                writes = deque()
+                writes: deque[tuple[str, Any]] = deque()
                 return PregelExecutableTask(
                     packet.node,
                     packet.arg,
@@ -685,7 +570,7 @@ def prepare_single_task(
                                 channels,
                                 managed,
                                 PregelTaskWrites(
-                                    task_path[:3], packet.node, writes, triggers
+                                    task_path, packet.node, writes, triggers
                                 ),
                                 config,
                             ),
@@ -702,24 +587,26 @@ 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,
                     proc.retry_policy,
                     None,
                     task_id,
-                    task_path[:3],
+                    task_path,
                     writers=proc.flat_writers,
                 )
+
         else:
-            return PregelTask(task_id, packet.node, task_path[:3])
+            return PregelTask(task_id, packet.node, task_path)
     elif task_path[0] == PULL:
         # (PULL, node name)
         name = cast(str, task_path[1])
@@ -747,12 +634,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
@@ -769,7 +650,7 @@ def prepare_single_task(
                 "langgraph_step": step,
                 "langgraph_node": name,
                 "langgraph_triggers": triggers,
-                "langgraph_path": task_path[:3],
+                "langgraph_path": task_path,
                 "langgraph_checkpoint_ns": task_checkpoint_ns,
             }
             if task_id_checksum is not None:
@@ -808,9 +689,7 @@ def prepare_single_task(
                                     checkpoint,
                                     channels,
                                     managed,
-                                    PregelTaskWrites(
-                                        task_path[:3], name, writes, triggers
-                                    ),
+                                    PregelTaskWrites(task_path, name, writes, triggers),
                                     config,
                                 ),
                                 CONFIG_KEY_STORE: (
@@ -826,24 +705,26 @@ 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,
                         proc.retry_policy,
                         None,
                         task_id,
-                        task_path[:3],
+                        task_path,
                         writers=proc.flat_writers,
                     )
             else:
-                return PregelTask(task_id, name, task_path[:3])
+                return PregelTask(task_id, name, task_path)
 
 
 def _proc_input(

libs/langgraph/langgraph/pregel/call.py

@@ -1,123 +0,0 @@
-import sys
-import types
-from typing import Any, Callable, Optional
-
-from langgraph.constants import RETURN
-from langgraph.pregel.write import ChannelWrite, ChannelWriteEntry
-from langgraph.utils.runnable import RunnableSeq, coerce_to_runnable
-
-"""
-Utilities borrowed from cloudpickle.
-https://github.com/cloudpipe/cloudpickle/blob/6220b0ce83ffee5e47e06770a1ee38ca9e47c850/cloudpickle/cloudpickle.py#L265
-"""
-
-
-def _getattribute(obj: Any, name: str) -> Any:
-    for subpath in name.split("."):
-        if subpath == "<locals>":
-            raise AttributeError(
-                "Can't get local attribute {!r} on {!r}".format(name, obj)
-            )
-        try:
-            parent = obj
-            obj = getattr(obj, subpath)
-        except AttributeError:
-            raise AttributeError(
-                "Can't get attribute {!r} on {!r}".format(name, obj)
-            ) from None
-    return obj, parent
-
-
-def _whichmodule(obj: Any, name: str) -> Optional[str]:
-    """Find the module an object belongs to.
-
-    This function differs from ``pickle.whichmodule`` in two ways:
-    - it does not mangle the cases where obj's module is __main__ and obj was
-      not found in any module.
-    - Errors arising during module introspection are ignored, as those errors
-      are considered unwanted side effects.
-    """
-    module_name = getattr(obj, "__module__", None)
-
-    if module_name is not None:
-        return module_name
-    # Protect the iteration by using a copy of sys.modules against dynamic
-    # modules that trigger imports of other modules upon calls to getattr or
-    # other threads importing at the same time.
-    for module_name, module in sys.modules.copy().items():
-        # Some modules such as coverage can inject non-module objects inside
-        # sys.modules
-        if (
-            module_name == "__main__"
-            or module_name == "__mp_main__"
-            or module is None
-            or not isinstance(module, types.ModuleType)
-        ):
-            continue
-        try:
-            if _getattribute(module, name)[0] is obj:
-                return module_name
-        except Exception:
-            pass
-    return None
-
-
-def _lookup_module_and_qualname(
-    obj: Any, name: Optional[str] = None
-) -> Optional[tuple[types.ModuleType, str]]:
-    if name is None:
-        name = getattr(obj, "__qualname__", None)
-    if name is None:  # pragma: no cover
-        # This used to be needed for Python 2.7 support but is probably not
-        # needed anymore. However we keep the __name__ introspection in case
-        # users of cloudpickle rely on this old behavior for unknown reasons.
-        name = getattr(obj, "__name__", None)
-    if name is None:
-        return None
-
-    module_name = _whichmodule(obj, name)
-
-    if module_name is None:
-        # In this case, obj.__module__ is None AND obj was not found in any
-        # imported module. obj is thus treated as dynamic.
-        return None
-
-    if module_name == "__main__":
-        return None
-
-    # Note: if module_name is in sys.modules, the corresponding module is
-    # assumed importable at unpickling time. See #357
-    module = sys.modules.get(module_name, None)
-    if module is None:
-        # The main reason why obj's module would not be imported is that this
-        # module has been dynamically created, using for example
-        # types.ModuleType. The other possibility is that module was removed
-        # from sys.modules after obj was created/imported. But this case is not
-        # supported, as the standard pickle does not support it either.
-        return None
-
-    try:
-        obj2, parent = _getattribute(module, name)
-    except AttributeError:
-        # obj was not found inside the module it points to
-        return None
-    if obj2 is not obj:
-        return None
-    return module, name
-
-
-def get_runnable_for_func(func: Callable[..., Any]) -> RunnableSeq:
-    if func in CACHE:
-        return CACHE[func]
-    else:
-        seq = RunnableSeq(
-            coerce_to_runnable(func, name=None, trace=False),
-            ChannelWrite([ChannelWriteEntry(RETURN)]),
-            name=func.__name__,
-        )
-        if not _lookup_module_and_qualname(func):
-            return seq
-        return CACHE.setdefault(func, seq)
-
-
-CACHE: dict[Callable[..., Any], RunnableSeq] = {}

libs/langgraph/langgraph/pregel/executor.py

@@ -1,7 +1,6 @@
 import asyncio
 import concurrent.futures
 import sys
-import time
 from contextlib import ExitStack
 from contextvars import copy_context
 from types import TracebackType
@@ -35,7 +34,6 @@ class Submit(Protocol[P, T]):
         __name__: Optional[str] = None,
         __cancel_on_exit__: bool = False,
         __reraise_on_exit__: bool = True,
-        __next_tick__: bool = False,
         **kwargs: P.kwargs,
     ) -> concurrent.futures.Future[T]: ...
 
@@ -60,13 +58,9 @@ class BackgroundExecutor(ContextManager):
         __name__: Optional[str] = None,  # currently not used in sync version
         __cancel_on_exit__: bool = False,  # for sync, can cancel only if not started
         __reraise_on_exit__: bool = True,
-        __next_tick__: bool = False,
         **kwargs: P.kwargs,
     ) -> concurrent.futures.Future[T]:
-        if __next_tick__:
-            task = self.executor.submit(next_tick, fn, *args, **kwargs)
-        else:
-            task = self.executor.submit(fn, *args, **kwargs)
+        task = self.executor.submit(fn, *args, **kwargs)
         self.tasks[task] = (__cancel_on_exit__, __reraise_on_exit__)
         task.add_done_callback(self.done)
         return task
@@ -143,14 +137,11 @@ class AsyncBackgroundExecutor(AsyncContextManager):
         __name__: Optional[str] = None,
         __cancel_on_exit__: bool = False,
         __reraise_on_exit__: bool = True,
-        __next_tick__: bool = False,
         **kwargs: P.kwargs,
     ) -> asyncio.Task[T]:
         coro = cast(Coroutine[None, None, T], fn(*args, **kwargs))
         if self.semaphore:
             coro = gated(self.semaphore, coro)
-        if __next_tick__:
-            coro = anext_tick(coro)
         if self.context_not_supported:
             task = self.loop.create_task(coro, name=__name__)
         else:
@@ -206,15 +197,3 @@ async def gated(semaphore: asyncio.Semaphore, coro: Coroutine[None, None, T]) ->
     """A coroutine that waits for a semaphore before running another coroutine."""
     async with semaphore:
         return await coro
-
-
-def next_tick(fn: Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
-    """A function that yields control to other threads before running another function."""
-    time.sleep(0)
-    return fn(*args, **kwargs)
-
-
-async def anext_tick(coro: Coroutine[None, None, T]) -> T:
-    """A coroutine that yields control to event loop before running another coroutine."""
-    await asyncio.sleep(0)
-    return await coro