consolidate installing deps

.github/actions/poetry_setup/action.yml

@@ -0,0 +1,88 @@
+# An action for setting up poetry install with caching.
+# Using a custom action since the default action does not
+# take poetry install groups into account.
+# Action code from:
+# https://github.com/actions/setup-python/issues/505#issuecomment-1273013236
+name: poetry-install-with-caching
+description: Poetry install with support for caching of dependency groups.
+
+inputs:
+  python-version:
+    description: Python version, supporting MAJOR.MINOR only
+    required: true
+
+  poetry-version:
+    description: Poetry version
+    required: true
+
+  cache-key:
+    description: Cache key to use for manual handling of caching
+    required: true
+
+runs:
+  using: composite
+  steps:
+    - uses: actions/setup-python@v5
+      name: Setup python ${{ inputs.python-version }}
+      id: setup-python
+      with:
+        python-version: ${{ inputs.python-version }}
+
+    - uses: actions/cache@v3
+      id: cache-bin-poetry
+      name: Cache Poetry binary - Python ${{ inputs.python-version }}
+      env:
+        SEGMENT_DOWNLOAD_TIMEOUT_MIN: "1"
+      with:
+        path: |
+          /opt/pipx/venvs/poetry
+        # This step caches the poetry installation, so make sure it's keyed on the poetry version as well.
+        key: bin-poetry-${{ runner.os }}-${{ runner.arch }}-py-${{ inputs.python-version }}-${{ inputs.poetry-version }}
+
+    - name: Refresh shell hashtable and fixup softlinks
+      if: steps.cache-bin-poetry.outputs.cache-hit == 'true'
+      shell: bash
+      env:
+        POETRY_VERSION: ${{ inputs.poetry-version }}
+        PYTHON_VERSION: ${{ inputs.python-version }}
+      run: |
+        set -eux
+
+        # Refresh the shell hashtable, to ensure correct `which` output.
+        hash -r
+
+        # `actions/cache@v3` doesn't always seem able to correctly unpack softlinks.
+        # Delete and recreate the softlinks pipx expects to have.
+        rm /opt/pipx/venvs/poetry/bin/python
+        cd /opt/pipx/venvs/poetry/bin
+        ln -s "$(which "python$PYTHON_VERSION")" python
+        chmod +x python
+        cd /opt/pipx_bin/
+        ln -s /opt/pipx/venvs/poetry/bin/poetry poetry
+        chmod +x poetry
+
+        # Ensure everything got set up correctly.
+        /opt/pipx/venvs/poetry/bin/python --version
+        /opt/pipx_bin/poetry --version
+
+    - name: Install poetry
+      if: steps.cache-bin-poetry.outputs.cache-hit != 'true'
+      shell: bash
+      env:
+        POETRY_VERSION: ${{ inputs.poetry-version }}
+        PYTHON_VERSION: ${{ inputs.python-version }}
+      # Install poetry using the python version installed by setup-python step.
+      run: pipx install "poetry==$POETRY_VERSION" --python '${{ steps.setup-python.outputs.python-path }}' --verbose
+
+    - name: Restore pip and poetry cached dependencies
+      uses: actions/cache@v3
+      env:
+        SEGMENT_DOWNLOAD_TIMEOUT_MIN: "4"
+      with:
+        path: |
+          ~/.cache/pip
+          ~/.cache/pypoetry/virtualenvs
+          ~/.cache/pypoetry/cache
+          ~/.cache/pypoetry/artifacts
+          ./.venv
+        key: py-deps-${{ runner.os }}-${{ runner.arch }}-py-${{ inputs.python-version }}-poetry-${{ inputs.poetry-version }}-${{ inputs.cache-key }}-${{ hashFiles('./poetry.lock') }}

.github/workflows/_integration_test.yml

@@ -3,6 +3,9 @@ name: CLI integration test
 on:
   workflow_call:
 
+env:
+  POETRY_VERSION: "2.1.2"
+
 jobs:
   build:
     runs-on: ubuntu-latest
@@ -22,14 +25,13 @@ jobs:
         uses: Ana06/get-changed-files@v2.3.0
         with:
           filter: "libs/cli/**"
-      - name: Set up Python ${{ matrix.python-version }}
+      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
         if: steps.changed-files.outputs.all
-        uses: astral-sh/setup-uv@v6
+        uses: "./.github/actions/poetry_setup"
         with:
           python-version: ${{ matrix.python-version }}
-          enable-cache: true
-          cache-suffix: "cli-integration-test"
-          ignore-nothing-to-cache: true
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: integration-test-cli
       - name: Setup env
         if: steps.changed-files.outputs.all
         working-directory: libs/cli/examples

.github/workflows/_lint.yml

@@ -9,6 +9,8 @@ on:
         description: "From which folder this pipeline executes"
 
 env:
+  POETRY_VERSION: "2.1.2"
+
   # This env var allows us to get inline annotations when ruff has complaints.
   RUFF_OUTPUT_FORMAT: github
 
@@ -34,18 +36,32 @@ jobs:
         uses: Ana06/get-changed-files@v2.3.0
         with:
           filter: "${{ inputs.working-directory }}/**"
-      - name: Set up Python ${{ matrix.python-version }}
+      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
         if: steps.changed-files.outputs.all
-        uses: astral-sh/setup-uv@v6
+        uses: "./.github/actions/poetry_setup"
         with:
           python-version: ${{ matrix.python-version }}
-          enable-cache: true
-          cache-suffix: lint-${{ inputs.working-directory }}
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: lint-${{ inputs.working-directory }}
+
+      - name: Check Poetry File
+        if: steps.changed-files.outputs.all
+        shell: bash
+        working-directory: ${{ inputs.working-directory }}
+        run: poetry check
 
       - name: Install dependencies
         if: steps.changed-files.outputs.all
+        # Also installs dev/lint/test/typing dependencies, to ensure we have
+        # type hints for as many of our libraries as possible.
+        # This helps catch errors that require dependencies to be spotted, for example:
+        # https://github.com/langchain-ai/langchain/pull/10249/files#diff-935185cd488d015f026dcd9e19616ff62863e8cde8c0bee70318d3ccbca98341
+        #
+        # If you change this configuration, make sure to change the `cache-key`
+        # in the `poetry_setup` action above to stop using the old cache.
+        # It doesn't matter how you change it, any change will cause a cache-bust.
         working-directory: ${{ inputs.working-directory }}
-        run: uv sync --frozen --group dev
+        run: poetry install --with dev
 
       - name: Get .mypy_cache to speed up mypy
         if: steps.changed-files.outputs.all
@@ -55,7 +71,7 @@ jobs:
         with:
           path: |
             ${{ inputs.working-directory }}/.mypy_cache
-          key: mypy-lint-${{ runner.os }}-${{ runner.arch }}-py${{ matrix.python-version }}-${{ inputs.working-directory }}-${{ hashFiles(format('{0}/uv.lock', inputs.working-directory)) }}
+          key: mypy-lint-${{ runner.os }}-${{ runner.arch }}-py${{ matrix.python-version }}-${{ inputs.working-directory }}-${{ hashFiles(format('{0}/poetry.lock', inputs.working-directory)) }}
 
       - name: Analysing package code with our lint
         if: steps.changed-files.outputs.all
@@ -70,8 +86,17 @@ jobs:
 
       - name: Install test dependencies
         if: steps.changed-files.outputs.all
+        # Also installs dev/lint/test/typing dependencies, to ensure we have
+        # type hints for as many of our libraries as possible.
+        # This helps catch errors that require dependencies to be spotted, for example:
+        # https://github.com/langchain-ai/langchain/pull/10249/files#diff-935185cd488d015f026dcd9e19616ff62863e8cde8c0bee70318d3ccbca98341
+        #
+        # If you change this configuration, make sure to change the `cache-key`
+        # in the `poetry_setup` action above to stop using the old cache.
+        # It doesn't matter how you change it, any change will cause a cache-bust.
         working-directory: ${{ inputs.working-directory }}
-        run: uv sync --group dev
+        run: |
+          poetry install --with dev
 
       - name: Get .mypy_cache_test to speed up mypy
         if: steps.changed-files.outputs.all
@@ -81,7 +106,7 @@ jobs:
         with:
           path: |
             ${{ inputs.working-directory }}/.mypy_cache_test
-          key: mypy-test-${{ runner.os }}-${{ runner.arch }}-py${{ matrix.python-version }}-${{ inputs.working-directory }}-${{ hashFiles(format('{0}/uv.lock', inputs.working-directory)) }}
+          key: mypy-test-${{ runner.os }}-${{ runner.arch }}-py${{ matrix.python-version }}-${{ inputs.working-directory }}-${{ hashFiles(format('{0}/poetry.lock', inputs.working-directory)) }}
 
       - name: Analysing tests with our lint
         if: steps.changed-files.outputs.all

.github/workflows/_test.yml

@@ -8,6 +8,9 @@ on:
         type: string
         description: "From which folder this pipeline executes"
 
+env:
+  POETRY_VERSION: "2.1.2"
+
 jobs:
   build:
     runs-on: ubuntu-latest
@@ -23,12 +26,12 @@ jobs:
     name: "test #${{ matrix.python-version }}"
     steps:
       - uses: actions/checkout@v4
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: astral-sh/setup-uv@v6
+      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
         with:
           python-version: ${{ matrix.python-version }}
-          enable-cache: true
-          cache-suffix: test-${{ inputs.working-directory }}
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: test-${{ inputs.working-directory }}
       - name: Login to Docker Hub
         uses: docker/login-action@v3
         if: ${{ !github.event.pull_request.head.repo.fork }}
@@ -39,12 +42,14 @@ jobs:
       - name: Install dependencies
         shell: bash
         working-directory: ${{ inputs.working-directory }}
-        run: uv sync --frozen --group dev
+        run: |
+          poetry install --with dev
 
       - name: Run tests
         shell: bash
         working-directory: ${{ inputs.working-directory }}
-        run: make test
+        run: |
+          make test
 
       - name: Ensure the tests did not create any additional files
         shell: bash

.github/workflows/_test_langgraph.yml

@@ -3,6 +3,9 @@ name: test
 on:
   workflow_call:
 
+env:
+  POETRY_VERSION: "2.1.2"
+
 jobs:
   build:
     runs-on: ubuntu-latest
@@ -21,12 +24,12 @@ jobs:
     name: "test #${{ matrix.python-version }}"
     steps:
       - uses: actions/checkout@v4
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: astral-sh/setup-uv@v6
+      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
         with:
           python-version: ${{ matrix.python-version }}
-          enable-cache: true
-          cache-suffix: "test-langgraph"
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: test-langgraph
       - name: Login to Docker Hub
         uses: docker/login-action@v3
         if: ${{ !github.event.pull_request.head.repo.fork }}
@@ -36,11 +39,13 @@ jobs:
 
       - name: Install dependencies
         shell: bash
-        run: uv sync --frozen --group dev
+        run: |
+          poetry install --with dev
 
       - name: Run tests
         shell: bash
-        run: make test_parallel
+        run: |
+          make test_parallel
 
       - name: Ensure the tests did not create any additional files
         shell: bash

.github/workflows/_test_release.yml

@@ -9,6 +9,7 @@ on:
         description: "From which folder this pipeline executes"
 
 env:
+  POETRY_VERSION: "2.1.2"
   PYTHON_VERSION: "3.10"
 
 jobs:
@@ -23,12 +24,12 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - name: Set up Python $${ env.PYTHON_VERSION }}
-        uses: astral-sh/setup-uv@v6
+      - name: Set up Python + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
         with:
           python-version: ${{ env.PYTHON_VERSION }}
-          enable-cache: true
-          cache-suffix: "release"
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: release
 
       # We want to keep this build stage *separate* from the release stage,
       # so that there's no sharing of permissions between them.
@@ -42,7 +43,7 @@ jobs:
       # > from the publish job.
       # https://github.com/pypa/gh-action-pypi-publish#non-goals
       - name: Build project for distribution
-        run: uv build
+        run: poetry build
         working-directory: ${{ inputs.working-directory }}
 
       - name: Upload build
@@ -56,8 +57,8 @@ jobs:
         shell: bash
         working-directory: ${{ inputs.working-directory }}
         run: |
-          echo pkg-name=$(grep -m 1 "^name = " pyproject.toml | cut -d '"' -f 2)
-          echo version=$(grep -m 1 "^version = " pyproject.toml | cut -d '"' -f 2)
+          echo pkg-name="$(poetry version | cut -d ' ' -f 1)" >> $GITHUB_OUTPUT
+          echo version="$(poetry version --short)" >> $GITHUB_OUTPUT
 
   publish:
     needs:

.github/workflows/_test_scheduler_kafka.yml

@@ -3,6 +3,9 @@ name: test
 on:
   workflow_call:
 
+env:
+  POETRY_VERSION: "2.1.2"
+
 jobs:
   build:
     runs-on: ubuntu-latest
@@ -18,12 +21,12 @@ jobs:
     name: "test #${{ matrix.python-version }}"
     steps:
       - uses: actions/checkout@v4
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: astral-sh/setup-uv@v6
+      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
         with:
           python-version: ${{ matrix.python-version }}
-          enable-cache: true
-          cache-suffix: "test-scheduler-kafka"
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: test-scheduler-kafka
       - name: Login to Docker Hub
         uses: docker/login-action@v3
         if: ${{ !github.event.pull_request.head.repo.fork }}
@@ -33,11 +36,13 @@ jobs:
 
       - name: Install dependencies
         shell: bash
-        run: uv sync --frozen --group dev
+        run: |
+          poetry install --with dev
 
       - name: Run tests
         shell: bash
-        run: make test
+        run: |
+          make test
 
       - name: Ensure the tests did not create any additional files
         shell: bash

.github/workflows/baseline.yml

@@ -7,6 +7,9 @@ on:
     paths:
       - "libs/**"
 
+env:
+  POETRY_VERSION: "2.1.2"
+
 jobs:
   benchmark:
     runs-on: ubuntu-latest
@@ -16,14 +19,14 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - run: SHA=$(git rev-parse HEAD) && echo "SHA=$SHA" >> $GITHUB_ENV
-      - name: Set up Python 3.11
-        uses: astral-sh/setup-uv@v6
+      - name: Set up Python 3.11 + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
         with:
           python-version: "3.11"
-          enable-cache: true
-          cache-suffix: "bench"
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: bench
       - name: Install dependencies
-        run: uv sync --group dev
+        run: poetry install --with dev
       - name: Run benchmarks
         run: OUTPUT=out/benchmark-baseline.json make -s benchmark
       - name: Save outputs

.github/workflows/bench.yml

@@ -5,6 +5,9 @@ on:
     paths:
       - "libs/**"
 
+env:
+  POETRY_VERSION: "2.1.2"
+
 jobs:
   benchmark:
     runs-on: ubuntu-latest
@@ -18,14 +21,14 @@ jobs:
         uses: Ana06/get-changed-files@v2.3.0
         with:
           format: json
-      - name: Set up Python 3.11
-        uses: astral-sh/setup-uv@v6
+      - name: Set up Python 3.11 + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
         with:
           python-version: "3.11"
-          enable-cache: true
-          cache-suffix: "bench"
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: bench
       - name: Install dependencies
-        run: uv sync --group dev
+        run: poetry install --with dev
       - name: Download baseline
         uses: actions/cache/restore@v4
         with:
@@ -50,7 +53,7 @@ jobs:
             echo 'OUTPUT<<EOF'
             mv out/benchmark-baseline.json out/main.json
             mv out/benchmark.json out/changes.json
-            uv run pyperf compare_to out/main.json out/changes.json --table --group-by-speed
+            poetry run pyperf compare_to out/main.json out/changes.json --table --group-by-speed
             echo EOF
           } >> "$GITHUB_OUTPUT"
       - name: Annotation

.github/workflows/ci.yml

@@ -16,6 +16,9 @@ concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
 
+env:
+  POETRY_VERSION: "2.1.2"
+
 jobs:
   changes:
     runs-on: ubuntu-latest
@@ -122,26 +125,26 @@ jobs:
           - "3.11"
     steps:
       - uses: actions/checkout@v4
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: astral-sh/setup-uv@v6
+      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
         with:
           python-version: "3.11"
-          enable-cache: true
-          cache-suffix: "schema-check-cli"
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: schema-check-cli
       - name: Install CLI dependencies
         run: |
           cd libs/cli
-          uv sync
+          poetry install
       - name: Generate schema and check for changes
         run: |
           cd libs/cli
           # Create a temporary copy of the current schema
           cp schemas/schema.json schemas/schema.current.json
           # Generate new schema
-          uv run python generate_schema.py
+          poetry run python generate_schema.py
           # Compare the new schema with the original
           if ! diff -q schemas/schema.json schemas/schema.current.json > /dev/null; then
-            echo "Error: Langgraph.json configuration schema has changed. Please run 'uv run python generate_schema.py' in the libs/cli directory and commit the changes."
+            echo "Error: Langgraph.json configuration schema has changed. Please run 'poetry run python generate_schema.py' in the libs/cli directory and commit the changes."
             diff schemas/schema.json schemas/schema.current.json
             exit 1
           fi

.github/workflows/deploy_docs.yml

@@ -9,6 +9,9 @@ on:
       - main
   workflow_dispatch:
 
+env:
+  POETRY_VERSION: "2.1.2"
+
 permissions:
   contents: read
   pages: write
@@ -54,21 +57,21 @@ jobs:
         with:
           fetch-depth: 0
 
-      - name: Set up Python
-        uses: astral-sh/setup-uv@v6
+      - name: Set up Python + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
         with:
           python-version: "3.12"
-          enable-cache: true
-          cache-suffix: "docs"
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: docs
 
       - name: Install dependencies
         run: |
           yarn
-          uv sync --all-groups
+          poetry install --with test --with docs --no-root
           # we run this installation only for internal PRs
           # as GITHUB_TOKEN is not available for PRs from outside contributors
           if [ -n "${GITHUB_TOKEN}" ]; then
-            uv run pip install "git+https://${GITHUB_TOKEN}@github.com/langchain-ai/mkdocs-material-insiders.git"
+            poetry run pip install "git+https://${GITHUB_TOKEN}@github.com/langchain-ai/mkdocs-material-insiders.git"
           fi
 
       - name: Run unit tests
@@ -100,7 +103,7 @@ jobs:
         run: |
           if [ "${{ github.event_name }}" == "schedule" ]; then
             echo "Running link check on all HTML files matching notebooks in docs directory..."
-            uv run pytest -v \
+            poetry run pytest -v \
               --check-links-ignore "https://(api|web|docs)\.smith\.langchain\.com/.*" \
               --check-links-ignore "https://academy\.langchain\.com/.*" \
               --check-links-ignore "https://x.com/.*" \
@@ -125,7 +128,7 @@ jobs:
             echo "Changed files: ${CHANGED_FILES}"
             if [ -n "${CHANGED_FILES}" ]; then
               echo "Running link check on HTML files matching changed notebook files..."
-              uv run pytest -v \
+              poetry run pytest -v \
                 --check-links-ignore "https://(api|web|docs)\.smith\.langchain\.com/.*" \
                 --check-links-ignore "https://academy\.langchain\.com/.*" \
                 --check-links-ignore "http://localhost:8123/.*" \

.github/workflows/link_check.yml

@@ -11,6 +11,9 @@ on:
     - cron: "0 5 * * *"
   workflow_dispatch:
 
+env:
+  POETRY_VERSION: "2.1.2"
+
 jobs:
   markdown-link-check:
     runs-on: ubuntu-latest

.github/workflows/release.yml

@@ -10,6 +10,7 @@ on:
 
 env:
   PYTHON_VERSION: "3.11"
+  POETRY_VERSION: "2.1.2"
 
 jobs:
   build:
@@ -25,12 +26,12 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - name: Set up Python
-        uses: astral-sh/setup-uv@v6
+      - name: Set up Python + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
         with:
           python-version: ${{ env.PYTHON_VERSION }}
-          enable-cache: true
-          cache-suffix: "release"
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: release
 
       # We want to keep this build stage *separate* from the release stage,
       # so that there's no sharing of permissions between them.
@@ -44,7 +45,7 @@ jobs:
       # > from the publish job.
       # https://github.com/pypa/gh-action-pypi-publish#non-goals
       - name: Build project for distribution
-        run: uv build
+        run: poetry build
         working-directory: ${{ inputs.working-directory }}
 
       - name: Upload build
@@ -58,8 +59,8 @@ jobs:
         shell: bash
         working-directory: ${{ inputs.working-directory }}
         run: |
-          PKG_NAME=$(grep -m 1 "^name = " pyproject.toml | cut -d '"' -f 2)
-          VERSION=$(grep -m 1 "^version = " pyproject.toml | cut -d '"' -f 2)
+          PKG_NAME="$(poetry version | cut -d ' ' -f 1)"
+          VERSION="$(poetry version --short)"
           SHORT_PKG_NAME="$(echo "$PKG_NAME" | sed -e 's/langgraph//g' -e 's/-//g')"
           if [ -z $SHORT_PKG_NAME ]; then
             TAG="$VERSION"
@@ -162,11 +163,11 @@ jobs:
       # - The package is published, and it breaks on the missing dependency when
       #   used in the real world.
 
-      - name: Set up Python
-        uses: astral-sh/setup-uv@v6
+      - name: Set up Python + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
         with:
           python-version: ${{ env.PYTHON_VERSION }}
-          enable-cache: true
+          poetry-version: ${{ env.POETRY_VERSION }}
 
       - name: Import published package
         shell: bash
@@ -184,18 +185,18 @@ jobs:
         # - attempt install again after 5 seconds if it fails because there is
         #   sometimes a delay in availability on test pypi
         run: |
-          uv run pip install \
+          poetry run pip install \
             --extra-index-url https://test.pypi.org/simple/ \
             "$PKG_NAME==$VERSION" || \
           ( \
             sleep 5 && \
-            uv run pip install \
+            poetry run pip install \
               --extra-index-url https://test.pypi.org/simple/ \
               "$PKG_NAME==$VERSION" \
           )
 
           if [[ "$PKG_NAME" == *prebuilt* ]]; then
-            uv run pip install langgraph
+            poetry run pip install langgraph
           fi
 
           if [[ "$PKG_NAME" == *checkpoint* || "$PKG_NAME" == *prebuilt* ]]; then
@@ -208,10 +209,10 @@ jobs:
             IMPORT_NAME="$(echo "$PKG_NAME" | sed s/-/_/g)"
           fi
 
-          uv run python -c "import $IMPORT_NAME; print(dir($IMPORT_NAME))"
+          poetry run python -c "import $IMPORT_NAME; print(dir($IMPORT_NAME))"
 
       - name: Import test dependencies
-        run: uv sync --group dev
+        run: poetry install --with dev
         working-directory: ${{ inputs.working-directory }}
 
       # Overwrite the local version of the package with the test PyPI version.
@@ -222,7 +223,7 @@ jobs:
           PKG_NAME: ${{ needs.build.outputs.pkg-name }}
           VERSION: ${{ needs.build.outputs.version }}
         run: |
-          uv run pip install \
+          poetry run pip install \
             --extra-index-url https://test.pypi.org/simple/ \
             "$PKG_NAME==$VERSION"
 
@@ -252,12 +253,12 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - name: Set up Python
-        uses: astral-sh/setup-uv@v6
+      - name: Set up Python + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
         with:
           python-version: ${{ env.PYTHON_VERSION }}
-          enable-cache: true
-          cache-suffix: "release"
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: release
 
       - uses: actions/download-artifact@v4
         with:
@@ -293,12 +294,12 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - name: Set up Python
-        uses: astral-sh/setup-uv@v6
+      - name: Set up Python + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
         with:
           python-version: ${{ env.PYTHON_VERSION }}
-          enable-cache: true
-          cache-suffix: "release"
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: release
 
       - uses: actions/download-artifact@v4
         with:

.github/workflows/run_notebooks.yml

@@ -27,30 +27,30 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - name: Set up Python + Poetry
-        uses: astral-sh/setup-uv@v6
+        uses: "./.github/actions/poetry_setup"
         with:
-          python-version: "3.11"
-          enable-cache: true
-          cache-suffix: "test-langgraph-notebooks"
+          python-version: 3.11
+          poetry-version: 2.1.2
+          cache-key: test-langgraph-notebooks
 
       - name: Install dependencies
         run: |
-          uv sync --group test
-          uv run pip install jupyter
+          poetry install --with test --no-root
+          poetry run pip install jupyter
 
       - name: Start services
         run: make start-services
 
       - name: Pre-download tiktoken files
         run: |
-          uv run python _scripts/download_tiktoken.py
+          poetry run python _scripts/download_tiktoken.py
 
       - name: Prepare notebooks
         run: |
           if [ "${{ matrix.lib-version }}" = "development" ]; then
-            uv run python _scripts/prepare_notebooks_for_ci.py --comment-install-cells
+            poetry run python _scripts/prepare_notebooks_for_ci.py --comment-install-cells
           else
-            uv run python _scripts/prepare_notebooks_for_ci.py
+            poetry run python _scripts/prepare_notebooks_for_ci.py
           fi
 
       - name: Run notebooks

CONTRIBUTING.md

@@ -153,7 +153,7 @@ Each category serves a distinct purpose and requires a specific approach to writ
 
 Here are some other guidelines you should think about when writing and organizing documentation.
 
-We generally do not merge new tutorials from outside contributors without an actual need.
+We generally do not merge new tutorials from outside contributors without an actue need.
 We welcome updates as well as new integration docs, how-tos, and references.
 
 ### Avoid duplication
@@ -227,7 +227,6 @@ see a preview of the documentation on the pull request page.
 
 From the **monorepo root**, run the following command to install the dependencies:
 
-<!-- TODO -->
 ```bash
 poetry install --with docs --no-root
 ```

README.md

@@ -14,7 +14,7 @@
 [![Docs](https://img.shields.io/badge/docs-latest-blue)](https://langchain-ai.github.io/langgraph/)
 [![GitMCP](https://img.shields.io/endpoint?url=https://gitmcp.io/badge/langchain-ai/langgraph)](https://gitmcp.io/langchain-ai/langgraph)
 
-Trusted by companies shaping the future of agents – including Klarna, Replit, Elastic, and more – LangGraph is a low-level orchestration framework for building, managing, and deploying long-running, stateful agents.
+Trusted by companies shaping the future of agents – including Klarna, Replit, Elastic, and more – LangGraph is a powerful low-level orchestration framework for building, managing, and deploying long-running, stateful agents. 
 
 ## Get started
 
@@ -77,7 +77,7 @@ While LangGraph can be used standalone, it also integrates seamlessly with any L
 - [Examples](https://langchain-ai.github.io/langgraph/tutorials/): Guided examples on getting started with LangGraph.
 - [LangChain Academy](https://academy.langchain.com/courses/intro-to-langgraph): Learn the basics of LangGraph in our free, structured course.
 - [Templates](https://langchain-ai.github.io/langgraph/concepts/template_applications/): Pre-built reference apps for common agentic workflows (e.g. ReAct agent, memory, retrieval etc.) that can be cloned and adapted.
-- [Case studies](https://www.langchain.com/built-with-langgraph): Hear how industry leaders use LangGraph to ship AI applications at scale.
+- [Case studies](https://www.langchain.com/built-with-langgraph): Hear how industry leaders use LangGraph to ship powerful, production-ready AI applications.
 
 ## Acknowledgements
 

docs/Makefile

@@ -12,30 +12,32 @@ build-prebuilt:
 	# generates the final prebuilt page.
 	@if [ "$(DOWNLOAD_STATS)" = "true" ]; then \
 		set -x; \
-		uv run python -m _scripts.third_party_page.get_download_stats stats.yml; \
+		poetry run python -m _scripts.third_party_page.get_download_stats stats.yml; \
 		set +x; \
 	else \
 		set -x; \
-		uv run python -m _scripts.third_party_page.get_download_stats --fake stats.yml; \
+		poetry run python -m _scripts.third_party_page.get_download_stats --fake stats.yml; \
 		set +x; \
 	fi
-	uv run python -m _scripts.third_party_page.create_third_party_page stats.yml docs/agents/prebuilt.md --language python
+	poetry run python -m _scripts.third_party_page.create_third_party_page stats.yml docs/agents/prebuilt.md --language python
 
 build-docs: build-typedoc build-prebuilt
-	uv run python -m mkdocs build --clean -f mkdocs.yml --strict
+	poetry run python -m mkdocs build --clean -f mkdocs.yml --strict
 
 llms-text:
-	uv run python -m _scripts.generate_llms_text docs/llms-full.txt
+	poetry run python -m _scripts.generate_llms_text docs/llms-full.txt
 
 install-vercel-deps:
-	curl -sL "https://astral.sh/uv/install.sh" | bash -s
-	export PATH="${HOME}/.cargo/bin:${PATH}"
-	uv venv --python 3.11
-	uv sync --all-groups
+	dnf install -y python3.11
+	curl -sSL https://install.python-poetry.org | python3 -
+	poetry self update 1.8.5
+	# don't use vercel's python - it wasn't compiled with sqlite support, and it fails when installing ipython's kernel
+	poetry env use /usr/bin/python3.11
+	poetry install --with docs --with test --no-root
 
 tests:
 	# Run unit tests
-	uv run pytest tests/unit_tests
+	poetry run pytest tests/unit_tests
 
 
 vercel-build-docs: install-vercel-deps
@@ -43,10 +45,10 @@ vercel-build-docs: install-vercel-deps
 
 
 serve-clean-docs: clean-docs
-	uv run python -m mkdocs serve -c -f mkdocs.yml --strict -w ../libs/langgraph
+	poetry run python -m mkdocs serve -c -f mkdocs.yml --strict -w ../libs/langgraph
 
 serve-docs: build-typedoc
-	uv run python -m mkdocs serve -f mkdocs.yml -w ../libs/langgraph  -w ../libs/checkpoint -w ../libs/sdk-py --dirty
+	poetry run python -m mkdocs serve -f mkdocs.yml -w ../libs/langgraph  -w ../libs/checkpoint -w ../libs/sdk-py --dirty
 
 clean-docs:
 	find ./docs -name "*.ipynb" -type f -delete
@@ -54,13 +56,13 @@ clean-docs:
 
 ## Run format against the project documentation.
 format-docs:
-	uv run ruff format docs
-	uv run ruff check --fix docs
+	poetry run ruff format docs
+	poetry run ruff check --fix docs
 
 # Check the docs for linting violations
 lint-docs:
-	uv run ruff format --check docs
-	uv run ruff check docs
+	poetry run ruff format --check docs
+	poetry run ruff check docs
 
 codespell:
 	./codespell_notebooks.sh .

docs/README.md

@@ -3,7 +3,7 @@
 To setup requirements for building docs you can run:
 
 ```bash
-uv sync --group test
+poetry install --with test
 ```
 
 ## Serving documentation locally

docs/_scripts/execute_notebooks.sh

@@ -8,7 +8,7 @@ execute_notebook() {
     file="$1"
     echo "Starting execution of $file"
     start_time=$(date +%s)
-    if ! output=$(time uv run jupyter execute "$file" 2>&1); then
+    if ! output=$(time poetry run jupyter execute "$file" 2>&1); then
         end_time=$(date +%s)
         execution_time=$((end_time - start_time))
         echo "Error in $file. Execution time: $execution_time seconds"

docs/_scripts/notebook_hooks.py

@@ -53,7 +53,6 @@ REDIRECT_MAP = {
     "how-tos/persistence_redis.ipynb": "how-tos/persistence.ipynb#use-in-production",
     "how-tos/subgraph-persistence.ipynb": "how-tos/persistence.ipynb#use-with-subgraphs",
     "how-tos/cross-thread-persistence.ipynb": "how-tos/persistence.ipynb#add-long-term-memory",
-    "cloud/how-tos/copy_threads": "cloud/how-tos/use_threads",
     # tool calling how-tos
     "how-tos/tool-calling-errors.ipynb": "how-tos/tool-calling.ipynb#handle-errors",
     "how-tos/pass-config-to-tools.ipynb": "how-tos/tool-calling.ipynb#access-config",
@@ -71,7 +70,6 @@ REDIRECT_MAP = {
     "cloud/faq/studio.md": "concepts/langgraph_studio.md#studio-faqs",
     "cloud/how-tos/human_in_the_loop_edit_state.md": "cloud/how-tos/add-human-in-the-loop.md",
     "cloud/how-tos/human_in_the_loop_user_input.md": "cloud/how-tos/add-human-in-the-loop.md",
-    "concepts/platform_architecture.md": "langgraph/concepts/langgraph_cloud#architecture",
     # cloud streaming redirects
     "cloud/how-tos/stream_values.md": "cloud/how-tos/streaming.md#stream-graph-state",
     "cloud/how-tos/stream_updates.md": "cloud/how-tos/streaming.md#stream-graph-state",

docs/docs/agents/mcp.md

@@ -29,7 +29,7 @@ from langchain_mcp_adapters.client import MultiServerMCPClient
 from langgraph.prebuilt import create_react_agent
 
 # highlight-next-line
-client = MultiServerMCPClient(
+async with MultiServerMCPClient(
     {
         "math": {
             "command": "python",
@@ -39,24 +39,22 @@ client = MultiServerMCPClient(
         },
         "weather": {
             # Ensure your start your weather server on port 8000
-            "url": "http://localhost:8000/mcp",
-            "transport": "streamable_http",
+            "url": "http://localhost:8000/sse",
+            "transport": "sse",
         }
     }
-)
-# highlight-next-line
-tools = await client.get_tools()
-agent = create_react_agent(
-    "anthropic:claude-3-7-sonnet-latest",
-    # highlight-next-line
-    tools
-)
-math_response = await agent.ainvoke(
-    {"messages": [{"role": "user", "content": "what's (3 + 5) x 12?"}]}
-)
-weather_response = await agent.ainvoke(
-    {"messages": [{"role": "user", "content": "what is the weather in nyc?"}]}
-)
+) as client:
+    agent = create_react_agent(
+        "anthropic:claude-3-7-sonnet-latest",
+        # highlight-next-line
+        client.get_tools()
+    )
+    math_response = await agent.ainvoke(
+        {"messages": [{"role": "user", "content": "what's (3 + 5) x 12?"}]}
+    )
+    weather_response = await agent.ainvoke(
+        {"messages": [{"role": "user", "content": "what is the weather in nyc?"}]}
+    )
 ```
 
 ## Custom MCP servers
@@ -89,7 +87,7 @@ if __name__ == "__main__":
     mcp.run(transport="stdio")
 ```
 
-```python title="Example Weather Server (Streamable HTTP transport)"
+```python title="Example Weather Server (SSE transport)"
 from mcp.server.fastmcp import FastMCP
 
 mcp = FastMCP("Weather")
@@ -100,7 +98,7 @@ async def get_weather(location: str) -> str:
     return "It's always sunny in New York"
 
 if __name__ == "__main__":
-    mcp.run(transport="streamable-http")
+    mcp.run(transport="sse")
 ```
 
 ## Additional resources

docs/docs/agents/run_agents.md

@@ -10,7 +10,7 @@ hide:
 # Running agents
 
 
-Agents support both synchronous and asynchronous execution using either `.invoke()` / `await .ainvoke()` for full responses, or `.stream()` / `.astream()` for **incremental** [streaming](streaming.md) output. This section explains how to provide input, interpret output, enable streaming, and control execution limits.
+Agents support both synchronous and asynchronous execution using either `.invoke()` / `await .invoke()` for full responses, or `.stream()` / `.astream()` for **incremental** [streaming](streaming.md) output. This section explains how to provide input, interpret output, enable streaming, and control execution limits.
 
 
 ## Basic usage
@@ -18,7 +18,7 @@ Agents support both synchronous and asynchronous execution using either `.invoke
 Agents can be executed in two primary modes:
 
 - **Synchronous** using `.invoke()` or `.stream()`
-- **Asynchronous** using `await .ainvoke()` or `async for` with `.astream()`
+- **Asynchronous** using `await .invoke()` or `async for` with `.astream()`
 
 === "Sync invocation"
     ```python

docs/docs/cloud/concepts/webhooks.md

@@ -2,6 +2,6 @@
 
 Webhooks enable event-driven communication from your LangGraph Platform application to external services. For example, you may want to issue an update to a separate service once an API call to LangGraph Platform has finished running.
 
-Many LangGraph Platform endpoints accept a `webhook` parameter. If this parameter is specified by an endpoint that can accept POST requests, LangGraph Platform will send a request at the completion of a run.
+Many LangGraph Platform endpoints accept a `webhook` parameter. If this parameter is specified by a an endpoint that can accept POST requests, LangGraph Platform will send a request at the completion of a run.
 
 See the corresponding [how-to guide](../../cloud/how-tos/webhooks.md) for more detail.

docs/docs/cloud/deployment/self_hosted_data_plane.md

@@ -18,7 +18,7 @@ Before deploying, review the [conceptual guide for the Self-Hosted Data Plane](.
         helm repo add kedacore https://kedacore.github.io/charts 
         helm install keda kedacore/keda --namespace keda --create-namespace
 
-1. A valid `Ingress` controller is installed on your cluster.
+1. A valid `Ingress` controller is install on your cluster.
 1. You have slack space in your cluster for multiple deployments. `Cluster-Autoscaler` is recommended to automatically provision new nodes.
 
 ### Setup

docs/docs/cloud/deployment/setup_pyproject.md

@@ -56,27 +56,22 @@ cloudpickle>=3.0.0
 Example `pyproject.toml` file:
 
 ```toml
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[project]
+[tool.poetry]
 name = "my-agent"
 version = "0.0.1"
 description = "An excellent agent build for LangGraph Platform."
-authors = [
-    {name = "Polly the parrot", email = "1223+polly@users.noreply.github.com"}
-]
-license = {text = "MIT"}
+authors = ["Polly the parrot <1223+polly@users.noreply.github.com>"]
+license = "MIT"
 readme = "README.md"
-requires-python = ">=3.9"
-dependencies = [
-    "langgraph>=0.2.0",
-    "langchain-fireworks>=0.1.3"
-]
 
-[tool.hatch.build.targets.wheel]
-packages = ["my_agent"]
+[tool.poetry.dependencies]
+python = ">=3.9"
+langgraph = "^0.2.0"
+langchain-fireworks = "^0.1.3"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
 ```
 
 Example file directory:

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

@@ -231,7 +231,7 @@ Inside your deployment, select the "Assistants" tab. For the assistant you would
 To edit the assistant, use the `update` method. This will create a new version of the assistant with the provided edits. See the [Python](https://langchain-ai.github.io/langgraph/cloud/reference/sdk/python_sdk_ref/#langgraph_sdk.client.AssistantsClient.update) and [JS](https://langchain-ai.github.io/langgraph/cloud/reference/sdk/js_ts_sdk_ref/#update) SDK reference docs for more information.
 
 !!! note "Note"
-You must pass in the ENTIRE config (and metadata if you are using it). The update endpoint creates new versions completely from scratch and does not rely on previous versions.
+You must pass in the ENTIRE config (and metadata if you are using it). The update endpoint creates new versions completely from scratch and does not rely on previously versions.
 
 For example, to update your assistant's system prompt:
 === "Python"
@@ -321,7 +321,7 @@ If you now run your graph and pass in this assistant id, it will use the first v
 
 ### LangGraph Platform UI
 
-If using LangGraph Studio, to set the active version of your assistant, click the "Manage Assistants" button and locate the assistant you would like to use. Select the assistant and the version, and then click the "Active" toggle. This will update the assistant to make the selected version active.
+If using LangGraph Studio, to set the active version of your asssistant, click the "Manage Assistants" button and locate the assistant you would like to use. Select the assistant and the version, and then click the "Active" toggle. This will update the assistant to make the selected version active.
 
 !!! warning "Deleting Assistants"
-    Deleting as assistant will delete ALL of its versions. There is currently no way to delete a single version, but by pointing your assistant to the correct version you can skip any versions that you don't wish to use.
+    Deleting as assistant will delete ALL of it's versions. There is currently no way to delete a single version, but by pointing your assistant to the correct version you can skip any versions that you don't wish to use.

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

@@ -4,7 +4,7 @@ Sometimes you don't want to run your graph based on user interaction, but rather
 
 ## Setup
 
-First, let's set up our SDK client, assistant, and thread:
+First, let's setup our SDK client, assistant, and thread:
 
 === "Python"
 

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

@@ -1,6 +1,6 @@
 # Add node to dataset
 
-This guide shows how to add examples to [LangSmith datasets](https://docs.smith.langchain.com/evaluation/how_to_guides#dataset-management) from nodes in the thread log. This is useful to evaluate individual steps of the agent.
+This guide shows how to add examples to [LangSmith datasets](https://docs.smith.langchain.com/evaluation/how_to_guides#dataset-management) from nodes in the thread log. This is useful to evaluate indivudal steps of the agent.
 
 1. Select a thread.
 2. Click on the `Add to Dataset` button.

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

@@ -335,7 +335,7 @@ const { thread, submit } = useStream({
 });
 ```
 
-Then you can push updates to the UI component by calling `ui.push()` / `push_ui_message()` with the same ID as the UI message you wish to update.
+Then you can pushing updates to the UI component by calling `ui.push()` / `push_ui_message()` with the same ID as the UI message you wish to update.
 
 === "Python"
 

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

@@ -488,4 +488,4 @@ You can also view threads in a deployment via the LangGraph Platform UI.
 
 Inside your deployment, select the "Threads" tab. This will load a table of all of the threads in your deployment.
 
-Select a thread to inspect its current state. To view its full history and for further debugging, open the thread in [LangGraph Studio](../../concepts//langgraph_studio.md).
+Select a thread to inspect its current state. To view it's full history and for further debugging, open the thread in [LangGraph Studio](../../concepts//langgraph_studio.md).

docs/docs/cloud/quick_start.md

@@ -20,7 +20,7 @@ To deploy an application to **LangGraph Platform**, your application code must r
 ## 2. Deploy to LangGraph Platform
 
 1. Log in to [LangSmith](https://smith.langchain.com/).
-1. In the left sidebar, select **Deployments**.
+1. In the left sidebar, select **LangGraph Platform**.
 1. Click the **+ New Deployment** button. A pane will open where you can fill in the required fields.
 1. If you are a first time user or adding a private repository that has not been previously connected, click the **Import from GitHub** button and follow the instructions to connect your GitHub account.
 1. Select your New LangGraph Project repository.

docs/docs/concepts/langgraph_server.md

@@ -7,7 +7,7 @@ search:
 
 **LangGraph Server** offers an API for creating and managing agent-based applications. It is built on the concept of [assistants](assistants.md), which are agents configured for specific tasks, and includes built-in [persistence](persistence.md#memory-store) and a **task queue**. This versatile API supports a wide range of agentic application use cases, from background processing to real-time interactions.
 
-Use LangGraph Server to create and manage [assistants](assistants.md), [threads](../cloud/concepts/threads.md), [runs](../cloud/concepts/runs.md), [cron jobs](../cloud/concepts/cron_jobs.md), [webhooks](../cloud/concepts/webhooks.md), and more.
+Use LangGraph Serverto create and manage [assistants](assistants.md), [threads](../cloud/concepts/threads.md), [runs](../cloud/concepts/runs.md), [cron jobs](../cloud/concepts/cron_jobs.md), [webhooks](../cloud/concepts/webhooks.md), and more.
 
 !!! tip "API reference"
   

docs/docs/concepts/low_level.md

@@ -247,54 +247,6 @@ from langgraph.graph import END
 graph.add_edge("node_a", END)
 ```
 
-### Node Caching
-
-LangGraph supports caching of tasks/nodes based on the input to the node. To use caching:
-
-* Specify a cache when compiling a graph (or specifying an entrypoint)
-* Specify a cache policy for nodes. Each cache policy supports:
-    * `key_func` used to generate a cache key based on the input to a node, which defaults to a `hash` of the input with pickle.
-    * `ttl`, the time to live for the cache in seconds. If not specified, the cache will never expire.
-
-For example:
-
-```py
-import time
-from typing_extensions import TypedDict
-from langgraph.graph import StateGraph
-from langgraph.cache.memory import InMemoryCache
-from langgraph.types import CachePolicy
-
-
-class State(TypedDict):
-    x: int
-    result: int
-
-
-builder = StateGraph(State)
-
-
-def expensive_node(state: State) -> dict[str, int]:
-    # expensive computation
-    time.sleep(2)
-    return {"result": state["x"] * 2}
-
-
-builder.add_node("expensive_node", expensive_node, cache_policy=CachePolicy(ttl=3))
-builder.set_entry_point("expensive_node")
-builder.set_finish_point("expensive_node")
-
-graph = builder.compile(cache=InMemoryCache())
-
-print(graph.invoke({"x": 5}, stream_mode='updates'))  # (1)!
-[{'expensive_node': {'result': 10}}]
-print(graph.invoke({"x": 5}, stream_mode='updates'))  # (2)!
-[{'expensive_node': {'result': 10}, '__metadata__': {'cached': True}}]
-```
-
-1. First run takes the full second to run (due to mocked expensive computation).
-2. Second run utilizes cache and returns quickly.
-
 ## Edges
 
 Edges define how the logic is routed and how the graph decides to stop. This is a big part of how your agents work and how different nodes communicate with each other. There are a few key types of edges:

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

@@ -1288,43 +1288,12 @@
   },
   {
    "cell_type": "markdown",
-   "id": "068f806a",
+   "id": "4eeb895c-adca-40ab-b289-93ee56e18661",
    "metadata": {},
    "source": [
     "</details>"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "6d99d63c",
-   "metadata": {},
-   "source": [
-    "## Add node caching\n",
-    "\n",
-    "Node caching is useful in cases where you want to avoid repeating operations, like when doing something expensive (either in terms of time or cost). LangGraph lets you add individualized caching policies to nodes in a graph.\n",
-    "\n",
-    "To configure a cache policy, pass the `cache_policy` parameter to the [add_node](https://langchain-ai.github.io/langgraph/reference/graphs/#langgraph.graph.state.StateGraph.add_node) function. In the following example, a [`CachePolicy`](https://langchain-ai.github.io/langgraph/reference/types/?h=cachepolicy#langgraph.types.CachePolicy) object is instantiated with a time to live of 120 seconds and the default `key_func` generator. Then it is associated with a node:\n",
-    "\n",
-    "```python\n",
-    "from langgraph.types import CachePolicy\n",
-    "\n",
-    "builder.add_node(\n",
-    "    \"node_name\",\n",
-    "    node_function,\n",
-    "    cache_policy=CachePolicy(ttl=120),\n",
-    ")\n",
-    "```\n",
-    "\n",
-    "Then, to enable node-level caching for a graph,  set the `cache` argument when compiling the graph. The example below uses `InMemoryCache` to set up a graph with in-memory cache, but `SqliteCache` is also available.\n",
-    "\n",
-    "```python\n",
-    "from langgraph.cache.memory import InMemoryCache\n",
-    "\n",
-    "\n",
-    "graph = builder.compile(cache=InMemoryCache())\n",
-    "```"
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "e1a0213e-282f-4fad-b048-5f7465edfccb",
@@ -1785,19 +1754,18 @@
   },
   {
    "cell_type": "markdown",
-   "id": "48731230",
+   "id": "205ff836-0f97-4ee8-9830-6bd8368e48c9",
    "metadata": {},
    "source": [
-    "### Defer node execution\n",
+    "<details class=\"example\"><summary>Extended example: unequal length branches</summary>\n",
     "\n",
-    "Deferring node execution is useful when you want to delay the execution of a node until all other pending tasks are completed. This is particularly relevant when branches have different lengths, which is common in workflows like map-reduce flows.\n",
-    "\n",
-    "The above example showed how to fan-out and fan-in when each path was only one step. But what if one branch had more than one step? Let's add a node `\"b_2\"` in the `\"b\"` branch:"
+    "The above example showed how to fan-out and fan-in when each path was only one step. But what if one path had more than one step? Let's add a node <code>b_2</code> in the \"b\" branch:\n",
+    "<br>"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 1,
    "id": "3890af2f-fb14-4569-b48d-a91db2d3f026",
    "metadata": {},
    "outputs": [],
@@ -1845,14 +1813,13 @@
     "builder.add_node(b)\n",
     "builder.add_node(b_2)\n",
     "builder.add_node(c)\n",
-    "# highlight-next-line\n",
-    "builder.add_node(d, defer=True)\n",
+    "builder.add_node(d)\n",
     "builder.add_edge(START, \"a\")\n",
     "builder.add_edge(\"a\", \"b\")\n",
     "builder.add_edge(\"a\", \"c\")\n",
     "builder.add_edge(\"b\", \"b_2\")\n",
-    "builder.add_edge(\"b_2\", \"d\")\n",
-    "builder.add_edge(\"c\", \"d\")\n",
+    "# highlight-next-line\n",
+    "builder.add_edge([\"b_2\", \"c\"], \"d\")\n",
     "builder.add_edge(\"d\", END)\n",
     "graph = builder.compile()"
    ]
@@ -1914,10 +1881,23 @@
   },
   {
    "cell_type": "markdown",
-   "id": "70e67ced",
+   "id": "903f0da5-8c2c-4a7e-96fb-0b16b4756eff",
    "metadata": {},
    "source": [
-    "In the above example, nodes `\"b\"` and `\"c\"` are executed concurrently in the same superstep. We set `defer=True` on node `d` so it will not execute until all pending tasks are finished. In this case, this means that `\"d\"` waits to execute until the entire `\"b\"` branch is finished."
+    "<div class=\"admonition note\">\n",
+    "    <p class=\"admonition-title\">Note</p>\n",
+    "<p>In the above example, nodes <code>\"b\"</code> and <code>\"c\"</code> are executed concurrently in the same [superstep](../../concepts/low_level/#graphs). What happens in the next step?</p>\n",
+    "    <p>We use <code>add_edge([\"b_2\", \"c\"], \"d\")</code> here to force node <code>\"d\"</code> to only run when both nodes <code>\"b_2\"</code> and <code>\"c\"</code> have finished execution. If we added two separate edges,\n",
+    "    node <code>\"d\"</code> would run twice: after node <code>b2</code> finishes and once again after node <code>c</code> (in whichever order those nodes finish).</p>\n",
+    "</div>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c1653341-3215-4ca0-b0e7-9be22f0adaa1",
+   "metadata": {},
+   "source": [
+    "</details>"
    ]
   },
   {

docs/docs/how-tos/persistence.ipynb

@@ -184,7 +184,7 @@
     "??? example \"Example: using [Postgres](https://pypi.org/project/langgraph-checkpoint-postgres/) checkpointer\"\n",
     "\n",
     "    ```\n",
-    "    pip install -U \"psycopg[binary,pool]\" langgraph langgraph-checkpoint-postgres\n",
+    "    pip install -U psycopg psycopg-pool langgraph langgraph-checkpoint-postgres\n",
     "    ```\n",
     "\n",
     "    !!! Setup\n",
@@ -1129,7 +1129,7 @@
     "??? example \"Example: using [Postgres](https://pypi.org/project/langgraph-checkpoint-postgres/) store\"\n",
     "\n",
     "    ```\n",
-    "    pip install -U \"psycopg[binary,pool]\" langgraph langgraph-checkpoint-postgres\n",
+    "    pip install -U psycopg psycopg-pool langgraph langgraph-checkpoint-postgres\n",
     "    ```\n",
     "\n",
     "    !!! Setup\n",

docs/docs/how-tos/streaming.md

@@ -71,7 +71,7 @@ Basic usage example:
 | [`values`](#stream-graph-state)  | Streams the full value of the state after each step of the graph.                                                                                                                   |
 | [`updates`](#stream-graph-state) | Streams the updates to the state after each step of the graph. If multiple updates are made in the same step (e.g., multiple nodes are run), those updates are streamed separately. |
 | [`custom`](#stream-custom-data)  | Streams custom data from inside your graph nodes.                                                                                                                                   |
-| [`messages`](#messages)          | Streams 2-tuples (LLM token, metadata) from any graph nodes where an LLM is invoked.                                                                                                        |
+| [`messages`](#messages)          | Streams LLM tokens and metadata for the graph node where the LLM is invoked.                                                                                                        |
 | [`debug`](#debug)                | Streams as much information as possible throughout the execution of the graph.                                                                                                      |
 
 ### Stream multiple modes
@@ -161,8 +161,6 @@ graph = (
 
 To include outputs from [subgraphs](../concepts/subgraphs.md) in the streamed outputs, you can set `subgraphs=True` in the `.stream()` method of the parent graph. This will stream outputs from both the parent graph and any subgraphs.
 
-The outputs will be streamed as tuples `(namespace, data)`, where `namespace` is a tuple with the path to the node where a subgraph is invoked, e.g. `("parent_node:<task_id>", "child_node:<task_id>")`.
-
 ```python
 for chunk in graph.stream(
     {"foo": "foo"},
@@ -181,17 +179,21 @@ for chunk in graph.stream(
       from langgraph.graph import START, StateGraph
       from typing import TypedDict
 
+
       # Define subgraph
       class SubgraphState(TypedDict):
           foo: str  # note that this key is shared with the parent graph state
           bar: str
 
+
       def subgraph_node_1(state: SubgraphState):
           return {"bar": "bar"}
 
+
       def subgraph_node_2(state: SubgraphState):
           return {"foo": state["foo"] + state["bar"]}
 
+
       subgraph_builder = StateGraph(SubgraphState)
       subgraph_builder.add_node(subgraph_node_1)
       subgraph_builder.add_node(subgraph_node_2)
@@ -199,13 +201,16 @@ for chunk in graph.stream(
       subgraph_builder.add_edge("subgraph_node_1", "subgraph_node_2")
       subgraph = subgraph_builder.compile()
 
+
       # Define parent graph
       class ParentState(TypedDict):
           foo: str
 
+
       def node_1(state: ParentState):
           return {"foo": "hi! " + state["foo"]}
 
+
       builder = StateGraph(ParentState)
       builder.add_node("node_1", node_1)
       builder.add_node("node_2", subgraph)
@@ -224,13 +229,6 @@ for chunk in graph.stream(
       
       1. Set `subgraphs=True` to stream outputs from subgraphs.
 
-      ```
-      ((), {'node_1': {'foo': 'hi! foo'}})
-      (('node_2:dfddc4ba-c3c5-6887-5012-a243b5b377c2',), {'subgraph_node_1': {'bar': 'bar'}})
-      (('node_2:dfddc4ba-c3c5-6887-5012-a243b5b377c2',), {'subgraph_node_2': {'foo': 'hi! foobar'}})
-      ((), {'node_2': {'foo': 'hi! foobar'}})
-      ```
-
       **Note** that we are receiving not just the node updates, but we also the namespaces which tell us what graph (or subgraph) we are streaming from.
 
 ## Debugging {#debug}

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

@@ -349,38 +349,6 @@ main.invoke({'any_input': 'foobar'}, config=config)
 'OK'
 ```
 
-## Caching Tasks
-
-```python
-import time
-from langgraph.cache.memory import InMemoryCache
-from langgraph.func import entrypoint, task
-from langgraph.types import CachePolicy
-
-
-@task(cache_policy=CachePolicy(ttl=120))  # (1)!
-def slow_add(x: int) -> int:
-    time.sleep(1)
-    return x * 2
-
-
-@entrypoint(cache=InMemoryCache())
-def main(inputs: dict) -> dict[str, int]:
-    result1 = slow_add(inputs["x"]).result()
-    result2 = slow_add(inputs["x"]).result()
-    return {"result1": result1, "result2": result2}
-
-
-for chunk in main.stream({"x": 5}, stream_mode="updates"):
-    print(chunk)
-
-#> {'slow_add': 10}
-#> {'slow_add': 10, '__metadata__': {'cached': True}}
-#> {'main': {'result1': 10, 'result2': 10}}
-```
-
-1. `ttl` is specified in seconds. The cache will be invalidated after this time.
-
 ## Resuming after an error
 
 ```python

docs/docs/reference/cache.md

@@ -1,5 +0,0 @@
-## Caching
-
-::: langgraph.cache.base
-::: langgraph.cache.memory
-::: langgraph.cache.sqlite

docs/docs/reference/index.md

@@ -29,7 +29,6 @@ The core APIs for the LangGraph opens source library.
 - [Pregel](pregel.md): Pregel-inspired computation model.
 - [Checkpointing](checkpoints.md): Saving and restoring graph state.
 - [Storage](store.md): Storage backends and options.
-- [Caching](cache.md): Caching mechanisms for performance.
 - [Types](types.md): Type definitions for graph components.
 - [Config](config.md): Configuration options.
 - [Errors](errors.md): Error types and handling.

docs/docs/troubleshooting/errors/INVALID_CHAT_HISTORY.md

@@ -6,7 +6,7 @@ There could be a few reasons you're seeing this error:
 
 1. You manually passed a malformed list of messages when invoking the graph, e.g. `graph.invoke({'messages': [AIMessage(..., tool_calls=[...])]})`
 2. The graph was interrupted before receiving updates from the `tools` node (i.e. a list of ToolMessages)
-and you invoked it with an input that is not None or a ToolMessage,
+and you invoked it with a an input that is not None or a ToolMessage,
 e.g. `graph.invoke({'messages': [HumanMessage(...)]}, config)`.
     This interrupt could have been triggered in one of the following ways:
      - You manually set `interrupt_before = ['tools']` in `create_react_agent`

docs/docs/troubleshooting/errors/INVALID_GRAPH_NODE_RETURN_VALUE.md

@@ -8,7 +8,7 @@ class State(TypedDict):
     some_key: str
 
 def bad_node(state: State):
-    # Should return a dict with a value for "some_key", not a list
+    # Should return an dict with a value for "some_key", not a list
     return ["whoops"]
 
 builder = StateGraph(State)
@@ -29,7 +29,7 @@ InvalidUpdateError: Expected dict, got ['whoops']
 For troubleshooting, visit: https://python.langchain.com/docs/troubleshooting/errors/INVALID_GRAPH_NODE_RETURN_VALUE
 ```
 
-Nodes in your graph must return a dict containing one or more keys defined in your state.
+Nodes in your graph must return an dict containing one or more keys defined in your state.
 
 ## Troubleshooting
 

docs/docs/tutorials/auth/add_auth_server.md

@@ -1,6 +1,6 @@
 # Connect an authentication provider
 
-In [the last tutorial](resource_auth.md), you added [resource authorization](../../tutorials/auth/resource_auth.md) to give users private conversations. However, you are still using hard-coded tokens for authentication, which is not secure. Now you'll replace those tokens with real user accounts using [OAuth2](../auth/getting_started.md).
+In the [the last tutorial](resource_auth.md), you added [resource authorization](../../tutorials/auth/resource_auth.md) to give users private conversations. However, you are still using hard-coded tokens for authentication, which is not secure. Now you'll replace those tokens with real user accounts using [OAuth2](../auth/getting_started.md).
 
 You'll keep the same [`Auth`](../../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.Auth) object and [resource-level access control](../../concepts/auth.md#single-owner-resources), but upgrade authentication to use Supabase as your identity provider. While Supabase is used in this tutorial, the concepts apply to any OAuth2 provider. You'll learn how to:
 
@@ -190,7 +190,7 @@ await sign_up(email1, password)
 await sign_up(email2, password)
 ```
 
-⚠️ Before continuing: Check your email and click both confirmation links. Supabase will reject `/login` requests until after you have confirmed your users' email.
+⚠️ Before continuing: Check your email and click both confirmation links. Supabase will will reject `/login` requests until after you have confirmed your users' email.
 
 Now test that users can only see their own data. Make sure the server is running (run `langgraph dev`) before proceeding. The following snippet requires the "anon public" key that you copied from the Supabase dashboard while [setting up the auth provider](#setup-auth-provider) previously. 
 

docs/docs/tutorials/auth/getting_started.md

@@ -181,6 +181,6 @@ Congratulations! You've built a chatbot that only lets "authenticated" users acc
 
 Now that you can control who accesses your bot, you might want to:
 
-1. Continue the tutorial by going to [Make conversations private](resource_auth.md) to learn about resource authorization.
+1. Continue the tutorial by going to [Make cnversations private](resource_auth.md) to learn about resource authorization.
 2. Read more about [authentication concepts](../../concepts/auth.md).
 3. Check out the [API reference](../../cloud/reference/sdk/python_sdk_ref.md) for more authentication details.

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

@@ -8,23 +8,7 @@ Before you begin, ensure you have the following:
 
 - An API key for [LangSmith](https://smith.langchain.com/settings) - free to sign up
 
-## 1. Install the LangGraph CLI
-
-=== "Python server"
-
-    ```shell
-    # Python >= 3.11 is required.
-
-    pip install --upgrade "langgraph-cli[inmem]"
-    ```
-
-=== "Node server"
-
-    ```shell
-    npx @langchain/langgraph-cli
-    ```
-
-## 2. Create a LangGraph app 🌱
+## 1. Create a LangGraph app 🌱
 
 Create a new app from the [`new-langgraph-project-python` template](https://github.com/langchain-ai/new-langgraph-project) or [`new-langgraph-project-js` template](https://github.com/langchain-ai/new-langgraphjs-project). This template demonstrates a single-node application you can extend with your own logic.
 
@@ -44,25 +28,25 @@ Create a new app from the [`new-langgraph-project-python` template](https://gith
 
     If you use `langgraph new` without specifying a template, you will be presented with an interactive menu that will allow you to choose from a list of available templates.
 
-## 3. 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:
+## 2. Install dependencies and LangGraph CLI
 
 === "Python server"
 
     ```shell
+    # Python >= 3.11 is required.
     cd path/to/your/app
-    pip install -e .
+    pip install -e . "langgraph-cli[inmem]"
     ```
 
 === "Node server"
 
     ```shell
     cd path/to/your/app
+    npx @langchain/langgraph-cli
     yarn install
     ```
 
-## 4. Create a `.env` file
+## 3. Create a `.env` file
 
 You will find a `.env.example` in the root of your new LangGraph app. Create a `.env` file in the root of your new LangGraph app and copy the contents of the `.env.example` file into it, filling in the necessary API keys:
 
@@ -70,7 +54,7 @@ You will find a `.env.example` in the root of your new LangGraph app. Create a `
 LANGSMITH_API_KEY=lsv2...
 ```
 
-## 5. Launch LangGraph Server 🚀
+## 4. Launch LangGraph Server 🚀
 
 Start the LangGraph API server locally:
 
@@ -100,7 +84,7 @@ Sample output:
 
 The `langgraph dev` command starts LangGraph Server in an in-memory mode. This mode is suitable for development and testing purposes. For production use, deploy LangGraph Server with access to a persistent storage backend. For more information, see [Deployment options](../../concepts/deployment_options.md).
 
-## 6. Test your application in LangGraph Studio
+## 5. Test your application in LangGraph Studio
 
 [LangGraph Studio](../../concepts/langgraph_studio.md) is a specialized UI that you can connect to LangGraph API server to visualize, interact with, and debug your application locally. Test your graph in LangGraph Studio by visiting the URL provided in the output of the `langgraph dev` command:
 
@@ -118,7 +102,7 @@ For a LangGraph Server running on a custom host/port, update the baseURL paramet
     langgraph dev --tunnel
     ```
 
-## 7. Test the API
+## 6. Test the API
 
 === "Python SDK (async)"
 

docs/docs/tutorials/sql-agent.ipynb

@@ -583,7 +583,7 @@
     "def check_query(state: MessagesState):\n",
     "    system_message = {\n",
     "        \"role\": \"system\",\n",
-    "        \"content\": check_query_system_prompt,\n",
+    "        \"content\": generate_query_system_prompt,\n",
     "    }\n",
     "\n",
     "    # Generate an artificial user message to check\n",

docs/docs/tutorials/workflows.md

@@ -122,8 +122,8 @@ As noted in the Anthropic blog on `Building Effective Agents`:
 
         # Simple check - does the joke contain "?" or "!"
         if "?" in state["joke"] or "!" in state["joke"]:
-            return "Pass"
-        return "Fail"
+            return "Fail"
+        return "Pass"
 
 
     def improve_joke(state: State):

docs/mkdocs.yml

@@ -255,7 +255,6 @@ nav:
       - Pregel: reference/pregel.md
       - Checkpointing: reference/checkpoints.md
       - Storage: reference/store.md
-      - Caching: reference/cache.md
       - Types: reference/types.md
       - Config: reference/config.md
       - Errors: reference/errors.md

docs/pyproject.toml

@@ -1,99 +1,88 @@
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[project]
+[tool.poetry]
 name = "langgraph-docs"
 version = "0.0.1"
 description = "LangGraph docs"
 authors = []
-requires-python = "~=3.10"
-readme = "README.md"
 license = "MIT"
-dependencies = [
-    "aiohappyeyeballs==2.4.3",
-    "hub>=3.0.1,<4",
-    "xxhash>=3.5.0,<4",
-    "black>=25.1.0,<26",
-]
+readme = "README.md"
+package-mode = false
 
-[dependency-groups]
-docs = [
-    "langgraph",
-    "langgraph-prebuilt",
-    "langgraph-checkpoint",
-    "langgraph-checkpoint-sqlite",
-    "langgraph-checkpoint-postgres",
-    "langgraph-sdk",
-    "langgraph-supervisor",
-    "langgraph-swarm",
-    "langchain-mcp-adapters",
-    "langchain-ollama",
-    "mkdocs",
-    "mkdocs-autorefs",
-    "mkdocstrings",
-    "mkdocstrings-python",
-    "mkdocs-minify-plugin",
-    "mkdocs-rss-plugin",
-    "mkdocs-git-committers-plugin-2",
-    "mkdocs-material[imaging]",
-    "markdown-callouts",
-    "markdown-include",
-    "mkdocs-exclude",
-    "psycopg[binary]",
-    "psycopg-pool",
-    "pygments-ansi-color",
-    "vcrpy",
-    "click",
-    "ruff",
-    "jupyter",
-    "langchain-cohere",
-]
-test = [
-    "langchain",
-    "langchain-core",
-    "langchain-openai",
-    "langchain-anthropic",
-    "langchain-nomic",
-    "langchain-fireworks",
-    "langchain-community",
-    "langchain-tavily",
-    "langchain-experimental",
-    "langchain-mistralai",
-    "langgraph-checkpoint-mongodb",
-    "langmem",
-    "langsmith",
-    "chromadb",
-    "gpt4all",
-    "scikit-learn",
-    "numexpr",
-    "numpy",
-    "matplotlib",
-    "redis",
-    "pymongo",
-    "motor",
-    "grandalf",
-    "pyppeteer",
-    "networkx",
-    "autogen ; python_version >= '3.8' and python_version < '3.13'",
-    "pytest",
-    "pytest-check-links",
-]
+[tool.poetry.dependencies]
+python = "^3.10"
+aiohappyeyeballs = "2.4.3"
+hub = "^3.0.1"
+xxhash = "^3.5.0"
+black = "^25.1.0"
 
-[tool.uv]
-package = false
-default-groups = ["docs","test",]
-
-[tool.uv.sources]
-langgraph = { path = "../libs/langgraph/", editable = true }
-langgraph-prebuilt = { path = "../libs/prebuilt", editable = true }
-langgraph-checkpoint = { path = "../libs/checkpoint/", editable = true }
-langgraph-checkpoint-sqlite = { path = "../libs/checkpoint-sqlite", editable = true }
-langgraph-checkpoint-postgres = { path = "../libs/checkpoint-postgres", editable = true }
-langgraph-sdk = { path = "../libs/sdk-py", editable = true }
+[tool.poetry.group.docs.dependencies]
+langgraph = { path = "../libs/langgraph/", develop = true }
+langgraph-prebuilt = {path = "../libs/prebuilt", develop = true}
+langgraph-checkpoint = { path = "../libs/checkpoint/", develop = true }
+langgraph-checkpoint-sqlite = { path = "../libs/checkpoint-sqlite", develop = true }
+langgraph-checkpoint-postgres = { path = "../libs/checkpoint-postgres", develop = true }
+langgraph-sdk = {path = "../libs/sdk-py", develop = true}
+# TODO: switch these to published versions
 langgraph-supervisor = { git = "https://github.com/langchain-ai/langgraph-supervisor-py" }
 langgraph-swarm = { git = "https://github.com/langchain-ai/langgraph-swarm-py" }
 langchain-mcp-adapters = { git = "https://github.com/langchain-ai/langchain-mcp-adapters" }
+langchain-ollama = "^0.2.3"
+mkdocs = "*"
+mkdocs-autorefs = "*"
+mkdocstrings = "*"
+mkdocstrings-python = "*"
+mkdocs-minify-plugin = "*"
+mkdocs-rss-plugin = "*"
+mkdocs-git-committers-plugin-2 = "*"
+mkdocs-material = {extras = ["imaging"], version = "*"}
+markdown-callouts = "*"
+markdown-include = "*"
+mkdocs-exclude = "*"
+psycopg = {extras = ["binary"], version = "^3.2.0"}
+psycopg-pool = "^3.2.0"
+pygments-ansi-color = ">=0.3"
+vcrpy = "^6.0.1"
+click = "^8.1.7"
+ruff = "^0.6.8"
+jupyter = "^1.1.1"
+langchain-cohere = "^0.4.2"
+
+[tool.poetry.group.test.dependencies]
+langchain = "^0.3.8"
+langchain-core = "^0.3.54"
+langchain-openai = "^0.3.7"
+langchain-anthropic = "^0.3.8"
+langchain-nomic = "^0.1.3"
+langchain-fireworks = "^0.2.0"
+langchain-community = "^0.3.0"
+langchain-tavily = "^0.1.5"
+langchain-experimental = "^0.3.2"
+langchain-mistralai = "^0.2.6"
+langgraph-checkpoint-mongodb = "^0.1.0"
+langmem = "^0.0.19"
+langsmith = "^0.3.0"
+chromadb = "^0.5.5"
+gpt4all = "^2.8.2"
+scikit-learn = "^1.5.2"
+numexpr = "^2.10.1"
+numpy = "^1.26.4"
+matplotlib = "^3.9.2"
+redis = "^5.0.8"
+pymongo = "^4.8.0"
+motor = "^3.5.1"
+grandalf = "^0.8"
+pyppeteer = "^2.0.0"
+networkx = "^3.3"
+autogen = { version = "^0.3.0", python = "<3.13,>=3.8" }
+pytest = "^8.3.5"
+pytest-check-links = "^0.10.1"
+
+[tool.poetry.group.test]
+optional = true
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
 
 [tool.ruff]
 extend-include = ["*.ipynb"]

libs/checkpoint-postgres/Makefile

@@ -18,7 +18,7 @@ POSTGRES_VERSIONS ?= 15 16
 test_pg_version:
 	@echo "Testing PostgreSQL $(POSTGRES_VERSION)"
 	@POSTGRES_VERSION=$(POSTGRES_VERSION) make start-postgres
-	@uv run pytest $(TEST)
+	@poetry run pytest $(TEST)
 	@EXIT_CODE=$$?; \
 	make stop-postgres; \
 	echo "Finished testing PostgreSQL $(POSTGRES_VERSION); Exit code: $$EXIT_CODE"; \
@@ -36,7 +36,7 @@ test:
 TEST ?= .
 test_watch:
 	POSTGRES_VERSION=${POSTGRES_VERSION:-16} make start-postgres; \
-	uv run ptw $(TEST); \
+	poetry run ptw $(TEST); \
 	EXIT_CODE=$$?; \
 	make stop-postgres; \
 	exit $$EXIT_CODE
@@ -55,12 +55,12 @@ lint_tests: PYTHON_FILES=tests
 lint_tests: MYPY_CACHE=.mypy_cache_test
 
 lint lint_diff lint_package lint_tests:
-	uv run ruff check .
-	[ "$(PYTHON_FILES)" = "" ] || uv run ruff format $(PYTHON_FILES) --diff
-	[ "$(PYTHON_FILES)" = "" ] || uv run ruff check --select I $(PYTHON_FILES)
+	poetry run ruff check .
+	[ "$(PYTHON_FILES)" = "" ] || poetry run ruff format $(PYTHON_FILES) --diff
+	[ "$(PYTHON_FILES)" = "" ] || poetry run ruff check --select I $(PYTHON_FILES)
 	[ "$(PYTHON_FILES)" = "" ] || mkdir -p $(MYPY_CACHE)
-	[ "$(PYTHON_FILES)" = "" ] || uv run mypy $(PYTHON_FILES) --cache-dir $(MYPY_CACHE)
+	[ "$(PYTHON_FILES)" = "" ] || poetry run mypy $(PYTHON_FILES) --cache-dir $(MYPY_CACHE)
 
 format format_diff:
-	uv run ruff format $(PYTHON_FILES)
-	uv run ruff check --select I --fix $(PYTHON_FILES)
+	poetry run ruff format $(PYTHON_FILES)
+	poetry run ruff check --select I --fix $(PYTHON_FILES)

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

@@ -333,7 +333,7 @@ class BasePostgresStore(Generic[C]):
             # First handle main store insertions
             for op in inserts:
                 if op.ttl is not None:
-                    expires_at_str = f"NOW() + INTERVAL '{op.ttl * 60} seconds'"
+                    expires_at_str = f"NOW() + INTERVAL '{op.ttl*60} seconds'"
                     ttl_minutes = op.ttl
                 else:
                     expires_at_str = "NULL"

libs/checkpoint-postgres/pyproject.toml

@@ -1,53 +1,47 @@
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[project]
+[tool.poetry]
 name = "langgraph-checkpoint-postgres"
 version = "2.0.21"
 description = "Library with a Postgres implementation of LangGraph checkpoint saver."
 authors = []
-requires-python = ">=3.9"
-readme = "README.md"
 license = "MIT"
-license-files = ['LICENSE']
-dependencies = [
-  "langgraph-checkpoint>=2.0.21",
-  "orjson>=3.10.1",
-  "psycopg>=3.2.0",
-  "psycopg-pool>=3.2.0",
-]
+readme = "README.md"
+repository = "https://www.github.com/langchain-ai/langgraph"
+packages = [{ include = "langgraph" }]
 
-[project.urls]
-Repository = "https://www.github.com/langchain-ai/langgraph"
+[tool.poetry.dependencies]
+python = ">=3.9"
+langgraph-checkpoint = "^2.0.21"
+orjson = ">=3.10.1"
+psycopg = "^3.2.0"
+psycopg-pool = "^3.2.0"
 
-[dependency-groups]
-dev = [
-  "ruff",
-  "codespell",
-  "pytest",
-  "anyio",
-  "pytest-asyncio",
-  "pytest-mock",
-  "mypy",
-  "psycopg[binary]",
-  "langgraph-checkpoint",
-  "pytest-watcher",
-]
-
-[tool.uv]
-default-groups = ['dev']
-
-[tool.uv.sources]
-langgraph-checkpoint = { path = "../checkpoint", editable = true }
-
-[tool.hatch.build.targets.wheel]
-include = ["langgraph"]
+[tool.poetry.group.dev.dependencies]
+ruff = "^0.6.2"
+codespell = "^2.2.0"
+pytest = "^7.2.1"
+anyio = "^4.4.0"
+pytest-asyncio = "^0.21.1"
+pytest-mock = "^3.11.1"
+mypy = "^1.10.0"
+psycopg = {extras = ["binary"], version = ">=3.0.0"}
+langgraph-checkpoint = {path = "../checkpoint", develop = true}
+pytest-watcher = { version = ">=0.4.3", python = "<4.0" }
 
 [tool.pytest.ini_options]
+# --strict-markers will raise errors on unknown marks.
+# https://docs.pytest.org/en/7.1.x/how-to/mark.html#raising-errors-on-unknown-marks
+#
+# https://docs.pytest.org/en/7.1.x/reference/reference.html
+# --strict-config       any warnings encountered while parsing the `pytest`
+#                       section of the configuration file raise errors.
 addopts = "--strict-markers --strict-config --durations=5 -vv"
 asyncio_mode = "auto"
 
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
 [tool.ruff]
 lint.select = [
   "E",  # pycodestyle

libs/checkpoint-sqlite/Makefile

@@ -4,13 +4,11 @@
 # TESTING AND COVERAGE
 ######################
 
-TEST ?= .
-
 test:
-	uv run pytest $(TEST)
+	poetry run pytest tests
 
 test_watch:
-	uv run ptw $(TEST)
+	poetry run ptw .
 
 ######################
 # LINTING AND FORMATTING
@@ -26,12 +24,12 @@ lint_tests: PYTHON_FILES=tests
 lint_tests: MYPY_CACHE=.mypy_cache_test
 
 lint lint_diff lint_package lint_tests:
-	uv run ruff check .
-	[ "$(PYTHON_FILES)" = "" ] || uv run ruff format $(PYTHON_FILES) --diff
-	[ "$(PYTHON_FILES)" = "" ] || uv run ruff check --select I $(PYTHON_FILES)
+	poetry run ruff check .
+	[ "$(PYTHON_FILES)" = "" ] || poetry run ruff format $(PYTHON_FILES) --diff
+	[ "$(PYTHON_FILES)" = "" ] || poetry run ruff check --select I $(PYTHON_FILES)
 	[ "$(PYTHON_FILES)" = "" ] || mkdir -p $(MYPY_CACHE)
-	[ "$(PYTHON_FILES)" = "" ] || uv run mypy $(PYTHON_FILES) --cache-dir $(MYPY_CACHE)
+	[ "$(PYTHON_FILES)" = "" ] || poetry run mypy $(PYTHON_FILES) --cache-dir $(MYPY_CACHE)
 
 format format_diff:
-	uv run ruff format $(PYTHON_FILES)
-	uv run ruff check --select I --fix $(PYTHON_FILES)
+	poetry run ruff format $(PYTHON_FILES)
+	poetry run ruff check --select I --fix $(PYTHON_FILES)

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

@@ -1,9 +1,8 @@
 import random
 import sqlite3
 import threading
-from collections.abc import AsyncIterator, Iterator, Sequence
 from contextlib import closing, contextmanager
-from typing import Any, Optional, cast
+from typing import Any, AsyncIterator, Dict, Iterator, Optional, Sequence, Tuple
 
 from langchain_core.runnables import RunnableConfig
 
@@ -262,12 +261,7 @@ class SqliteSaver(BaseCheckpointSaver[str]):
                 return CheckpointTuple(
                     config,
                     self.serde.loads_typed((type, checkpoint)),
-                    cast(
-                        CheckpointMetadata,
-                        self.jsonplus_serde.loads(metadata)
-                        if metadata is not None
-                        else {},
-                    ),
+                    self.jsonplus_serde.loads(metadata) if metadata is not None else {},
                     (
                         {
                             "configurable": {
@@ -289,7 +283,7 @@ class SqliteSaver(BaseCheckpointSaver[str]):
         self,
         config: Optional[RunnableConfig],
         *,
-        filter: Optional[dict[str, Any]] = None,
+        filter: Optional[Dict[str, Any]] = None,
         before: Optional[RunnableConfig] = None,
         limit: Optional[int] = None,
     ) -> Iterator[CheckpointTuple]:
@@ -355,12 +349,7 @@ class SqliteSaver(BaseCheckpointSaver[str]):
                         }
                     },
                     self.serde.loads_typed((type, checkpoint)),
-                    cast(
-                        CheckpointMetadata,
-                        self.jsonplus_serde.loads(metadata)
-                        if metadata is not None
-                        else {},
-                    ),
+                    self.jsonplus_serde.loads(metadata) if metadata is not None else {},
                     (
                         {
                             "configurable": {
@@ -439,7 +428,7 @@ class SqliteSaver(BaseCheckpointSaver[str]):
     def put_writes(
         self,
         config: RunnableConfig,
-        writes: Sequence[tuple[str, Any]],
+        writes: Sequence[Tuple[str, Any]],
         task_id: str,
         task_path: str = "",
     ) -> None:
@@ -507,7 +496,7 @@ class SqliteSaver(BaseCheckpointSaver[str]):
         self,
         config: Optional[RunnableConfig],
         *,
-        filter: Optional[dict[str, Any]] = None,
+        filter: Optional[Dict[str, Any]] = None,
         before: Optional[RunnableConfig] = None,
         limit: Optional[int] = None,
     ) -> AsyncIterator[CheckpointTuple]:

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

@@ -2,7 +2,7 @@ import asyncio
 import random
 from collections.abc import AsyncIterator, Iterator, Sequence
 from contextlib import asynccontextmanager
-from typing import Any, Callable, Optional, TypeVar, cast
+from typing import Any, Callable, Optional, TypeVar
 
 import aiosqlite
 from langchain_core.runnables import RunnableConfig
@@ -374,12 +374,7 @@ class AsyncSqliteSaver(BaseCheckpointSaver[str]):
                 return CheckpointTuple(
                     config,
                     self.serde.loads_typed((type, checkpoint)),
-                    cast(
-                        CheckpointMetadata,
-                        self.jsonplus_serde.loads(metadata)
-                        if metadata is not None
-                        else {},
-                    ),
+                    self.jsonplus_serde.loads(metadata) if metadata is not None else {},
                     (
                         {
                             "configurable": {
@@ -454,12 +449,7 @@ class AsyncSqliteSaver(BaseCheckpointSaver[str]):
                         }
                     },
                     self.serde.loads_typed((type, checkpoint)),
-                    cast(
-                        CheckpointMetadata,
-                        self.jsonplus_serde.loads(metadata)
-                        if metadata is not None
-                        else {},
-                    ),
+                    self.jsonplus_serde.loads(metadata) if metadata is not None else {},
                     (
                         {
                             "configurable": {

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

@@ -1,6 +1,5 @@
 import json
-from collections.abc import Sequence
-from typing import Any, Optional
+from typing import Any, Dict, Optional, Sequence, Tuple
 
 from langchain_core.runnables import RunnableConfig
 
@@ -8,8 +7,8 @@ from langgraph.checkpoint.base import get_checkpoint_id
 
 
 def _metadata_predicate(
-    metadata_filter: dict[str, Any],
-) -> tuple[Sequence[str], Sequence[Any]]:
+    metadata_filter: Dict[str, Any],
+) -> Tuple[Sequence[str], Sequence[Any]]:
     """Return WHERE clause predicates for (a)search() given metadata filter.
 
     This method returns a tuple of a string and a tuple of values. The string
@@ -18,7 +17,7 @@ def _metadata_predicate(
     for each of the corresponding parameters.
     """
 
-    def _where_value(query_value: Any) -> tuple[str, Any]:
+    def _where_value(query_value: Any) -> Tuple[str, Any]:
         """Return tuple of operator and value for WHERE clause predicate."""
         if query_value is None:
             return ("IS ?", None)
@@ -53,9 +52,9 @@ def _metadata_predicate(
 
 def search_where(
     config: Optional[RunnableConfig],
-    filter: Optional[dict[str, Any]],
+    filter: Optional[Dict[str, Any]],
     before: Optional[RunnableConfig] = None,
-) -> tuple[str, Sequence[Any]]:
+) -> Tuple[str, Sequence[Any]]:
     """Return WHERE clause predicates for (a)search() given metadata filter
     and `before` config.
 

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

@@ -1,4 +0,0 @@
-from langgraph.store.sqlite.aio import AsyncSqliteStore
-from langgraph.store.sqlite.base import SqliteStore
-
-__all__ = ["AsyncSqliteStore", "SqliteStore"]

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

@@ -1,582 +0,0 @@
-import asyncio
-import logging
-from collections import defaultdict
-from collections.abc import AsyncIterator, Iterable, Sequence
-from contextlib import asynccontextmanager
-from types import TracebackType
-from typing import Any, Callable, Optional, Union, cast
-
-import aiosqlite
-import orjson
-import sqlite_vec  # type: ignore[import-untyped]
-
-from langgraph.store.base import (
-    GetOp,
-    ListNamespacesOp,
-    Op,
-    PutOp,
-    Result,
-    SearchOp,
-    TTLConfig,
-)
-from langgraph.store.base.batch import AsyncBatchedBaseStore
-from langgraph.store.sqlite.base import (
-    _PLACEHOLDER,
-    BaseSqliteStore,
-    SqliteIndexConfig,
-    _decode_ns_text,
-    _ensure_index_config,
-    _group_ops,
-    _row_to_item,
-    _row_to_search_item,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class AsyncSqliteStore(AsyncBatchedBaseStore, BaseSqliteStore):
-    """Asynchronous SQLite-backed store with optional vector search.
-
-    This class provides an asynchronous interface for storing and retrieving data
-    using a SQLite database with support for vector search capabilities.
-
-    Examples:
-        Basic setup and usage:
-        ```python
-        from langgraph.store.sqlite import AsyncSqliteStore
-
-        async with AsyncSqliteStore.from_conn_string(":memory:") as store:
-            await store.setup()  # Run migrations
-
-            # 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_openai import OpenAIEmbeddings
-        from langgraph.store.sqlite import AsyncSqliteStore
-
-        async with AsyncSqliteStore.from_conn_string(
-            ":memory:",
-            index={
-                "dims": 1536,
-                "embed": OpenAIEmbeddings(),
-                "fields": ["text"]  # specify which fields to embed
-            }
-        ) as store:
-            await store.setup()  # Run migrations once
-
-            # Store documents
-            await store.aput(("docs",), "doc1", {"text": "Python tutorial"})
-            await store.aput(("docs",), "doc2", {"text": "TypeScript guide"})
-            await store.aput(("docs",), "doc3", {"text": "Other guide"}, index=False)  # don't index
-
-            # Search by similarity
-            results = await store.asearch(("docs",), query="programming guides", limit=2)
-        ```
-
-    Warning:
-        Make sure to call `setup()` before first use to create necessary tables and indexes.
-
-    Note:
-        This class requires the aiosqlite package. Install with `pip install aiosqlite`.
-    """
-
-    def __init__(
-        self,
-        conn: aiosqlite.Connection,
-        *,
-        deserializer: Optional[
-            Callable[[Union[bytes, str, orjson.Fragment]], dict[str, Any]]
-        ] = None,
-        index: Optional[SqliteIndexConfig] = None,
-        ttl: Optional[TTLConfig] = None,
-    ):
-        """Initialize the async SQLite store.
-
-        Args:
-            conn: The SQLite database connection.
-            deserializer: Optional custom deserializer function for values.
-            index: Optional vector search configuration.
-            ttl: Optional time-to-live configuration.
-        """
-        super().__init__()
-        self._deserializer = deserializer
-        self.conn = conn
-        self.lock = asyncio.Lock()
-        self.loop = asyncio.get_running_loop()
-        self.is_setup = False
-        self.index_config = index
-        if self.index_config:
-            self.embeddings, self.index_config = _ensure_index_config(self.index_config)
-        else:
-            self.embeddings = None
-        self.ttl_config = ttl
-        self._ttl_sweeper_task: Optional[asyncio.Task[None]] = None
-        self._ttl_stop_event = asyncio.Event()
-
-    @classmethod
-    @asynccontextmanager
-    async def from_conn_string(
-        cls,
-        conn_string: str,
-        *,
-        index: Optional[SqliteIndexConfig] = None,
-        ttl: Optional[TTLConfig] = None,
-    ) -> AsyncIterator["AsyncSqliteStore"]:
-        """Create a new AsyncSqliteStore instance from a connection string.
-
-        Args:
-            conn_string: The SQLite connection string.
-            index: Optional vector search configuration.
-            ttl: Optional time-to-live configuration.
-
-        Returns:
-            An AsyncSqliteStore instance wrapped in an async context manager.
-        """
-        async with aiosqlite.connect(conn_string, isolation_level=None) as conn:
-            yield cls(conn, index=index, ttl=ttl)
-
-    async def setup(self) -> None:
-        """Set up the store database.
-
-        This method creates the necessary tables in the SQLite database if they don't
-        already exist and runs database migrations. It should be called before first use.
-        """
-        async with self.lock:
-            if self.is_setup:
-                return
-
-            # Create migrations table if it doesn't exist
-            await self.conn.execute(
-                """
-                CREATE TABLE IF NOT EXISTS store_migrations (
-                    v INTEGER PRIMARY KEY
-                )
-                """
-            )
-
-            # Check current migration version
-            async with self.conn.execute(
-                "SELECT v FROM store_migrations ORDER BY v DESC LIMIT 1"
-            ) as cur:
-                row = await cur.fetchone()
-                if row is None:
-                    version = -1
-                else:
-                    version = row[0]
-
-            # Apply migrations
-            for v, sql in enumerate(self.MIGRATIONS[version + 1 :], start=version + 1):
-                await self.conn.executescript(sql)
-                await self.conn.execute(
-                    "INSERT INTO store_migrations (v) VALUES (?)", (v,)
-                )
-
-            # Apply vector migrations if index config is provided
-            if self.index_config:
-                # Create vector migrations table if it doesn't exist
-                await self.conn.enable_load_extension(True)
-                await self.conn.load_extension(sqlite_vec.loadable_path())
-                await self.conn.enable_load_extension(False)
-                await self.conn.execute(
-                    """
-                    CREATE TABLE IF NOT EXISTS vector_migrations (
-                        v INTEGER PRIMARY KEY
-                    )
-                    """
-                )
-
-                # Check current vector migration version
-                async with self.conn.execute(
-                    "SELECT v FROM vector_migrations ORDER BY v DESC LIMIT 1"
-                ) as cur:
-                    row = await cur.fetchone()
-                    if row is None:
-                        version = -1
-                    else:
-                        version = row[0]
-
-                # Apply vector migrations
-                for v, sql in enumerate(
-                    self.VECTOR_MIGRATIONS[version + 1 :], start=version + 1
-                ):
-                    await self.conn.executescript(sql)
-                    await self.conn.execute(
-                        "INSERT INTO vector_migrations (v) VALUES (?)", (v,)
-                    )
-
-            self.is_setup = True
-
-    @asynccontextmanager
-    async def _cursor(
-        self, *, transaction: bool = True
-    ) -> AsyncIterator[aiosqlite.Cursor]:
-        """Get a cursor for the SQLite database.
-
-        Args:
-            transaction: Whether to use a transaction for database operations.
-
-        Yields:
-            An SQLite cursor object.
-        """
-        async with self.lock:
-            if not self.is_setup:
-                await self.setup()
-
-            if transaction:
-                await self.conn.execute("BEGIN")
-
-            async with self.conn.cursor() as cur:
-                try:
-                    yield cur
-                finally:
-                    if transaction:
-                        await self.conn.execute("COMMIT")
-
-    async def sweep_ttl(self) -> int:
-        """Delete expired store items based on TTL.
-
-        Returns:
-            int: The number of deleted items.
-        """
-        async with self._cursor() as cur:
-            await cur.execute(
-                """
-                DELETE FROM store
-                WHERE expires_at IS NOT NULL AND expires_at < CURRENT_TIMESTAMP
-                """
-            )
-            deleted_count = cur.rowcount
-            return deleted_count
-
-    async def start_ttl_sweeper(
-        self, sweep_interval_minutes: Optional[int] = None
-    ) -> asyncio.Task[None]:
-        """Periodically delete expired store items based on TTL.
-
-        Returns:
-            Task that can be awaited or cancelled.
-        """
-        if not self.ttl_config:
-            return asyncio.create_task(asyncio.sleep(0))
-
-        if self._ttl_sweeper_task is not None and not self._ttl_sweeper_task.done():
-            return self._ttl_sweeper_task
-
-        self._ttl_stop_event.clear()
-
-        interval = float(
-            sweep_interval_minutes or self.ttl_config.get("sweep_interval_minutes") or 5
-        )
-        logger.info(f"Starting store TTL sweeper with interval {interval} minutes")
-
-        async def _sweep_loop() -> None:
-            while not self._ttl_stop_event.is_set():
-                try:
-                    try:
-                        await asyncio.wait_for(
-                            self._ttl_stop_event.wait(),
-                            timeout=interval * 60,
-                        )
-                        break
-                    except asyncio.TimeoutError:
-                        pass
-
-                    expired_items = await self.sweep_ttl()
-                    if expired_items > 0:
-                        logger.info(f"Store swept {expired_items} expired items")
-                except asyncio.CancelledError:
-                    break
-                except Exception as exc:
-                    logger.exception("Store TTL sweep iteration failed", exc_info=exc)
-
-        task = asyncio.create_task(_sweep_loop())
-        task.set_name("ttl_sweeper")
-        self._ttl_sweeper_task = task
-        return task
-
-    async def stop_ttl_sweeper(self, timeout: Optional[float] = None) -> bool:
-        """Stop the TTL sweeper task if it's running.
-
-        Args:
-            timeout: Maximum time to wait for the task to stop, in seconds.
-                If None, wait indefinitely.
-
-        Returns:
-            bool: True if the task was successfully stopped or wasn't running,
-                False if the timeout was reached before the task stopped.
-        """
-        if self._ttl_sweeper_task is None or self._ttl_sweeper_task.done():
-            return True
-
-        logger.info("Stopping TTL sweeper task")
-        self._ttl_stop_event.set()
-
-        if timeout is not None:
-            try:
-                await asyncio.wait_for(self._ttl_sweeper_task, timeout=timeout)
-                success = True
-            except asyncio.TimeoutError:
-                success = False
-        else:
-            await self._ttl_sweeper_task
-            success = True
-
-        if success:
-            self._ttl_sweeper_task = None
-            logger.info("TTL sweeper task stopped")
-        else:
-            logger.warning("Timed out waiting for TTL sweeper task to stop")
-
-        return success
-
-    async def __aenter__(self) -> "AsyncSqliteStore":
-        return self
-
-    async def __aexit__(
-        self,
-        exc_type: Optional[type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional["TracebackType"],
-    ) -> None:
-        # Ensure the TTL sweeper task is stopped when exiting the context
-        if hasattr(self, "_ttl_sweeper_task") and self._ttl_sweeper_task is not None:
-            # Set the event to signal the task to stop
-            self._ttl_stop_event.set()
-            # We don't wait for the task to complete here to avoid blocking
-            # The task will clean up itself gracefully
-
-    async def abatch(self, ops: Iterable[Op]) -> list[Result]:
-        """Execute a batch of operations asynchronously.
-
-        Args:
-            ops: Iterable of operations to execute.
-
-        Returns:
-            List of operation results.
-        """
-        grouped_ops, num_ops = _group_ops(ops)
-        results: list[Result] = [None] * num_ops
-
-        async with self._cursor(transaction=True) as cur:
-            if GetOp in grouped_ops:
-                await self._batch_get_ops(
-                    cast(Sequence[tuple[int, GetOp]], grouped_ops[GetOp]), results, cur
-                )
-
-            if SearchOp in grouped_ops:
-                await self._batch_search_ops(
-                    cast(Sequence[tuple[int, SearchOp]], grouped_ops[SearchOp]),
-                    results,
-                    cur,
-                )
-
-            if ListNamespacesOp in grouped_ops:
-                await self._batch_list_namespaces_ops(
-                    cast(
-                        Sequence[tuple[int, ListNamespacesOp]],
-                        grouped_ops[ListNamespacesOp],
-                    ),
-                    results,
-                    cur,
-                )
-
-            if PutOp in grouped_ops:
-                await self._batch_put_ops(
-                    cast(Sequence[tuple[int, PutOp]], grouped_ops[PutOp]), cur
-                )
-
-        return results
-
-    async def _batch_get_ops(
-        self,
-        get_ops: Sequence[tuple[int, GetOp]],
-        results: list[Result],
-        cur: aiosqlite.Cursor,
-    ) -> None:
-        """Process batch GET operations.
-
-        Args:
-            get_ops: Sequence of GET operations.
-            results: List to store results in.
-            cur: Database cursor.
-        """
-        # Group all queries by namespace to execute all operations for each namespace together
-        namespace_queries = defaultdict(list)
-        for prepared_query in self._get_batch_GET_ops_queries(get_ops):
-            namespace_queries[prepared_query.namespace].append(prepared_query)
-
-        # Process each namespace's operations
-        for namespace, queries in namespace_queries.items():
-            # Execute TTL refresh queries first
-            for query in queries:
-                if query.kind == "refresh":
-                    try:
-                        await cur.execute(query.query, query.params)
-                    except Exception as e:
-                        raise ValueError(
-                            f"Error executing TTL refresh: \n{query.query}\n{query.params}\n{e}"
-                        ) from e
-
-            # Then execute GET queries and process results
-            for query in queries:
-                if query.kind == "get":
-                    try:
-                        await cur.execute(query.query, query.params)
-                    except Exception as e:
-                        raise ValueError(
-                            f"Error executing GET query: \n{query.query}\n{query.params}\n{e}"
-                        ) from e
-
-                    rows = await cur.fetchall()
-                    key_to_row = {
-                        row[0]: {
-                            "key": row[0],
-                            "value": row[1],
-                            "created_at": row[2],
-                            "updated_at": row[3],
-                            "expires_at": row[4] if len(row) > 4 else None,
-                            "ttl_minutes": row[5] if len(row) > 5 else None,
-                        }
-                        for row in rows
-                    }
-
-                    # Process results for this query
-                    for idx, key in query.items:
-                        row = key_to_row.get(key)
-                        if row:
-                            results[idx] = _row_to_item(
-                                namespace, row, loader=self._deserializer
-                            )
-                        else:
-                            results[idx] = None
-
-    async def _batch_put_ops(
-        self,
-        put_ops: Sequence[tuple[int, PutOp]],
-        cur: aiosqlite.Cursor,
-    ) -> None:
-        """Process batch PUT operations.
-
-        Args:
-            put_ops: Sequence of PUT operations.
-            cur: Database cursor.
-        """
-        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 = await self.embeddings.aembed_documents(
-                [param[-1] for param in txt_params]
-            )
-
-            # Convert vectors to SQLite-friendly format
-            vector_params = []
-            for (ns, k, pathname, _), vector in zip(txt_params, vectors):
-                vector_params.extend(
-                    [ns, k, pathname, sqlite_vec.serialize_float32(vector)]
-                )
-
-            queries.append((query, vector_params))
-
-        for query, params in queries:
-            await cur.execute(query, params)
-
-    async def _batch_search_ops(
-        self,
-        search_ops: Sequence[tuple[int, SearchOp]],
-        results: list[Result],
-        cur: aiosqlite.Cursor,
-    ) -> None:
-        """Process batch SEARCH operations.
-
-        Args:
-            search_ops: Sequence of SEARCH operations.
-            results: List to store results in.
-            cur: Database cursor.
-        """
-        queries, embedding_requests = self._prepare_batch_search_queries(search_ops)
-
-        # Setup dot_product function if it doesn't exist
-        if embedding_requests and self.embeddings:
-            vectors = await self.embeddings.aembed_documents(
-                [query for _, query in embedding_requests]
-            )
-
-            for (idx, _), embedding in zip(embedding_requests, vectors):
-                _params_list: list = queries[idx][1]
-                for i, param in enumerate(_params_list):
-                    if param is _PLACEHOLDER:
-                        _params_list[i] = sqlite_vec.serialize_float32(embedding)
-
-        for (idx, _), (query, params) in zip(search_ops, queries):
-            await cur.execute(query, params)
-            rows = await cur.fetchall()
-
-            if "score" in query:
-                items = [
-                    _row_to_search_item(
-                        _decode_ns_text(row[0]),
-                        {
-                            "key": row[1],
-                            "value": row[2],
-                            "created_at": row[3],
-                            "updated_at": row[4],
-                            "expires_at": row[5] if len(row) > 5 else None,
-                            "ttl_minutes": row[6] if len(row) > 6 else None,
-                            "score": row[7] if len(row) > 7 else None,
-                        },
-                        loader=self._deserializer,
-                    )
-                    for row in rows
-                ]
-            else:  # Regular search query
-                items = [
-                    _row_to_search_item(
-                        _decode_ns_text(row[0]),
-                        {
-                            "key": row[1],
-                            "value": row[2],
-                            "created_at": row[3],
-                            "updated_at": row[4],
-                            "expires_at": row[5] if len(row) > 5 else None,
-                            "ttl_minutes": row[6] if len(row) > 6 else None,
-                        },
-                        loader=self._deserializer,
-                    )
-                    for row in rows
-                ]
-
-            results[idx] = items
-
-    async def _batch_list_namespaces_ops(
-        self,
-        list_ops: Sequence[tuple[int, ListNamespacesOp]],
-        results: list[Result],
-        cur: aiosqlite.Cursor,
-    ) -> None:
-        """Process batch LIST NAMESPACES operations.
-
-        Args:
-            list_ops: Sequence of LIST NAMESPACES operations.
-            results: List to store results in.
-            cur: Database cursor.
-        """
-        queries = self._get_batch_list_namespaces_queries(list_ops)
-        for (query, params), (idx, _) in zip(queries, list_ops):
-            await cur.execute(query, params)
-
-            rows = await cur.fetchall()
-            results[idx] = [_decode_ns_text(row[0]) for row in rows]

libs/checkpoint-sqlite/pyproject.toml

@@ -1,51 +1,43 @@
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[project]
+[tool.poetry]
 name = "langgraph-checkpoint-sqlite"
-version = "2.0.10"
+version = "2.0.7"
 description = "Library with a SQLite implementation of LangGraph checkpoint saver."
 authors = []
-requires-python = ">=3.9"
-readme = "README.md"
 license = "MIT"
-license-files = ['LICENSE']
-dependencies = [
-    "langgraph-checkpoint>=2.0.21",
-    "aiosqlite>=0.20",
-    "sqlite-vec>=0.1.6",
-]
+readme = "README.md"
+repository = "https://www.github.com/langchain-ai/langgraph"
+packages = [{ include = "langgraph" }]
 
-[project.urls]
-Repository = "https://www.github.com/langchain-ai/langgraph"
+[tool.poetry.dependencies]
+python = ">=3.9"
+langgraph-checkpoint = "^2.0.15"
+aiosqlite = ">=0.20,<0.22"
 
-[dependency-groups]
-dev = [
-  "ruff",
-  "codespell",
-  "pytest",
-  "pytest-asyncio",
-  "pytest-mock",
-  "pytest-watcher",
-  "mypy",
-  "langgraph-checkpoint",
-  "pytest-retry>=1.7.0",
-]
-
-[tool.uv]
-default-groups = ['dev']
-
-[tool.uv.sources]
-langgraph-checkpoint = { path = "../checkpoint", editable = true }
-
-[tool.hatch.build.targets.wheel]
-include = ["langgraph"]
+[tool.poetry.group.dev.dependencies]
+ruff = "^0.6.2"
+codespell = "^2.2.0"
+pytest = "^7.2.1"
+pytest-asyncio = "^0.21.1"
+pytest-mock = "^3.11.1"
+pytest-watcher = { version = ">=0.4.1", python = "<4.0" }
+mypy = "^1.10.0"
+langgraph-checkpoint = {path = "../checkpoint", develop = true}
 
 [tool.pytest.ini_options]
+# --strict-markers will raise errors on unknown marks.
+# https://docs.pytest.org/en/7.1.x/how-to/mark.html#raising-errors-on-unknown-marks
+#
+# https://docs.pytest.org/en/7.1.x/reference/reference.html
+# --strict-config       any warnings encountered while parsing the `pytest`
+#                       section of the configuration file raise errors.
 addopts = "--strict-markers --strict-config --durations=5 -vv"
 asyncio_mode = "auto"
 
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
 [tool.ruff]
 lint.select = [
   "E",  # pycodestyle

libs/checkpoint-sqlite/tests/test_aiosqlite.py

@@ -59,7 +59,7 @@ class TestAsyncSqliteSaver:
 
     async def test_combined_metadata(self) -> None:
         async with AsyncSqliteSaver.from_conn_string(":memory:") as saver:
-            config: RunnableConfig = {
+            config = {
                 "configurable": {
                     "thread_id": "thread-2",
                     "checkpoint_ns": "",
@@ -69,7 +69,7 @@ class TestAsyncSqliteSaver:
             }
             await saver.aput(config, self.chkpnt_2, self.metadata_2, {})
             checkpoint = await saver.aget_tuple(config)
-            assert checkpoint is not None and checkpoint.metadata == {
+            assert checkpoint.metadata == {
                 **self.metadata_2,
                 "thread_id": "thread-2",
                 "run_id": "my_run_id",

libs/checkpoint-sqlite/tests/test_async_store.py

@@ -1,719 +0,0 @@
-# mypy: disable-error-code="union-attr,arg-type,index,operator"
-import asyncio
-import os
-import tempfile
-import uuid
-from collections.abc import AsyncIterator, Generator, Iterable
-from contextlib import asynccontextmanager
-from typing import Optional, Union, cast
-
-import pytest
-
-from langgraph.store.base import (
-    GetOp,
-    Item,
-    ListNamespacesOp,
-    PutOp,
-    SearchOp,
-)
-from langgraph.store.sqlite import AsyncSqliteStore
-from langgraph.store.sqlite.base import SqliteIndexConfig
-from tests.test_store import CharacterEmbeddings
-
-
-@pytest.fixture(scope="function", params=["memory", "file"])
-async def store(request: pytest.FixtureRequest) -> AsyncIterator[AsyncSqliteStore]:
-    """Create an AsyncSqliteStore for testing."""
-    if request.param == "memory":
-        # In-memory store
-        async with AsyncSqliteStore.from_conn_string(":memory:") as store:
-            await store.setup()
-            yield store
-    else:
-        # Temporary file store
-        temp_file = tempfile.NamedTemporaryFile(delete=False)
-        temp_file.close()
-        try:
-            async with AsyncSqliteStore.from_conn_string(temp_file.name) as store:
-                await store.setup()
-                yield store
-        finally:
-            os.unlink(temp_file.name)
-
-
-@pytest.fixture(scope="function")
-def fake_embeddings() -> CharacterEmbeddings:
-    """Create fake embeddings for testing."""
-    return CharacterEmbeddings(dims=500)
-
-
-@asynccontextmanager
-async def create_vector_store(
-    fake_embeddings: CharacterEmbeddings,
-    conn_string: str = ":memory:",
-    text_fields: Optional[list[str]] = None,
-) -> AsyncIterator[AsyncSqliteStore]:
-    """Create an AsyncSqliteStore with vector search capabilities."""
-    index_config: SqliteIndexConfig = {
-        "dims": fake_embeddings.dims,
-        "embed": fake_embeddings,
-        "text_fields": text_fields,
-    }
-
-    async with AsyncSqliteStore.from_conn_string(
-        conn_string, index=index_config
-    ) as store:
-        await store.setup()
-        yield store
-
-
-@pytest.fixture(scope="function", params=["memory", "file"])
-def conn_string(request: pytest.FixtureRequest) -> Generator[str, None, None]:
-    if request.param == "memory":
-        yield ":memory:"
-    else:
-        temp_file = tempfile.NamedTemporaryFile(delete=False)
-        temp_file.close()
-        try:
-            yield temp_file.name
-        finally:
-            os.unlink(temp_file.name)
-
-
-async def test_no_running_loop(store: AsyncSqliteStore) -> None:
-    """Test that sync methods raise proper errors in the main thread."""
-    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"})])
-
-
-async def test_large_batches_async(store: AsyncSqliteStore) -> None:
-    """Test processing large batch operations asynchronously."""
-    N = 100
-    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(
-                asyncio.create_task(
-                    store.aget(
-                        ("test", "foo", "bar", "baz", str(m % 2)),
-                        f"key{i}",
-                    )
-                )
-            )
-            coros.append(
-                asyncio.create_task(
-                    store.alist_namespaces(
-                        prefix=None,
-                        max_depth=m + 1,
-                    )
-                )
-            )
-            coros.append(
-                asyncio.create_task(
-                    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: AsyncSqliteStore) -> None:
-    """Test ordering of batch operations in async context."""
-    # Setup test data
-    await store.aput(("test", "foo"), "key1", {"data": "value1"})
-    await store.aput(("test", "bar"), "key2", {"data": "value2"})
-
-    ops = [
-        GetOp(namespace=("test", "foo"), key="key1"),
-        PutOp(namespace=("test", "bar"), key="key2", value={"data": "value2"}),
-        SearchOp(
-            namespace_prefix=("test",), filter={"data": "value1"}, limit=10, offset=0
-        ),
-        ListNamespacesOp(match_conditions=None, max_depth=None, limit=10, offset=0),
-        GetOp(namespace=("test",), key="key3"),
-    ]
-
-    results = await store.abatch(
-        cast(Iterable[Union[GetOp, PutOp, SearchOp, ListNamespacesOp]], ops)
-    )
-    assert len(results) == 5
-    assert isinstance(results[0], Item)
-    assert isinstance(results[0].value, dict)
-    assert results[0].value == {"data": "value1"}
-    assert results[0].key == "key1"
-    assert results[1] is None  # Put operation returns None
-    assert isinstance(results[2], list)
-    # SQLite query implementation might return different results
-    # Just check that we get a list back and don't check the exact content
-    assert isinstance(results[3], list)
-    assert len(results[3]) > 0
-    assert results[4] is None  # Non-existent key returns None
-
-    # Test reordered operations
-    ops_reordered = [
-        SearchOp(namespace_prefix=("test",), filter=None, limit=5, offset=0),
-        GetOp(namespace=("test", "bar"), key="key2"),
-        ListNamespacesOp(match_conditions=None, max_depth=None, limit=5, offset=0),
-        PutOp(namespace=("test",), key="key3", value={"data": "value3"}),
-        GetOp(namespace=("test", "foo"), key="key1"),
-    ]
-
-    results_reordered = await store.abatch(
-        cast(Iterable[Union[GetOp, PutOp, SearchOp, ListNamespacesOp]], ops_reordered)
-    )
-    assert len(results_reordered) == 5
-    assert isinstance(results_reordered[0], list)
-    assert len(results_reordered[0]) >= 2  # Should find at least our two test items
-    assert isinstance(results_reordered[1], Item)
-    assert results_reordered[1].value == {"data": "value2"}
-    assert results_reordered[1].key == "key2"
-    assert isinstance(results_reordered[2], list)
-    assert len(results_reordered[2]) > 0
-    assert results_reordered[3] is None  # Put operation returns None
-    assert isinstance(results_reordered[4], Item)
-    assert results_reordered[4].value == {"data": "value1"}
-    assert results_reordered[4].key == "key1"
-
-
-async def test_batch_get_ops(store: AsyncSqliteStore) -> None:
-    """Test GET operations in batch context."""
-    # Setup test data
-    await store.aput(("test",), "key1", {"data": "value1"})
-    await store.aput(("test",), "key2", {"data": "value2"})
-
-    ops = [
-        GetOp(namespace=("test",), key="key1"),
-        GetOp(namespace=("test",), key="key2"),
-        GetOp(namespace=("test",), key="key3"),  # Non-existent key
-    ]
-
-    results = await store.abatch(ops)
-
-    assert len(results) == 3
-    assert results[0] is not None
-    assert results[1] is not None
-    assert results[2] is None
-    if results[0] is not None:
-        assert results[0].key == "key1"
-    if results[1] is not None:
-        assert results[1].key == "key2"
-
-
-async def test_batch_put_ops(store: AsyncSqliteStore) -> None:
-    """Test PUT operations in batch context."""
-    ops = [
-        PutOp(namespace=("test",), key="key1", value={"data": "value1"}),
-        PutOp(namespace=("test",), key="key2", value={"data": "value2"}),
-        PutOp(namespace=("test",), key="key3", value=None),  # Delete operation
-    ]
-
-    results = await store.abatch(ops)
-    assert len(results) == 3
-    assert all(result is None for result in results)
-
-    # Verify the puts worked
-    items = await store.asearch(("test",), limit=10)
-    assert len(items) == 2  # key3 had None value so wasn't stored
-
-
-async def test_batch_search_ops(store: AsyncSqliteStore) -> None:
-    """Test SEARCH operations in batch context."""
-    # Setup test data
-    await store.aput(("test", "foo"), "key1", {"data": "value1"})
-    await store.aput(("test", "bar"), "key2", {"data": "value2"})
-
-    ops = [
-        SearchOp(
-            namespace_prefix=("test",), filter={"data": "value1"}, limit=10, offset=0
-        ),
-        SearchOp(namespace_prefix=("test",), filter=None, limit=5, offset=0),
-    ]
-
-    results = await store.abatch(ops)
-
-    assert len(results) == 2
-    # SQLite query implementation might return different results
-    # Just check that we get lists back and don't check the exact content
-    assert isinstance(results[0], list)
-    assert isinstance(results[1], list)
-    assert len(results[1]) >= 1  # We should at least find some results
-
-
-async def test_batch_list_namespaces_ops(store: AsyncSqliteStore) -> None:
-    """Test LIST NAMESPACES operations in batch context."""
-    # Setup test data
-    await store.aput(("test", "namespace1"), "key1", {"data": "value1"})
-    await store.aput(("test", "namespace2"), "key2", {"data": "value2"})
-
-    ops = [ListNamespacesOp(match_conditions=None, max_depth=None, limit=10, offset=0)]
-
-    results = await store.abatch(ops)
-
-    assert len(results) == 1
-    if isinstance(results[0], list):
-        assert len(results[0]) == 2
-        assert ("test", "namespace1") in results[0]
-        assert ("test", "namespace2") in results[0]
-
-
-async def test_vector_store_initialization(
-    fake_embeddings: CharacterEmbeddings,
-) -> None:
-    """Test store initialization with embedding config."""
-    async with create_vector_store(fake_embeddings) as store:
-        assert store.index_config is not None
-        assert store.index_config["dims"] == fake_embeddings.dims
-        if hasattr(store.index_config.get("embed"), "embed_documents"):
-            assert store.index_config["embed"] == fake_embeddings
-
-
-async def test_vector_insert_with_auto_embedding(
-    fake_embeddings: CharacterEmbeddings,
-    conn_string: str,
-) -> None:
-    """Test inserting items that get auto-embedded."""
-    async with create_vector_store(fake_embeddings, conn_string=conn_string) as store:
-        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
-
-
-async def test_vector_update_with_embedding(
-    fake_embeddings: CharacterEmbeddings,
-    conn_string: str,
-) -> None:
-    """Test that updating items properly updates their embeddings."""
-    async with create_vector_store(fake_embeddings, conn_string=conn_string) as store:
-        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].score is not None
-        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
-            and initial_score is not None
-            and 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
-                    and after_score is not None
-                    and 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)
-
-
-async def test_vector_search_with_filters(
-    fake_embeddings: CharacterEmbeddings,
-    conn_string: str,
-) -> None:
-    """Test combining vector search with filters."""
-    async with create_vector_store(fake_embeddings, conn_string=conn_string) as store:
-        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)
-
-        # Vector search with filters can be inconsistent in test environments
-        # Skip asserting exact results as we've already validated the functionality
-        # in the synchronous tests
-        _ = await store.asearch(("test",), query="apple", filter={"color": "red"})
-
-        # Skip asserting exact results as we've already validated the functionality
-        # in the synchronous tests
-        _ = await store.asearch(("test",), query="car", filter={"color": "red"})
-
-        # Skip asserting exact results as we've already validated the functionality
-        # in the synchronous tests
-        _ = await store.asearch(
-            ("test",), query="bbbbluuu", filter={"score": {"$gt": 3.2}}
-        )
-
-        # Skip asserting exact results as we've already validated the functionality
-        # in the synchronous tests
-        _ = await store.asearch(
-            ("test",), query="apple", filter={"score": {"$gte": 4.0}, "color": "green"}
-        )
-
-
-async def test_vector_search_pagination(fake_embeddings: CharacterEmbeddings) -> None:
-    """Test pagination with vector search."""
-    async with create_vector_store(fake_embeddings) as store:
-        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_vector_search_edge_cases(fake_embeddings: CharacterEmbeddings) -> None:
-    """Test edge cases in vector search."""
-    async with create_vector_store(fake_embeddings) as store:
-        await store.aput(("test",), "doc1", {"text": "test document"})
-
-        results = await store.asearch(("test",), query="")
-        assert len(results) == 1
-
-        results = await store.asearch(("test",), query=None)
-        assert len(results) == 1
-
-        long_query = "test " * 100
-        results = await store.asearch(("test",), query=long_query)
-        assert len(results) == 1
-
-        special_query = "test!@#$%^&*()"
-        results = await store.asearch(("test",), query=special_query)
-        assert len(results) == 1
-
-
-async def test_embed_with_path(
-    fake_embeddings: CharacterEmbeddings,
-) -> None:
-    """Test vector search with specific text fields in SQLite store."""
-    async with create_vector_store(
-        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)
-
-        # 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
-        assert results[0].score > 0.9
-        assert results[1].score > 0.9
-
-        # ~Only match doc2
-        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
-
-        # 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 < 0.9
-        assert results[1].score < 0.9
-
-
-async def test_basic_store_ops(
-    fake_embeddings: CharacterEmbeddings,
-) -> None:
-    """Test vector search with specific text fields in SQLite store."""
-    async with create_vector_store(
-        fake_embeddings, text_fields=["key0", "key1", "key3"]
-    ) as store:
-        uid = uuid.uuid4().hex
-        namespace = (uid, "test", "documents")
-        item_id = "doc1"
-        item_value = {"title": "Test Document", "content": "Hello, World!"}
-        results = await store.asearch((uid,))
-        assert len(results) == 0
-
-        await store.aput(namespace, item_id, item_value)
-        item = await store.aget(namespace, item_id)
-
-        assert item is not None
-        assert item.namespace == namespace
-        assert item.key == item_id
-        assert item.value == item_value
-        assert item.created_at is not None
-        assert item.updated_at is not None
-
-        updated_value = {
-            "title": "Updated Test Document",
-            "content": "Hello, LangGraph!",
-        }
-        await asyncio.sleep(1.01)
-        await store.aput(namespace, item_id, updated_value)
-        updated_item = await store.aget(namespace, item_id)
-        assert updated_item is not None
-
-        assert updated_item.value == updated_value
-        assert updated_item.updated_at > item.updated_at
-        different_namespace = (uid, "test", "other_documents")
-        item_in_different_namespace = await store.aget(different_namespace, item_id)
-        assert item_in_different_namespace is None
-
-        new_item_id = "doc2"
-        new_item_value = {"title": "Another Document", "content": "Greetings!"}
-        await store.aput(namespace, new_item_id, new_item_value)
-
-        items = await store.asearch((uid, "test"), limit=10)
-        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)
-
-        namespaces = await store.alist_namespaces(prefix=(uid, "test"))
-        assert (uid, "test", "documents") in namespaces
-
-        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
-
-        empty_search_results = await store.asearch((uid, "test"), limit=10)
-        assert len(empty_search_results) == 0
-
-
-async def test_list_namespaces(
-    fake_embeddings: CharacterEmbeddings,
-) -> None:
-    """Test list namespaces functionality with various filters."""
-    async with create_vector_store(
-        fake_embeddings, text_fields=["key0", "key1", "key3"]
-    ) 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),
-        ]
-
-        # Add test data
-        for namespace in test_namespaces:
-            await store.aput(namespace, "dummy", {"content": "dummy"})
-
-        # Test prefix filtering
-        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)
-
-        # Test specific prefix
-        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)
-
-        # Test suffix filtering
-        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)
-
-        # Test combined prefix and suffix
-        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
-        )
-
-        # Test wildcard in prefix
-        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)
-
-        # Test wildcard in suffix
-        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,
-        )
-
-        # Test max depth
-        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(res for res in max_depth_result)) == len(max_depth_result) == 5
-
-        # Test pagination
-        limit_result = await store.alist_namespaces(prefix=(test_pref,), limit=3)
-        assert len(limit_result) == 3
-
-        offset_result = await store.alist_namespaces(prefix=(test_pref,), offset=3)
-        assert len(offset_result) == len(test_namespaces) - 3
-
-        empty_prefix_result = await store.alist_namespaces(prefix=(test_pref,))
-        assert len(empty_prefix_result) == len(test_namespaces)
-        assert set(empty_prefix_result) == set(test_namespaces)
-
-        # Clean up
-        for namespace in test_namespaces:
-            await store.adelete(namespace, "dummy")
-
-
-async def test_search_items(
-    fake_embeddings: CharacterEmbeddings,
-) -> None:
-    """Test search_items functionality by calling store methods directly."""
-    base = "test_search_items"
-    test_namespaces = [
-        (base, "documents", "user1"),
-        (base, "documents", "user2"),
-        (base, "reports", "department1"),
-        (base, "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"]},
-    ]
-
-    async with create_vector_store(
-        fake_embeddings, text_fields=["key0", "key1", "key3"]
-    ) as store:
-        # Insert test data
-        for ns, item in zip(test_namespaces, test_items):
-            key = f"item_{ns[-1]}"
-            await store.aput(ns, key, item)
-
-        # 1. Search documents
-        docs = await store.asearch((base, "documents"))
-        assert len(docs) == 2
-        assert all(item.namespace[1] == "documents" for item in docs)
-
-        # 2. Search reports
-        reports = await store.asearch((base, "reports"))
-        assert len(reports) == 2
-        assert all(item.namespace[1] == "reports" for item in reports)
-
-        # 3. Pagination
-        first_page = await store.asearch((base,), limit=2, offset=0)
-        second_page = await store.asearch((base,), limit=2, offset=2)
-        assert len(first_page) == 2
-        assert len(second_page) == 2
-        keys_page1 = {item.key for item in first_page}
-        keys_page2 = {item.key for item in second_page}
-        assert keys_page1.isdisjoint(keys_page2)
-        all_items = await store.asearch((base,))
-        assert len(all_items) == 4
-
-        john_items = await store.asearch((base,), filter={"author": "John Doe"})
-        assert len(john_items) == 2
-        assert all(item.value["author"] == "John Doe" for item in john_items)
-
-        draft_items = await store.asearch((base,), filter={"tags": ["draft"]})
-        assert len(draft_items) == 2
-        assert all("draft" in item.value["tags"] for item in draft_items)
-
-        for ns in test_namespaces:
-            key = f"item_{ns[-1]}"
-            await store.adelete(ns, key)

libs/checkpoint-sqlite/tests/test_sqlite.py

@@ -60,7 +60,7 @@ class TestSqliteSaver:
 
     def test_combined_metadata(self) -> None:
         with SqliteSaver.from_conn_string(":memory:") as saver:
-            config: RunnableConfig = {
+            config = {
                 "configurable": {
                     "thread_id": "thread-2",
                     "checkpoint_ns": "",
@@ -70,7 +70,7 @@ class TestSqliteSaver:
             }
             saver.put(config, self.chkpnt_2, self.metadata_2, {})
             checkpoint = saver.get_tuple(config)
-            assert checkpoint is not None and checkpoint.metadata == {
+            assert checkpoint.metadata == {
                 **self.metadata_2,
                 "thread_id": "thread-2",
                 "run_id": "my_run_id",

libs/checkpoint-sqlite/tests/test_ttl.py

@@ -1,355 +0,0 @@
-"""Test SQLite store Time-To-Live (TTL) functionality."""
-
-import asyncio
-import os
-import tempfile
-import time
-from collections.abc import Generator
-
-import pytest
-
-from langgraph.store.sqlite import SqliteStore
-from langgraph.store.sqlite.aio import AsyncSqliteStore
-
-
-@pytest.fixture
-def temp_db_file() -> Generator[str, None, None]:
-    """Create a temporary database file for testing."""
-    fd, path = tempfile.mkstemp()
-    os.close(fd)
-    yield path
-    os.unlink(path)
-
-
-def test_ttl_basic(temp_db_file: str) -> None:
-    """Test basic TTL functionality with synchronous API."""
-    ttl_seconds = 1
-    ttl_minutes = ttl_seconds / 60
-
-    with SqliteStore.from_conn_string(
-        temp_db_file, ttl={"default_ttl": ttl_minutes}
-    ) as store:
-        store.setup()
-
-        store.put(("test",), "item1", {"value": "test"})
-
-        item = store.get(("test",), "item1")
-        assert item is not None
-        assert item.value["value"] == "test"
-
-        time.sleep(ttl_seconds + 1.0)
-
-        store.sweep_ttl()
-
-        item = store.get(("test",), "item1")
-        assert item is None
-
-
-@pytest.mark.flaky(retries=3)
-def test_ttl_refresh(temp_db_file: str) -> None:
-    """Test TTL refresh on read."""
-    ttl_seconds = 1
-    ttl_minutes = ttl_seconds / 60
-
-    with SqliteStore.from_conn_string(
-        temp_db_file, ttl={"default_ttl": ttl_minutes, "refresh_on_read": True}
-    ) as store:
-        store.setup()
-
-        # Store an item with TTL
-        store.put(("test",), "item1", {"value": "test"})
-
-        # Sleep almost to expiration
-        time.sleep(ttl_seconds - 0.5)
-        swept = store.sweep_ttl()
-        assert swept == 0
-
-        # Get the item and refresh TTL
-        item = store.get(("test",), "item1", refresh_ttl=True)
-        assert item is not None
-
-        time.sleep(ttl_seconds - 0.5)
-        swept = store.sweep_ttl()
-        assert swept == 0
-
-        # Get the item, should still be there
-        item = store.get(("test",), "item1")
-        assert item is not None
-        assert item.value["value"] == "test"
-
-        # Sleep again but don't refresh this time
-        time.sleep(ttl_seconds + 0.75)
-
-        swept = store.sweep_ttl()
-        assert swept == 1
-
-        # Item should be gone now
-        item = store.get(("test",), "item1")
-        assert item is None
-
-
-def test_ttl_sweeper(temp_db_file: str) -> None:
-    """Test TTL sweeper thread."""
-    ttl_seconds = 2
-    ttl_minutes = ttl_seconds / 60
-
-    with SqliteStore.from_conn_string(
-        temp_db_file,
-        ttl={"default_ttl": ttl_minutes, "sweep_interval_minutes": ttl_minutes / 2},
-    ) as store:
-        store.setup()
-
-        # Start the TTL sweeper
-        store.start_ttl_sweeper()
-
-        # Store an item with TTL
-        store.put(("test",), "item1", {"value": "test"})
-
-        # Item should be there initially
-        item = store.get(("test",), "item1")
-        assert item is not None
-
-        # Wait for TTL to expire and the sweeper to run
-        time.sleep(ttl_seconds + (ttl_seconds / 2) + 0.5)
-
-        # Item should be gone now (swept automatically)
-        item = store.get(("test",), "item1")
-        assert item is None
-
-        # Stop the sweeper
-        store.stop_ttl_sweeper()
-
-
-@pytest.mark.flaky(retries=3)
-def test_ttl_custom_value(temp_db_file: str) -> None:
-    """Test TTL with custom value per item."""
-    with SqliteStore.from_conn_string(temp_db_file) as store:
-        store.setup()
-
-        # Store items with different TTLs
-        store.put(("test",), "item1", {"value": "short"}, ttl=1 / 60)  # 1 second
-        store.put(("test",), "item2", {"value": "long"}, ttl=3 / 60)  # 3 seconds
-
-        # Item with short TTL
-        time.sleep(2)  # Wait for short TTL
-        store.sweep_ttl()
-
-        # Short TTL item should be gone, long TTL item should remain
-        item1 = store.get(("test",), "item1")
-        item2 = store.get(("test",), "item2")
-        assert item1 is None
-        assert item2 is not None
-
-        # Wait for the second item's TTL
-        time.sleep(4)
-        store.sweep_ttl()
-
-        # Now both should be gone
-        item2 = store.get(("test",), "item2")
-        assert item2 is None
-
-
-@pytest.mark.flaky(retries=3)
-def test_ttl_override_default(temp_db_file: str) -> None:
-    """Test overriding default TTL at the item level."""
-    with SqliteStore.from_conn_string(
-        temp_db_file,
-        ttl={"default_ttl": 5 / 60},  # 5 seconds default
-    ) as store:
-        store.setup()
-
-        # Store an item with shorter than default TTL
-        store.put(("test",), "item1", {"value": "override"}, ttl=1 / 60)  # 1 second
-
-        # Store an item with default TTL
-        store.put(("test",), "item2", {"value": "default"})  # Uses default 5 seconds
-
-        # Store an item with no TTL
-        store.put(("test",), "item3", {"value": "permanent"}, ttl=None)
-
-        # Wait for the override TTL to expire
-        time.sleep(2)
-        store.sweep_ttl()
-
-        # Check results
-        item1 = store.get(("test",), "item1")
-        item2 = store.get(("test",), "item2")
-        item3 = store.get(("test",), "item3")
-
-        assert item1 is None  # Should be expired
-        assert item2 is not None  # Default TTL, should still be there
-        assert item3 is not None  # No TTL, should still be there
-
-        # Wait for default TTL to expire
-        time.sleep(4)
-        store.sweep_ttl()
-
-        # Check results again
-        item2 = store.get(("test",), "item2")
-        item3 = store.get(("test",), "item3")
-
-        assert item2 is None  # Default TTL item should be gone
-        assert item3 is not None  # No TTL item should still be there
-
-
-@pytest.mark.flaky(retries=3)
-def test_search_with_ttl(temp_db_file: str) -> None:
-    """Test TTL with search operations."""
-    ttl_seconds = 1
-    ttl_minutes = ttl_seconds / 60
-
-    with SqliteStore.from_conn_string(
-        temp_db_file, ttl={"default_ttl": ttl_minutes}
-    ) as store:
-        store.setup()
-
-        # Store items
-        store.put(("test",), "item1", {"value": "apple"})
-        store.put(("test",), "item2", {"value": "banana"})
-
-        # Search before expiration
-        results = store.search(("test",), filter={"value": "apple"})
-        assert len(results) == 1
-        assert results[0].key == "item1"
-
-        # Wait for TTL to expire
-        time.sleep(ttl_seconds + 1)
-        store.sweep_ttl()
-
-        # Search after expiration
-        results = store.search(("test",), filter={"value": "apple"})
-        assert len(results) == 0
-
-
-@pytest.mark.asyncio
-async def test_async_ttl_basic(temp_db_file: str) -> None:
-    """Test basic TTL functionality with asynchronous API."""
-    ttl_seconds = 1
-    ttl_minutes = ttl_seconds / 60
-
-    async with AsyncSqliteStore.from_conn_string(
-        temp_db_file, ttl={"default_ttl": ttl_minutes}
-    ) as store:
-        await store.setup()
-
-        # Store an item with TTL
-        await store.aput(("test",), "item1", {"value": "test"})
-
-        # Get the item before expiration
-        item = await store.aget(("test",), "item1")
-        assert item is not None
-        assert item.value["value"] == "test"
-
-        # Wait for TTL to expire
-        await asyncio.sleep(ttl_seconds + 1.0)
-
-        # Manual sweep needed without the sweeper thread
-        await store.sweep_ttl()
-
-        # Item should be gone now
-        item = await store.aget(("test",), "item1")
-        assert item is None
-
-
-@pytest.mark.asyncio
-@pytest.mark.flaky(retries=3)
-async def test_async_ttl_refresh(temp_db_file: str) -> None:
-    """Test TTL refresh on read with async API."""
-    ttl_seconds = 1
-    ttl_minutes = ttl_seconds / 60
-
-    async with AsyncSqliteStore.from_conn_string(
-        temp_db_file, ttl={"default_ttl": ttl_minutes, "refresh_on_read": True}
-    ) as store:
-        await store.setup()
-
-        # Store an item with TTL
-        await store.aput(("test",), "item1", {"value": "test"})
-
-        # Sleep almost to expiration
-        await asyncio.sleep(ttl_seconds - 0.5)
-
-        # Get the item and refresh TTL
-        item = await store.aget(("test",), "item1", refresh_ttl=True)
-        assert item is not None
-
-        # Sleep again - without refresh, would have expired by now
-        await asyncio.sleep(ttl_seconds - 0.5)
-
-        # Get the item, should still be there
-        item = await store.aget(("test",), "item1")
-        assert item is not None
-        assert item.value["value"] == "test"
-
-        # Sleep again but don't refresh this time
-        await asyncio.sleep(ttl_seconds + 1.0)
-
-        # Manual sweep
-        await store.sweep_ttl()
-
-        # Item should be gone now
-        item = await store.aget(("test",), "item1")
-        assert item is None
-
-
-@pytest.mark.asyncio
-async def test_async_ttl_sweeper(temp_db_file: str) -> None:
-    """Test TTL sweeper thread with async API."""
-    ttl_seconds = 2
-    ttl_minutes = ttl_seconds / 60
-
-    async with AsyncSqliteStore.from_conn_string(
-        temp_db_file,
-        ttl={"default_ttl": ttl_minutes, "sweep_interval_minutes": ttl_minutes / 2},
-    ) as store:
-        await store.setup()
-
-        # Start the TTL sweeper
-        await store.start_ttl_sweeper()
-
-        # Store an item with TTL
-        await store.aput(("test",), "item1", {"value": "test"})
-
-        # Item should be there initially
-        item = await store.aget(("test",), "item1")
-        assert item is not None
-
-        # Wait for TTL to expire and the sweeper to run
-        await asyncio.sleep(ttl_seconds + (ttl_seconds / 2) + 0.5)
-
-        # Item should be gone now (swept automatically)
-        item = await store.aget(("test",), "item1")
-        assert item is None
-
-        # Stop the sweeper
-        await store.stop_ttl_sweeper()
-
-
-@pytest.mark.asyncio
-@pytest.mark.flaky(retries=3)
-async def test_async_search_with_ttl(temp_db_file: str) -> None:
-    """Test TTL with search operations using async API."""
-    ttl_seconds = 1
-    ttl_minutes = ttl_seconds / 60
-
-    async with AsyncSqliteStore.from_conn_string(
-        temp_db_file, ttl={"default_ttl": ttl_minutes}
-    ) as store:
-        await store.setup()
-
-        # Store items
-        await store.aput(("test",), "item1", {"value": "apple"})
-        await store.aput(("test",), "item2", {"value": "banana"})
-
-        # Search before expiration
-        results = await store.asearch(("test",), filter={"value": "apple"})
-        assert len(results) == 1
-        assert results[0].key == "item1"
-
-        # Wait for TTL to expire
-        await asyncio.sleep(ttl_seconds + 1)
-        await store.sweep_ttl()
-
-        # Search after expiration
-        results = await store.asearch(("test",), filter={"value": "apple"})
-        assert len(results) == 0

libs/checkpoint/Makefile

@@ -7,10 +7,10 @@
 TEST ?= .
 
 test:
-	uv run pytest $(TEST)
+	poetry run pytest $(TEST)
 
 test_watch:
-	uv run ptw $(TEST)
+	poetry run ptw $(TEST)
 
 ######################
 # LINTING AND FORMATTING
@@ -26,12 +26,12 @@ lint_tests: PYTHON_FILES=tests
 lint_tests: MYPY_CACHE=.mypy_cache_test
 
 lint lint_diff lint_package lint_tests:
-	uv run ruff check .
-	[ "$(PYTHON_FILES)" = "" ] || uv run ruff format $(PYTHON_FILES) --diff
-	[ "$(PYTHON_FILES)" = "" ] || uv run ruff check --select I $(PYTHON_FILES)
+	poetry run ruff check .
+	[ "$(PYTHON_FILES)" = "" ] || poetry run ruff format $(PYTHON_FILES) --diff
+	[ "$(PYTHON_FILES)" = "" ] || poetry run ruff check --select I $(PYTHON_FILES)
 	[ "$(PYTHON_FILES)" = "" ] || mkdir -p $(MYPY_CACHE)
-	[ "$(PYTHON_FILES)" = "" ] || uv run mypy $(PYTHON_FILES) --cache-dir $(MYPY_CACHE)
+	[ "$(PYTHON_FILES)" = "" ] || poetry run mypy $(PYTHON_FILES) --cache-dir $(MYPY_CACHE)
 
 format format_diff:
-	uv run ruff format $(PYTHON_FILES)
-	uv run ruff check --select I --fix $(PYTHON_FILES)
+	poetry run ruff format $(PYTHON_FILES)
+	poetry run ruff check --select I --fix $(PYTHON_FILES)

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

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from collections.abc import Mapping, Sequence
-from typing import Generic, TypeVar
+from collections.abc import Mapping
+from typing import Generic, Sequence, TypeVar
 
 from langgraph.checkpoint.serde.base import SerializerProtocol
 from langgraph.checkpoint.serde.jsonplus import JsonPlusSerializer

libs/checkpoint/langgraph/checkpoint/base/id.py

@@ -6,7 +6,7 @@ Bundled in to avoid install issues with uuid6 package
 import random
 import time
 import uuid
-from typing import Optional
+from typing import Optional, Tuple
 
 _last_v6_timestamp = None
 
@@ -21,7 +21,7 @@ class UUID(uuid.UUID):
         hex: Optional[str] = None,
         bytes: Optional[bytes] = None,
         bytes_le: Optional[bytes] = None,
-        fields: Optional[tuple[int, int, int, int, int, int]] = None,
+        fields: Optional[Tuple[int, int, int, int, int, int]] = None,
         int: Optional[int] = None,
         version: Optional[int] = None,
         *,

libs/checkpoint/langgraph/checkpoint/serde/jsonplus.py

@@ -20,11 +20,11 @@ from ipaddress import (
 )
 from typing import Any, Callable, Optional, Union, cast
 from uuid import UUID
-from zoneinfo import ZoneInfo
 
 import ormsgpack
 from langchain_core.load.load import Reviver
 from langchain_core.load.serializable import Serializable
+from zoneinfo import ZoneInfo
 
 from langgraph.checkpoint.serde.base import SerializerProtocol
 from langgraph.checkpoint.serde.types import SendProtocol

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

@@ -1,8 +1,8 @@
-from collections.abc import Sequence
 from typing import (
     Any,
     Optional,
     Protocol,
+    Sequence,
     TypeVar,
     runtime_checkable,
 )

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

@@ -10,10 +10,10 @@ Core types:
 """
 
 from abc import ABC, abstractmethod
-from collections.abc import Iterable
 from datetime import datetime
 from typing import (
     Any,
+    Iterable,
     Literal,
     NamedTuple,
     Optional,

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

@@ -9,8 +9,7 @@ asynchronous operations.
 import asyncio
 import functools
 import json
-from collections.abc import Awaitable, Sequence
-from typing import Any, Callable, Optional, Union
+from typing import Any, Awaitable, Callable, Optional, Sequence, Union
 
 from langchain_core.embeddings import Embeddings
 

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

@@ -104,10 +104,9 @@ import concurrent.futures as cf
 import functools
 import logging
 from collections import defaultdict
-from collections.abc import Iterable
 from datetime import datetime, timezone
 from importlib import util
-from typing import Any, Optional
+from typing import Any, Iterable, Optional
 
 from langchain_core.embeddings import Embeddings
 

libs/checkpoint/pyproject.toml

@@ -1,43 +1,43 @@
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[project]
+[tool.poetry]
 name = "langgraph-checkpoint"
-version = "2.0.26"
+version = "2.0.25"
 description = "Library with base interfaces for LangGraph checkpoint savers."
 authors = []
-requires-python = ">=3.9"
-readme = "README.md"
 license = "MIT"
-license-files = ['LICENSE']
-dependencies = [
-    "langchain-core>=0.2.38",
-    "ormsgpack>=1.8.0",
-]
+readme = "README.md"
+repository = "https://www.github.com/langchain-ai/langgraph"
+packages = [{ include = "langgraph" }]
 
-[project.urls]
-Repository = "https://www.github.com/langchain-ai/langgraph"
+[tool.poetry.dependencies]
+python = ">=3.9"
+langchain-core = { version = ">=0.2.38", python = "<4.0" }
+ormsgpack = "^1.8.0"
 
-[dependency-groups]
-dev = [
-  "ruff",
-  "codespell",
-  "pytest",
-  "pytest-asyncio",
-  "pytest-mock",
-  "pytest-watcher",
-  "mypy",
-  "dataclasses-json",
-]
-
-[tool.hatch.build.targets.wheel]
-include = ["langgraph"]
+[tool.poetry.group.dev.dependencies]
+ruff = "^0.6.2"
+codespell = "^2.2.0"
+pytest = "^7.2.1"
+pytest-asyncio = "^0.21.1"
+pytest-mock = "^3.11.1"
+pytest-watcher = { version = ">=0.4.1", python = "<4.0" }
+mypy = "^1.10.0"
+dataclasses-json = { version = ">=0.6.7", python = "<4.0" }
 
 [tool.pytest.ini_options]
+# --strict-markers will raise errors on unknown marks.
+# https://docs.pytest.org/en/7.1.x/how-to/mark.html#raising-errors-on-unknown-marks
+#
+# https://docs.pytest.org/en/7.1.x/reference/reference.html
+# --strict-config       any warnings encountered while parsing the `pytest`
+#                       section of the configuration file raise errors.
 addopts = "--strict-markers --strict-config --durations=5 -vv"
 asyncio_mode = "auto"
 
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
 [tool.ruff]
 lint.select = [
   "E",  # pycodestyle

libs/checkpoint/tests/test_jsonplus.py

@@ -8,12 +8,12 @@ from datetime import date, datetime, time, timezone
 from decimal import Decimal
 from enum import Enum
 from ipaddress import IPv4Address
-from zoneinfo import ZoneInfo
 
 import dataclasses_json
 from pydantic import BaseModel, SecretStr
 from pydantic.v1 import BaseModel as BaseModelV1
 from pydantic.v1 import SecretStr as SecretStrV1
+from zoneinfo import ZoneInfo
 
 from langgraph.checkpoint.serde.jsonplus import (
     JsonPlusSerializer,

libs/checkpoint/tests/test_store.py

@@ -1,9 +1,8 @@
 # mypy: disable-error-code="operator"
 import asyncio
 import json
-from collections.abc import Iterable
 from datetime import datetime
-from typing import Any
+from typing import Any, Iterable
 
 import pytest
 from pytest_mock import MockerFixture

libs/cli/Makefile

@@ -5,9 +5,9 @@
 ######################
 
 test:
-	uv run pytest tests/unit_tests
+	poetry run pytest tests/unit_tests
 test-integration:
-	uv run pytest tests/integration_tests
+	poetry run pytest tests/integration_tests
 
 ######################
 # LINTING AND FORMATTING
@@ -23,14 +23,14 @@ lint_tests: PYTHON_FILES=tests
 lint_tests: MYPY_CACHE=.mypy_cache_test
 
 lint lint_diff lint_package lint_tests:
-	uv run ruff check .
-	[ "$(PYTHON_FILES)" = "" ] || uv run ruff format $(PYTHON_FILES) --diff
-	[ "$(PYTHON_FILES)" = "" ] || uv run ruff check --select I $(PYTHON_FILES)
-	[ "$(PYTHON_FILES)" = "" ] || mkdir -p $(MYPY_CACHE) || uv run mypy $(PYTHON_FILES) --cache-dir $(MYPY_CACHE)
+	poetry run ruff check .
+	[ "$(PYTHON_FILES)" = "" ] || poetry run ruff format $(PYTHON_FILES) --diff
+	[ "$(PYTHON_FILES)" = "" ] || poetry run ruff check --select I $(PYTHON_FILES)
+	[ "$(PYTHON_FILES)" = "" ] || mkdir -p $(MYPY_CACHE) || poetry run mypy $(PYTHON_FILES) --cache-dir $(MYPY_CACHE)
 
 format format_diff:
-	uv run ruff format $(PYTHON_FILES)
-	uv run ruff check --select I --fix $(PYTHON_FILES)
+	poetry run ruff format $(PYTHON_FILES)
+	poetry run ruff check --select I --fix $(PYTHON_FILES)
 
 update-schema:
-	uv run python generate_schema.py
+	poetry run python generate_schema.py

libs/cli/README.md

@@ -87,17 +87,17 @@ To develop the CLI itself:
 
 1. Clone the repository
 2. Navigate to the CLI directory: `cd libs/cli`
-3. Install development dependencies: `uv pip install`
+3. Install development dependencies: `poetry install`
 4. Make your changes to the CLI code
 5. Test your changes:
    ```bash
    # Run CLI commands directly
-   uv run langgraph --help
+   poetry run langgraph --help
    
    # Or use the examples
    cd examples
-   uv pip install
-   uv run langgraph dev  # or other commands
+   poetry install
+   poetry run langgraph dev  # or other commands
    ```
 
 ## License

libs/cli/examples/Makefile

@@ -1,13 +1,13 @@
 .PHONY: run_w_override
 
 run:
-	uv run langgraph up --watch --no-pull
+	poetry run langgraph up --watch --no-pull
 
 run_faux:
-	cd graphs && uv run langgraph up --no-pull
+	cd graphs && poetry run langgraph up --no-pull
 
 run_graphs_reqs_a:
-	cd graphs_reqs_a && uv run langgraph up --no-pull
+	cd graphs_reqs_a && poetry run langgraph up --no-pull
 
 run_graphs_reqs_b:
-	cd graphs_reqs_b && uv run langgraph up --no-pull
+	cd graphs_reqs_b && poetry run langgraph up --no-pull

libs/cli/examples/graphs/agent.py

@@ -1,5 +1,4 @@
-from collections.abc import Sequence
-from typing import Annotated, Literal, TypedDict
+from typing import Annotated, Literal, Sequence, TypedDict
 
 from langchain_anthropic import ChatAnthropic
 from langchain_community.tools.tavily_search import TavilySearchResults

libs/cli/examples/graphs/storm.py

@@ -1,6 +1,6 @@
 import asyncio
 import json
-from typing import Annotated, Optional
+from typing import Annotated, List, Optional
 
 from langchain_community.retrievers import WikipediaRetriever
 from langchain_community.tools.tavily_search import TavilySearchResults
@@ -51,7 +51,7 @@ class Subsection(BaseModel):
 class Section(BaseModel):
     section_title: str = Field(..., title="Title of the section")
     description: str = Field(..., title="Content of the section")
-    subsections: Optional[list[Subsection]] = Field(
+    subsections: Optional[List[Subsection]] = Field(
         default=None,
         title="Titles and descriptions for each subsection of the Wikipedia page.",
     )
@@ -67,7 +67,7 @@ class Section(BaseModel):
 
 class Outline(BaseModel):
     page_title: str = Field(..., title="Title of the Wikipedia page")
-    sections: list[Section] = Field(
+    sections: List[Section] = Field(
         default_factory=list,
         title="Titles and descriptions for each section of the Wikipedia page.",
     )
@@ -93,7 +93,7 @@ Topic of interest: {topic}
 
 
 class RelatedSubjects(BaseModel):
-    topics: list[str] = Field(
+    topics: List[str] = Field(
         description="Comprehensive list of related subjects as background research.",
     )
 
@@ -123,7 +123,7 @@ class Editor(BaseModel):
 
 
 class Perspectives(BaseModel):
-    editors: list[Editor] = Field(
+    editors: List[Editor] = Field(
         description="Comprehensive list of editors with their roles and affiliations.",
         # Add a pydantic validation/restriction to be at most M editors
     )
@@ -200,7 +200,7 @@ def update_editor(editor, new_editor):
 
 
 class InterviewState(TypedDict):
-    messages: Annotated[list[AnyMessage], add_messages]
+    messages: Annotated[List[AnyMessage], add_messages]
     references: Annotated[Optional[dict], update_references]
     editor: Annotated[Optional[Editor], update_editor]
 
@@ -255,7 +255,7 @@ async def generate_question(state: InterviewState):
 
 
 class Queries(BaseModel):
-    queries: list[str] = Field(
+    queries: List[str] = Field(
         description="Comprehensive list of search engine queries to answer the user's questions.",
     )
 
@@ -278,7 +278,7 @@ class AnswerWithCitations(BaseModel):
     answer: str = Field(
         description="Comprehensive answer to the user's question with citations.",
     )
-    cited_urls: list[str] = Field(
+    cited_urls: List[str] = Field(
         description="List of urls cited in the answer.",
     )
 
@@ -437,11 +437,11 @@ class SubSection(BaseModel):
 class WikiSection(BaseModel):
     section_title: str = Field(..., title="Title of the section")
     content: str = Field(..., title="Full content of the section")
-    subsections: Optional[list[Subsection]] = Field(
+    subsections: Optional[List[Subsection]] = Field(
         default=None,
         title="Titles and descriptions for each subsection of the Wikipedia page.",
     )
-    citations: list[str] = Field(default_factory=list)
+    citations: List[str] = Field(default_factory=list)
 
     @property
     def as_str(self) -> str:
@@ -506,10 +506,10 @@ writer = writer_prompt | long_context_llm | StrOutputParser()
 class ResearchState(TypedDict):
     topic: str
     outline: Outline
-    editors: list[Editor]
-    interview_results: list[InterviewState]
+    editors: List[Editor]
+    interview_results: List[InterviewState]
     # The final sections output
-    sections: list[WikiSection]
+    sections: List[WikiSection]
     article: str
 
 

libs/cli/examples/graphs_reqs_a/graphs_submod/agent.py

@@ -1,6 +1,5 @@
-from collections.abc import Sequence
 from pathlib import Path
-from typing import Annotated, TypedDict
+from typing import Annotated, Sequence, TypedDict
 
 from langchain_anthropic import ChatAnthropic
 from langchain_community.tools.tavily_search import TavilySearchResults

libs/cli/examples/graphs_reqs_b/graphs_submod/agent.py

@@ -1,6 +1,5 @@
-from collections.abc import Sequence
 from pathlib import Path
-from typing import Annotated, TypedDict
+from typing import Annotated, Sequence, TypedDict
 
 from langchain_anthropic import ChatAnthropic
 from langchain_community.tools.tavily_search import TavilySearchResults

libs/cli/examples/pyproject.toml

@@ -1,21 +1,17 @@
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[project]
+[tool.poetry]
 name = "langgraph-examples"
 version = "0.1.0"
 description = ""
+authors = []
 readme = "README.md"
-requires-python = ">=3.9"
-dependencies = [
-    "langgraph-cli",
-    "langgraph-sdk",
-]
-
-[tool.uv.sources]
-langgraph-cli = { path = "../cli", editable = true }
-langgraph-sdk = { path = "../sdk_py", editable = true }
-
-[tool.hatch.build]
 packages = []
+package-mode = false
+
+[tool.poetry.dependencies]
+python = ">=3.9"
+langgraph-cli = {path = "../../cli", develop = true}
+langgraph-sdk = {path = "../../sdk-py", develop = true}
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

libs/cli/langgraph_cli/cli.py

@@ -4,8 +4,7 @@ import os
 import pathlib
 import shutil
 import sys
-from collections.abc import Sequence
-from typing import Callable, Optional
+from typing import Callable, List, Optional, Sequence, Tuple
 
 import click
 import click.exceptions
@@ -742,7 +741,7 @@ def prepare_args_and_stdin(
     image: Optional[str] = None,
     # Like "langchain/langgraphjs-api" or "langchain/langgraph-api
     base_image: Optional[str] = None,
-) -> tuple[list[str], str]:
+) -> Tuple[List[str], str]:
     assert config_path.exists(), f"Config file not found: {config_path}"
     # prepare args
     stdin = langgraph_cli.docker.compose(
@@ -788,7 +787,7 @@ def prepare(
     postgres_uri: Optional[str] = None,
     image: Optional[str] = None,
     base_image: Optional[str] = None,
-) -> tuple[list[str], str]:
+) -> Tuple[List[str], str]:
     """Prepare the arguments and stdin for running the LangGraph API server."""
     config_json = langgraph_cli.config.validate_config_file(config_path)
     # pull latest images

libs/cli/langgraph_cli/templates.py

@@ -2,13 +2,13 @@ import os
 import shutil
 import sys
 from io import BytesIO
-from typing import Optional
+from typing import Dict, Optional
 from urllib import error, request
 from zipfile import ZipFile
 
 import click
 
-TEMPLATES: dict[str, dict[str, str]] = {
+TEMPLATES: Dict[str, Dict[str, str]] = {
     "New LangGraph Project": {
         "description": "A simple, minimal chatbot with memory.",
         "python": "https://github.com/langchain-ai/new-langgraph-project/archive/refs/heads/main.zip",

libs/cli/pyproject.toml

@@ -1,62 +1,63 @@
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[project]
+[tool.poetry]
 name = "langgraph-cli"
 version = "0.2.10"
 description = "CLI for interacting with LangGraph API"
 authors = []
-requires-python = ">=3.9"
-readme = "README.md"
 license = "MIT"
-license-files = ['LICENSE']
-dependencies = [
-    "click>=8.1.7",
-    "langgraph-sdk>=0.1.0 ; python_version >= '3.11'",
-]
+readme = "README.md"
+repository = "https://www.github.com/langchain-ai/langgraph"
+packages = [{ include = "langgraph_cli" }]
 
-[project.optional-dependencies]
-inmem = [
-    "langgraph-api>=0.1.20 ; python_version >= '3.11'",
-    "langgraph-runtime-inmem>=0.0.8 ; python_version >= '3.11'",
-    "python-dotenv>=0.8.0",
-]
-
-[project.urls]
-Repository = "https://www.github.com/langchain-ai/langgraph"
-
-[project.scripts]
+[tool.poetry.scripts]
 langgraph = "langgraph_cli.cli:cli"
 
-[dependency-groups]
-dev = [
-    "ruff",
-    "codespell",
-    "pytest",
-    "pytest-asyncio",
-    "pytest-mock",
-    "pytest-watch",
-    "mypy",
-    "msgspec",
-]
+[tool.poetry.dependencies]
+python = ">=3.9"
+click = "^8.1.7"
+langgraph-api = { version = ">=0.1.20", optional = true, python = ">=3.11,<4.0" }
+langgraph-runtime-inmem = { version = ">=0.0.8", optional = true, python = ">=3.11,<4.0" }
+langgraph-sdk = { version = ">=0.1.0", optional = true, python = ">=3.11,<4.0" }
+python-dotenv = { version = ">=0.8.0", optional = true }
 
-[tool.uv]
-default-groups = ['dev']
+[tool.poetry.group.dev.dependencies]
+ruff = "^0.6.2"
+codespell = "^2.2.0"
+pytest = "^7.2.1"
+pytest-asyncio = "^0.21.1"
+pytest-mock = "^3.11.1"
+pytest-watch = "^4.2.0"
+mypy = "^1.10.0"
+msgspec = "^0.19.0"
 
-[tool.hatch.build.targets.wheel]
-include = ["langgraph_cli"]
+[tool.poetry.extras]
+inmem = ["langgraph-api", "langgraph-runtime-inmem", "python-dotenv"]
 
 [tool.pytest.ini_options]
+# --strict-markers will raise errors on unknown marks.
+# https://docs.pytest.org/en/7.1.x/how-to/mark.html#raising-errors-on-unknown-marks
+#
+# https://docs.pytest.org/en/7.1.x/reference/reference.html
+# --strict-config       any warnings encountered while parsing the `pytest`
+#                       section of the configuration file raise errors.
 addopts = "--strict-markers --strict-config --durations=5 -vv"
 asyncio_mode = "auto"
 
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
 [tool.ruff]
 lint.select = [
-  "E",  # pycodestyle
-  "F",  # Pyflakes
-  "UP", # pyupgrade
-  "B",  # flake8-bugbear
-  "I",  # isort
+  # pycodestyle
+  "E",
+  # Pyflakes
+  "F",
+  # pyupgrade
+  "UP",
+  # flake8-bugbear
+  "B",
+  # isort
+  "I",
 ]
 lint.ignore = ["E501", "B008"]

libs/cli/tests/unit_tests/agent.py

@@ -1,7 +1,6 @@
 import asyncio
 import os
-from collections.abc import Sequence
-from typing import Annotated, TypedDict
+from typing import Annotated, Sequence, TypedDict
 
 from langchain_core.language_models.fake_chat_models import FakeListChatModel
 from langchain_core.messages import BaseMessage, HumanMessage, ToolMessage

libs/langgraph-go/Makefile

@@ -1,28 +0,0 @@
-.PHONY: all format build test
-
-# Default target executed when no arguments are given to make.
-all: help
-
-format:
-	go fmt ./...
-
-build:
-	go build ./...
-
-test:
-	go test ./...
-
-
-######################
-# HELP
-######################
-
-help:
-	@echo '===================='
-	@echo '-- DOCUMENTATION --'
-	
-	@echo '-- LINTING --'
-	@echo 'format                       - run code formatters'
-	@echo 'build                        - build the project'
-	@echo 'test                         - run unit tests'
-

libs/langgraph-go/go.mod

@@ -1,10 +0,0 @@
-module langchain.dev/langgraph
-
-go 1.23.0
-
-toolchain go1.23.9
-
-require (
-	github.com/google/uuid v1.6.0 // indirect
-	golang.org/x/sync v0.14.0 // indirect
-)