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/generate_llms_text.py

@@ -1,19 +1,10 @@
 """Experimental script to generate consolidated llms text from the docs."""
 
-import asyncio
 import glob
 import os
-from typing import TypedDict, List, Optional
-import pydantic
-import re
-from pydantic import BaseModel, Field
-from langchain_core.rate_limiters import InMemoryRateLimiter
 
-import yaml
-from langchain.chat_models import init_chat_model
 from mkdocs.structure.files import File
 from mkdocs.structure.pages import Page
-from yaml import SafeLoader
 
 from _scripts.notebook_hooks import _on_page_markdown_with_config
 
@@ -22,49 +13,7 @@ HERE = os.path.dirname(os.path.abspath(__file__))
 SOURCE_DIR = os.path.abspath(os.path.join(os.path.dirname(HERE), "docs"))
 
 
-async def convert_ipynb_to_md(file_path: str) -> Optional[str]:
-    """Process a file (markdown or notebook) to markdown format.
-
-    Args:
-        file_path: Path to the file to process
-
-    Returns:
-        Processed markdown content if successful, None otherwise
-    """
-    rel_path = os.path.relpath(file_path, SOURCE_DIR)
-
-    # Create File and Page objects to match mkdocs structure
-    file_obj = File(
-        path=rel_path, src_dir=SOURCE_DIR, dest_dir="", use_directory_urls=True
-    )
-    page = Page(
-        title="",
-        file=file_obj,
-        config={},
-    )
-
-    try:
-        # Read raw content
-        with open(file_path, "r", encoding="utf-8") as f:
-            content = f.read()
-
-        # Convert to markdown without logic to resolve API references
-        processed_content = _on_page_markdown_with_config(
-            content, page, add_api_references=False, remove_base64_images=True
-        )
-        # Remove self-closing img tags <img ... />
-        processed_content = re.sub(r"<img[^>]*/>", "", processed_content)
-        # Remove img tags with content <img ...>...</img>
-        processed_content = re.sub(
-            r"<img[^>]*>.*?</img>", "", processed_content, flags=re.DOTALL
-        )
-        return processed_content
-    except Exception as e:
-        print(f"Error processing file {file_path}: {e}")
-        return None
-
-
-async def generate_full_llms_text(output_file: str) -> None:
+def _make_llms_text(output_file: str) -> str:
     """Generate a consolidated text file from markdown/notebook files for LLM training.
 
     Args:
@@ -72,9 +21,11 @@ async def generate_full_llms_text(output_file: str) -> None:
     """
     # Collect all markdown and notebook files
     all_files = glob.glob(os.path.join(SOURCE_DIR, "how-tos/*.md"), recursive=True)
+
     all_files.extend(
         glob.glob(os.path.join(SOURCE_DIR, "how-tos/*.ipynb"), recursive=True)
     )
+    # Add all concepts
     all_files.extend(
         glob.glob(os.path.join(SOURCE_DIR, "concepts/*.md"), recursive=True)
     )
@@ -84,14 +35,30 @@ async def generate_full_llms_text(output_file: str) -> None:
 
     all_content = []
 
-    # Process files concurrently
-    tasks = [convert_ipynb_to_md(file_path) for file_path in all_files]
-    results = await asyncio.gather(*tasks)
+    # Process each file
+    for file_path in all_files:
+        print(f"Processing {file_path}")
+        rel_path = os.path.relpath(file_path, SOURCE_DIR)
 
-    # Combine results with file paths
-    for file_path, processed_content in zip(all_files, results):
+        # Create File and Page objects to match mkdocs structure
+        file_obj = File(
+            path=rel_path, src_dir=SOURCE_DIR, dest_dir="", use_directory_urls=True
+        )
+        page = Page(
+            title="",
+            file=file_obj,
+            config={},
+        )
+
+        # Read raw content
+        with open(file_path, "r", encoding="utf-8") as f:
+            content = f.read()
+
+        # Convert to markdown without logic to resolve API references
+        processed_content = _on_page_markdown_with_config(
+            content, page, add_api_references=False, remove_base64_images=True
+        )
         if processed_content:
-            rel_path = os.path.relpath(file_path, SOURCE_DIR)
             # Add file name
             all_content.append(f"---\n{rel_path}\n---")
             # Add content
@@ -102,168 +69,6 @@ async def generate_full_llms_text(output_file: str) -> None:
         f.write("\n\n".join(all_content))
 
 
-def no_op_constructor(*args):
-    """No-op"""
-
-
-SafeLoader.add_multi_constructor(
-    "tag:yaml.org,2002:python/name",
-    no_op_constructor,
-)
-
-
-class NavItem(TypedDict):
-    title: str
-    url: str
-    hierarchy: tuple[str, ...]
-    description: str
-
-
-def _flatten_nav(
-    nav: list[dict[str, str | list] | str], path: tuple[str, ...] = ()
-) -> list[NavItem]:
-    flat: List[NavItem] = []
-    for item in nav:
-        if isinstance(item, dict):
-            for title, node in item.items():
-                new_path = path + (title,)
-                if isinstance(node, str):
-                    # Leaf page
-                    flat.append(
-                        {
-                            "title": title,
-                            "url": node,
-                            "hierarchy": new_path,
-                            "description": "",
-                        }
-                    )
-                elif isinstance(node, list):
-                    # Dive in, carrying along the updated path
-                    flat.extend(_flatten_nav(node, new_path))
-                else:
-                    raise TypeError(
-                        f"Unexpected node type {type(node)} under {title!r}"
-                    )
-        elif isinstance(item, str):
-            # Bare string entry → use itself as title, and as URL
-            new_path = path + (item,)
-            flat.append(
-                {"title": item, "url": item, "hierarchy": new_path, "description": ""}
-            )
-        else:
-            raise TypeError(f"Unexpected item type {type(item)} in nav")
-    return flat
-
-
-class PageInfo(BaseModel):
-    title: str = Field(description="The title of the page")
-    description: str = Field(
-        description="A short description of the page no longer than 3 sentences "
-        "explaining the kind of content that can be found in the page."
-    )
-
-
-async def process_nav_items(nav_items: list[NavItem]) -> list[NavItem]:
-    """Open the contents of each nav item and come up with a better title and description."""
-    rate_limiter = InMemoryRateLimiter(requests_per_second=10)
-    model = init_chat_model("gpt-4o-mini", temperature=0.0, rate_limiter=rate_limiter)
-    model = model.with_structured_output(PageInfo)
-
-    async def process_single_item(item: NavItem) -> NavItem:
-        path = item["url"]
-        file_path = os.path.join(SOURCE_DIR, path)
-
-        # Process the file content (handles both markdown and notebooks)
-        if path.endswith(".ipynb"):
-            content = await convert_ipynb_to_md(file_path)
-        else:
-            with open(file_path, "r", encoding="utf-8") as f:
-                content = f.read()
-
-        if not content:
-            return item
-
-        # Generate a better title and description
-        response = await model.ainvoke(
-            [
-                {
-                    "role": "system",
-                    "content": "You are a technical documentation writer. "
-                    "You are given a markdown page of documentation. "
-                    "Please come up with an appropriate title and "
-                    "description for the page. The description should "
-                    "be a short summary of the page content that is "
-                    "no longer than 3 sentences.",
-                },
-                {
-                    "role": "user",
-                    "content": "The markdown page is as follows:\n\n" + content,
-                },
-            ]
-        )
-        return {
-            "title": response.title,
-            "url": item["url"],
-            "hierarchy": item["hierarchy"],
-            "description": response.description,
-        }
-
-    # Remove any items that start with http:// or https:// looking only for
-    # local file at this stages.
-    nav_items = [
-        item for item in nav_items if not item["url"].startswith(("http://", "https://"))
-    ]
-    # Process items in parallel
-    tasks = [process_single_item(item) for item in nav_items]
-    new_nav_items = await asyncio.gather(*tasks)
-    return new_nav_items
-
-
-async def generate_nav_links_text(
-    output_file: str, *, replace_links: bool = False
-) -> None:
-    """Generate llms.txt from mkdocs.yaml."""
-    # Get path to mkdocs.yaml relative to this script
-    script_dir = os.path.dirname(os.path.abspath(__file__))
-    mkdocs_path = os.path.join(os.path.dirname(script_dir), "mkdocs.yml")
-
-    # Load and parse yaml
-    with open(mkdocs_path, "r") as f:
-        config = yaml.safe_load(f)
-
-    # Extract nav section
-    nav = config.get("nav", [])
-    flattened = _flatten_nav(nav)
-
-    processed_nav = await process_nav_items(flattened)
-
-    with open(output_file, "w") as f:
-        current_section = None
-        for item in processed_nav:
-            # Get the top-level section (first item in hierarchy)
-            section = item["hierarchy"][0]
-
-            if section not in {"Guides", "Examples", "Resources"}:
-                continue
-
-            # If we're starting a new section, add a heading
-            if section != current_section:
-                f.write(f"\n# {section}\n\n")
-                current_section = section
-
-            title = item["title"]
-            # Process URL based on replace_links flag
-            url = item["url"]
-            if replace_links:
-                # Remove .md extension and ensure single trailing slash
-                url = url.removesuffix(".md")
-                url = url.removesuffix(".ipynb")
-                url = url.rstrip("/") + "/"
-                url = f"https://langchain-ai.github.io/langgraph/{url}"
-
-            f.write(f"- [{title}]({url}): {item['description']}\n")
-
-
 if __name__ == "__main__":
     import argparse
 
@@ -273,23 +78,6 @@ if __name__ == "__main__":
         )
     )
     parser.add_argument("output_file", help="Path to output the consolidated text file")
-    parser.add_argument(
-        "--link-only",
-        action="store_true",
-        help="Only include link references in the output",
-    )
-    parser.add_argument(
-        "--replace-links",
-        action="store_true",
-        help="Replace markdown links with full URLs in the output",
-    )
 
     args = parser.parse_args()
-    if args.link_only:
-        coro = generate_nav_links_text(
-            args.output_file, replace_links=args.replace_links
-        )
-    else:
-        coro = generate_full_llms_text(args.output_file)
-
-    asyncio.run(coro)
+    _make_llms_text(args.output_file)

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": "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/overview.md

@@ -53,139 +53,3 @@ The high-level components are organized into several packages, each with a speci
 | `langmem`                                  | Agent memory management: [**short-term and long-term**](./memory.md)        | `pip install -U langmem`                |
 | `agentevals`                               | Utilities to [**evaluate agent performance**](./evals.md)                   | `pip install -U agentevals`             |
 
-## Visualize an agent graph
-
-Use the following tool to visualize the graph generated by
-[`create_react_agent`][langgraph.prebuilt.chat_agent_executor.create_react_agent]
-and to view an outline of the corresponding code.
-It allows you to explore the infrastructure of the agent as defined by the presence of:
-
-* [`tools`](../agents/tools.md): A list of tools (functions, APIs, or other callable objects) that the agent can use to perform tasks.
-* [`pre_model_hook`](../how-tos/create-react-agent-manage-message-history.ipynb): A function that is called before the model is invoked. It can be used to condense messages or perform other preprocessing tasks.
-* `post_model_hook`: A function that is called after the model is invoked. It can be used to implement guardrails, human-in-the-loop flows, or other postprocessing tasks.
-* [`response_format`](../agents/agents.md#6-configure-structured-output): A data structure used to constrain the type of the final output, e.g., a `pydantic` `BaseModel`.
-
-<div class="agent-layout">
-  <div class="agent-graph-features-container">
-    <div class="agent-graph-features">
-      <h3 class="agent-section-title">Features</h3>
-      <label><input type="checkbox" id="tools" checked> <code>tools</code></label>
-      <label><input type="checkbox" id="pre_model_hook"> <code>pre_model_hook</code></label>
-      <label><input type="checkbox" id="post_model_hook"> <code>post_model_hook</code></label>
-      <label><input type="checkbox" id="response_format"> <code>response_format</code></label>
-    </div>
-  </div>
-
-  <div class="agent-graph-container">
-    <h3 class="agent-section-title">Graph</h3>
-    <img id="agent-graph-img" src="../assets/react_agent_graphs/0001.svg" alt="graph image" style="max-width: 100%;"/>
-  </div>
-</div>
-
-
-The following code snippet shows how to create the above agent (and underlying graph) with
-[`create_react_agent`][langgraph.prebuilt.chat_agent_executor.create_react_agent]:
-
-<div class="language-python">
-  <pre><code id="agent-code" class="language-python"></code></pre>
-</div>
-
-
-<script>
-function getCheckedValue(id) {
-  return document.getElementById(id).checked ? "1" : "0";
-}
-
-function getKey() {
-  return [
-    getCheckedValue("response_format"),
-    getCheckedValue("post_model_hook"),
-    getCheckedValue("pre_model_hook"),
-    getCheckedValue("tools")
-  ].join("");
-}
-
-function generateCodeSnippet({ tools, pre, post, response }) {
-  const lines = [
-    "from langgraph.prebuilt import create_react_agent",
-    "from langchain_openai import ChatOpenAI"
-  ];
-
-  if (response) lines.push("from pydantic import BaseModel");
-
-  lines.push("", 'model = ChatOpenAI("o4-mini")', "");
-
-  if (tools) {
-    lines.push(
-      "def tool() -> None:",
-      '    """Testing tool."""',
-      "    ...",
-      ""
-    );
-  }
-
-  if (pre) {
-    lines.push(
-      "def pre_model_hook() -> None:",
-      '    """Pre-model hook."""',
-      "    ...",
-      ""
-    );
-  }
-
-  if (post) {
-    lines.push(
-      "def post_model_hook() -> None:",
-      '    """Post-model hook."""',
-      "    ...",
-      ""
-    );
-  }
-
-  if (response) {
-    lines.push(
-      "class ResponseFormat(BaseModel):",
-      '    """Response format for the agent."""',
-      "    result: str",
-      ""
-    );
-  }
-
-  lines.push("agent = create_react_agent(");
-  lines.push("    model,");
-
-  if (tools) lines.push("    tools=[tool],");
-  if (pre) lines.push("    pre_model_hook=pre_model_hook,");
-  if (post) lines.push("    post_model_hook=post_model_hook,");
-  if (response) lines.push("    response_format=ResponseFormat,");
-
-  lines.push(")", "", "agent.get_graph().draw_mermaid_png()");
-
-  return lines.join("\n");
-}
-
-async function render() {
-  const key = getKey();
-  document.getElementById("agent-graph-img").src = `../assets/react_agent_graphs/${key}.svg`;
-
-  const state = {
-    tools: document.getElementById("tools").checked,
-    pre: document.getElementById("pre_model_hook").checked,
-    post: document.getElementById("post_model_hook").checked,
-    response: document.getElementById("response_format").checked
-  };
-
-  document.getElementById("agent-code").textContent = generateCodeSnippet(state);
-}
-
-function initializeWidget() {
-  render(); // no need for `await` here
-  document.querySelectorAll(".agent-graph-features input").forEach((input) => {
-    input.addEventListener("change", render);
-  });
-}
-
-// Init for both full reload and SPA nav (used by MkDocs Material)
-window.addEventListener("DOMContentLoaded", initializeWidget);
-document$.subscribe(initializeWidget);
-</script>

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/agents/tools.md

@@ -280,21 +280,7 @@ LangGraph allows access to short-term and long-term memory from tools. See [Memo
 
 ## Prebuilt tools
 
-You can use prebuilt tools from model providers by passing a dictionary with tool specs to the `tools` parameter of `create_react_agent`. For example, to use the `web_search_preview` tool from OpenAI:
-
-```python
-from langgraph.prebuilt import create_react_agent
-
-agent = create_react_agent(
-    model="openai:gpt-4o-mini", 
-    tools=[{"type": "web_search_preview"}]
-)
-response = agent.invoke(
-    {"messages": ["What was a positive news story from today?"]}
-)
-```
-
-Additionally, LangChain supports a wide range of prebuilt tool integrations for interacting with APIs, databases, file systems, web data, and more. These tools extend the functionality of agents and enable rapid development.
+LangChain supports a wide range of prebuilt tool integrations for interacting with APIs, databases, file systems, web data, and more. These tools extend the functionality of agents and enable rapid development.
 
 You can browse the full list of available integrations in the [LangChain integrations directory](https://python.langchain.com/docs/integrations/tools/).
 

docs/docs/assets/react-agent-graphs.json

@@ -1,19 +0,0 @@
-{
-    "0000": "graph TD;\n\t__start__ --> agent;\n\tagent --> __end__;",
-    "0001": "graph TD;\n\t__start__ --> agent;\n\tagent -.-> __end__;\n\tagent -.-> tools;\n\ttools --> agent;",
-    "0010": "graph TD;\n\t__start__ --> pre_model_hook;\n\tpre_model_hook --> agent;\n\tagent --> __end__;",
-    "0011": "graph TD;\n\t__start__ --> pre_model_hook;\n\tagent -.-> __end__;\n\tagent -.-> tools;\n\tpre_model_hook --> agent;\n\ttools --> pre_model_hook;",
-    "0100": "graph TD;\n\t__start__ --> agent;\n\tagent --> post_model_hook;\n\tpost_model_hook --> __end__;",
-    "0101": "graph TD;\n\t__start__ --> agent;\n\tagent --> post_model_hook;\n\tpost_model_hook -.-> __end__;\n\tpost_model_hook -.-> agent;\n\tpost_model_hook -.-> tools;\n\ttools --> agent;",
-    "0110": "graph TD;\n\t__start__ --> pre_model_hook;\n\tagent --> post_model_hook;\n\tpre_model_hook --> agent;\n\tpost_model_hook --> __end__;",
-    "0111": "graph TD;\n\t__start__ --> pre_model_hook;\n\tagent --> post_model_hook;\n\tpost_model_hook -.-> __end__;\n\tpost_model_hook -.-> pre_model_hook;\n\tpost_model_hook -.-> tools;\n\tpre_model_hook --> agent;\n\ttools --> pre_model_hook;",
-    "1000": "graph TD;\n\t__start__ --> agent;\n\tagent --> generate_structured_response;\n\tgenerate_structured_response --> __end__;",
-    "1001": "graph TD;\n\t__start__ --> agent;\n\tagent -.-> generate_structured_response;\n\tagent -.-> tools;\n\ttools --> agent;\n\tgenerate_structured_response --> __end__;",
-    "1010": "graph TD;\n\t__start__ --> pre_model_hook;\n\tagent --> generate_structured_response;\n\tpre_model_hook --> agent;\n\tgenerate_structured_response --> __end__;",
-    "1011": "graph TD;\n\t__start__ --> pre_model_hook;\n\tagent -.-> generate_structured_response;\n\tagent -.-> tools;\n\tpre_model_hook --> agent;\n\ttools --> pre_model_hook;\n\tgenerate_structured_response --> __end__;",
-    "1100": "graph TD;\n\t__start__ --> agent;\n\tagent --> post_model_hook;\n\tpost_model_hook --> generate_structured_response;\n\tgenerate_structured_response --> __end__;",
-    "1101": "graph TD;\n\t__start__ --> agent;\n\tagent --> post_model_hook;\n\tpost_model_hook -.-> agent;\n\tpost_model_hook -.-> generate_structured_response;\n\tpost_model_hook -.-> tools;\n\ttools --> agent;\n\tgenerate_structured_response --> __end__;",
-    "1110": "graph TD;\n\t__start__ --> pre_model_hook;\n\tagent --> post_model_hook;\n\tpost_model_hook --> generate_structured_response;\n\tpre_model_hook --> agent;\n\tgenerate_structured_response --> __end__;",
-    "1111": "graph TD;\n\t__start__ --> pre_model_hook;\n\tagent --> post_model_hook;\n\tpost_model_hook -.-> generate_structured_response;\n\tpost_model_hook -.-> pre_model_hook;\n\tpost_model_hook -.-> tools;\n\tpre_model_hook --> agent;\n\ttools --> pre_model_hook;\n\tgenerate_structured_response --> __end__;"
-}
-  

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_control_plane.md

@@ -2,8 +2,8 @@
 
 Before deploying, review the [conceptual guide for the Self-Hosted Control Plane](../../concepts/langgraph_self_hosted_control_plane.md) deployment option.
 
-!!! info "Important"
-    The Self-Hosted Control Plane deployment option is currently in beta stage and requires an [Enterprise](../../concepts/plans.md) plan.
+!!! important "Beta"
+    The Self-Hosted Control Plane deployment option is currently in beta stage.
 
 ## Prerequisites
 

docs/docs/cloud/deployment/self_hosted_data_plane.md

@@ -2,8 +2,8 @@
 
 Before deploying, review the [conceptual guide for the Self-Hosted Data Plane](../../concepts/langgraph_self_hosted_data_plane.md) deployment option.
 
-!!! info "Important"
-    The Self-Hosted Data Plane deployment option is currently in beta stage and requires an [Enterprise](../../concepts/plans.md) plan.
+!!! important "Beta"
+    The Self-Hosted Data Plane deployment option is currently in beta stage.
 
 ## Prerequisites
 
@@ -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.md

@@ -129,6 +129,9 @@ workflow.add_edge("action", "agent")
 graph = workflow.compile()
 ```
 
+!!! warning "Assign `CompiledGraph` to Variable"
+    The build process for LangGraph Platform requires that the `CompiledGraph` object be assigned to a variable at the top-level of a Python module (alternatively, you can provide [a function that creates a graph](./graph_rebuild.md)).
+
 Example file directory:
 
 ```bash

docs/docs/cloud/deployment/setup_javascript.md

@@ -155,6 +155,10 @@ const workflow = new StateGraph(MessagesAnnotation)
 export const graph = workflow.compile();
 ```
 
+!!! info "Assign `CompiledGraph` to Variable"
+
+    The build process for LangGraph Platform requires that the `CompiledGraph` object be assigned to a variable at the top-level of a JavaScript module (alternatively, you can provide [a function that creates a graph](./graph_rebuild.md)).
+
 Example file directory:
 
 ```bash

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:
@@ -142,6 +137,9 @@ workflow.add_edge("action", "agent")
 graph = workflow.compile()
 ```
 
+!!! warning "Assign `CompiledGraph` to Variable"
+    The build process for LangGraph Platform requires that the `CompiledGraph` object be assigned to a variable at the top-level of a Python module.
+
 Example file directory:
 
 ```bash

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/cloud/reference/cli.md

@@ -40,7 +40,7 @@ The LangGraph CLI requires a JSON configuration file that follows this [schema](
     | Key                                                          | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
     | ------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
     | <span style="white-space: nowrap;">`dependencies`</span>     | **Required**. Array of dependencies for LangGraph Platform API server. Dependencies can be one of the following: <ul><li>A single period (`"."`), which will look for local Python packages.</li><li>The directory path where `pyproject.toml`, `setup.py` or `requirements.txt` is located.</br></br>For example, if `requirements.txt` is located in the root of the project directory, specify `"./"`. If it's located in a subdirectory called `local_package`, specify `"./local_package"`. Do not specify the string `"requirements.txt"` itself.</li><li>A Python package name.</li></ul> |
-    | <span style="white-space: nowrap;">`graphs`</span>           | **Required**. Mapping from graph ID to path where the compiled graph or a function that makes a graph is defined. Example: <ul><li>`./your_package/your_file.py:variable`, where `variable` is an instance of `langgraph.graph.state.CompiledStateGraph`</li><li>`./your_package/your_file.py:make_graph`, where `make_graph` is a function that takes a config dictionary (`langchain_core.runnables.RunnableConfig`) and returns an instance of `langgraph.graph.state.StateGraph` or `langgraph.graph.state.CompiledStateGraph`. See [how to rebuild a graph at runtime](../../cloud/deployment/graph_rebuild.md) for more details.</li></ul>                                    |
+    | <span style="white-space: nowrap;">`graphs`</span>           | **Required**. Mapping from graph ID to path where the compiled graph or a function that makes a graph is defined. Example: <ul><li>`./your_package/your_file.py:variable`, where `variable` is an instance of `langgraph.graph.state.CompiledStateGraph`</li><li>`./your_package/your_file.py:make_graph`, where `make_graph` is a function that takes a config dictionary (`langchain_core.runnables.RunnableConfig`) and creates an instance of `langgraph.graph.state.StateGraph` / `langgraph.graph.state.CompiledStateGraph`.</li></ul>                                    |
     | <span style="white-space: nowrap;">`auth`</span>             | _(Added in v0.0.11)_ Auth configuration containing the path to your authentication handler. Example: `./your_package/auth.py:auth`, where `auth` is an instance of `langgraph_sdk.Auth`. See [authentication guide](../../concepts/auth.md) for details.                                                                                                                                                                                                                                                                                                                        |
     | <span style="white-space: nowrap;">`base_image`</span>       | Optional. Base image to use for the LangGraph API server. Defaults to `langchain/langgraph-api` or `langchain/langgraphjs-api`. Use this to pin your builds to a particular version of the langgraph API, such as `"langchain/langgraph-server:0.2"`. See https://hub.docker.com/r/langchain/langgraph-server/tags for more details. (added in `langgraph-cli==0.2.8`) |
     | <span style="white-space: nowrap;">`env`</span>              | Path to `.env` file or a mapping from environment variable to its value.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
@@ -57,7 +57,7 @@ The LangGraph CLI requires a JSON configuration file that follows this [schema](
 
     | Key                                                          | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
     | ------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-    | <span style="white-space: nowrap;">`graphs`</span>           | **Required**. Mapping from graph ID to path where the compiled graph or a function that makes a graph is defined. Example: <ul><li>`./src/graph.ts:variable`, where `variable` is an instance of `CompiledStateGraph`</li><li>`./src/graph.ts:makeGraph`, where `makeGraph` is a function that takes a config dictionary (`LangGraphRunnableConfig`) and returns an instance of `StateGraph` or `CompiledStateGraph`. See [how to rebuild a graph at runtime](../../cloud/deployment/graph_rebuild.md) for more details.</li></ul>                                    |
+    | <span style="white-space: nowrap;">`graphs`</span>           | **Required**. Mapping from graph ID to path where the compiled graph or a function that makes a graph is defined. Example: <ul><li>`./src/graph.ts:variable`, where `variable` is an instance of `CompiledStateGraph`</li><li>`./src/graph.ts:makeGraph`, where `makeGraph` is a function that takes a config dictionary (`LangGraphRunnableConfig`) and creates an instance of `StateGraph` / `CompiledStateGraph`.</li></ul>                                    |
     | <span style="white-space: nowrap;">`env`</span>              | Path to `.env` file or a mapping from environment variable to its value.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
     | <span style="white-space: nowrap;">`store`</span>            | Configuration for adding semantic search and/or time-to-live (TTL) to the BaseStore. Contains the following fields: <ul><li>`index` (optional): Configuration for semantic search indexing with fields `embed`, `dims`, and optional `fields`.</li><li>`ttl` (optional): Configuration for item expiration. An object with optional fields: `refresh_on_read` (boolean, defaults to `true`), `default_ttl` (float, lifespan in **minutes**, defaults to no expiration), and `sweep_interval_minutes` (integer, how often to check for expired items, defaults to no sweeping).</li></ul> |
     | <span style="white-space: nowrap;">`node_version`</span>     | Specify `node_version: 20` to use LangGraph.js.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |

docs/docs/concepts/deployment_options.md

@@ -40,8 +40,8 @@ For more information, please see:
 
 ## Self-Hosted Data Plane
 
-!!! info "Important"
-    The Self-Hosted Data Plane deployment option is currently in beta stage and requires an [Enterprise](../concepts/plans.md) plan.
+!!! important "Beta"
+    The Self-Hosted Data Plane deployment option is currently in beta stage.
 
 The [Self-Hosted Data Plane](./langgraph_self_hosted_data_plane.md) deployment option is a "hybrid" model for deployment where we manage the [control plane](./langgraph_control_plane.md) in our cloud and you manage the [data plane](./langgraph_data_plane.md) in your cloud. This option provides a way to securely manage your data plane infrastructure, while offloading control plane management to us.
 
@@ -56,8 +56,8 @@ For more information, please see:
 
 ## Self-Hosted Control Plane
 
-!!! info "Important"
-    The Self-Hosted Control Plane deployment option is currently in beta stage and requires an [Enterprise](../concepts/plans.md) plan.
+!!! important "Beta"
+    The Self-Hosted Control Plane deployment option is currently in beta stage.
 
 The [Self-Hosted Control Plane](./langgraph_self_hosted_control_plane.md) deployment option is a fully self-hosted model for deployment where you manage the [control plane](./langgraph_control_plane.md) and [data plane](./langgraph_data_plane.md) in your cloud. This option give you full control and responsibility of the control plane and data plane infrastructure.
 

docs/docs/concepts/langgraph_self_hosted_control_plane.md

@@ -2,8 +2,8 @@
 
 There are two versions of the self-hosted deployment: [Self-Hosted Data Plane](./deployment_options.md#self-hosted-data-plane) and [Self-Hosted Control Plane](./deployment_options.md#self-hosted-control-plane).
 
-!!! info "Important"
-    The Self-Hosted Control Plane deployment option is currently in beta stage and requires an [Enterprise](../../concepts/plans.md) plan.
+!!! important "Beta"
+    The Self-Hosted Control Plane deployment option is currently in beta stage.
 
 ## Requirements
 

docs/docs/concepts/langgraph_self_hosted_data_plane.md

@@ -7,8 +7,8 @@ search:
 
 There are two versions of the self-hosted deployment: [Self-Hosted Data Plane](./deployment_options.md#self-hosted-data-plane) and [Self-Hosted Control Plane](./deployment_options.md#self-hosted-control-plane).
 
-!!! info "Important"
-    The Self-Hosted Data Plane deployment option is currently in beta stage and requires an [Enterprise](../../concepts/plans.md) plan.
+!!! important "Beta"
+    The Self-Hosted Data Plane deployment option is currently in beta stage.
 
 ## Requirements
 

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/concepts/pregel.md

@@ -180,7 +180,7 @@ Below are a few different examples to give you a sense of the Pregel API.
 
     def reducer(current, update):
         if current:
-            return current + " | " + update
+            return current + " | " + "update"
         else:
             return update
 

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/llms.txt

@@ -1,149 +1,202 @@
+# LangGraph
 
-# Guides
+## Tutorials
 
-- [LangGraph Documentation](https://langchain-ai.github.io/langgraph/index/): This page provides an overview of the LangGraph project, including its logo and essential scripts for functionality within MkDocs. It also includes a reference to the README.md file for detailed information about the project. The content is designed to be user-friendly and visually appealing.
-- [LangGraph Quickstart Guide](https://langchain-ai.github.io/langgraph/agents/agents/): This quickstart guide provides step-by-step instructions for setting up and using LangGraph's prebuilt components to create agentic systems. It covers prerequisites, installation, agent creation, configuration of language models, and advanced features like memory and structured output. Ideal for developers looking to leverage LangGraph for building intelligent agents.
-- [Getting Started with LangGraph: Building AI Agents](https://langchain-ai.github.io/langgraph/concepts/why-langgraph/): This page provides an overview of LangGraph, a platform designed for developers to create adaptable AI agents. It highlights key features such as reliability, extensibility, and streaming support, and offers a series of tutorials to help users build a support chatbot with various capabilities. By following the tutorials, developers will learn to implement essential functionalities like conversation state management and human-in-the-loop controls.
-- [Building a Basic Chatbot with LangGraph](https://langchain-ai.github.io/langgraph/tutorials/get-started/1-build-basic-chatbot/): This tutorial guides you through the process of creating a basic chatbot using LangGraph. It covers prerequisites, installation of necessary packages, and step-by-step instructions to set up a state machine for the chatbot. By the end of the tutorial, you will have a functional chatbot that can engage in simple conversations.
-- [Integrating Web Search Tools into Your Chatbot](https://langchain-ai.github.io/langgraph/tutorials/get-started/2-add-tools/): This tutorial guides you through the process of enhancing your chatbot's capabilities by integrating a web search tool, specifically the Tavily Search Engine. It covers prerequisites, installation, configuration, and the implementation of the search tool within a LangGraph-based chatbot. By the end, you'll have a functional chatbot that can retrieve real-time information to answer user queries beyond its training data.
-- [Implementing Memory in Chatbots with LangGraph](https://langchain-ai.github.io/langgraph/tutorials/get-started/3-add-memory/): This page provides a comprehensive guide on how to add memory functionality to chatbots using LangGraph's persistent checkpointing feature. It details the steps to create a `MemorySaver` checkpointer, compile the graph, and interact with the chatbot to maintain context across multiple interactions. Additionally, it explains how to inspect the state of the chatbot and highlights the advantages of checkpointing over simple memory solutions.
-- [Implementing Human-in-the-Loop Controls in LangGraph](https://langchain-ai.github.io/langgraph/tutorials/get-started/4-human-in-the-loop/): This page provides a comprehensive guide on adding human-in-the-loop controls to LangGraph workflows, enabling agents to pause execution for human input. It details the use of the `interrupt` function to facilitate user feedback and outlines the steps to integrate a `human_assistance` tool into a chatbot. Additionally, the tutorial covers graph compilation, visualization, and resuming execution with human input.
-- [Customizing State in LangGraph for Enhanced Chatbot Functionality](https://langchain-ai.github.io/langgraph/tutorials/get-started/5-customize-state/): This tutorial guides you through the process of adding custom fields to the state in LangGraph, enabling complex behaviors in your chatbot without relying solely on message lists. You will learn how to implement human-in-the-loop controls to verify information before it is stored in the state. By the end of this tutorial, you will have a deeper understanding of state management and how to enhance your chatbot's capabilities.
-- [Implementing Time Travel in LangGraph Chatbots](https://langchain-ai.github.io/langgraph/tutorials/get-started/6-time-travel/): This page provides a comprehensive guide on utilizing the time travel functionality in LangGraph to enhance chatbot interactions. It covers how to rewind, add steps, and replay the state history of a chatbot, allowing users to explore different outcomes and fix mistakes. Additionally, it includes code snippets and practical examples to help developers implement these features effectively.
-- [LangGraph Deployment Options](https://langchain-ai.github.io/langgraph/tutorials/deployment/): This page outlines the various options available for deploying LangGraph applications, including local testing and different cloud-based solutions. It details free deployment methods such as Local and Standalone Container (Lite), as well as production options like Cloud SaaS and self-hosted solutions. Each deployment method is linked to further documentation for in-depth guidance.
-- [Agent Development with LangGraph](https://langchain-ai.github.io/langgraph/agents/overview/): This page provides an overview of agent development using LangGraph, highlighting its prebuilt components and capabilities for building agent-based applications. It explains the structure of an agent, key features such as memory integration and human-in-the-loop control, and outlines the package ecosystem available for developers. With LangGraph, users can focus on application logic while leveraging robust infrastructure for state management and feedback.
-- [Guide to Running Agents in LangGraph](https://langchain-ai.github.io/langgraph/agents/run_agents/): This page provides a comprehensive overview of how to execute agents in LangGraph, detailing both synchronous and asynchronous methods. It covers input and output formats, streaming capabilities, and how to manage execution limits to prevent infinite loops. Additionally, it includes code examples and links to further resources for deeper understanding.
-- [Streaming Data in LangGraph](https://langchain-ai.github.io/langgraph/agents/streaming/): This page provides an overview of streaming data types in LangGraph, including agent progress, LLM tokens, and custom updates. It includes code examples for both synchronous and asynchronous streaming methods. Additionally, it covers how to stream multiple modes and disable streaming when necessary.
-- [Configuring Chat Models for Agents](https://langchain-ai.github.io/langgraph/agents/models/): This page provides detailed instructions on how to configure various chat models for use with agents in LangChain. It covers model initialization, tool calling support, and how to specify models from different providers such as OpenAI, Anthropic, Azure, Google Gemini, and AWS Bedrock. Additionally, it includes information on disabling streaming, adding model fallbacks, and links to further resources.
-- [Using Tools in LangChain](https://langchain-ai.github.io/langgraph/agents/tools/): This page provides an overview of how to define, customize, and manage tools within the LangChain framework. It covers creating simple tools, handling tool errors, and utilizing prebuilt integrations for enhanced functionality. Additionally, it discusses advanced features such as memory management and controlling tool behavior during agent execution.
-- [Integrating MCP with LangGraph Agents](https://langchain-ai.github.io/langgraph/agents/mcp/): This page provides a comprehensive guide on how to integrate the Model Context Protocol (MCP) with LangGraph agents using the `langchain-mcp-adapters` library. It includes installation instructions, example code for using MCP tools, and guidance on creating custom MCP servers. Additional resources for further reading on MCP are also provided.
-- [Understanding Context in LangGraph Agents](https://langchain-ai.github.io/langgraph/agents/context/): This page provides an overview of how to supply context to agents in LangGraph, detailing the three primary types: Config, State, and Long-Term Memory. It explains how to use these context types to enhance agent behavior, customize prompts, and access context in tools. Additionally, it includes code examples for implementing context in various scenarios.
-- [Understanding Memory in LangGraph for Conversational Agents](https://langchain-ai.github.io/langgraph/agents/memory/): This documentation page provides an overview of the two types of memory supported by LangGraph: short-term and long-term memory. It explains how to implement these memory types in conversational agents, including code examples and best practices for managing message history. Additionally, it covers the use of persistent storage and tools for enhancing memory functionality.
-- [Implementing Human-in-the-Loop in LangGraph](https://langchain-ai.github.io/langgraph/agents/human-in-the-loop/): This documentation page provides a comprehensive guide on how to implement Human-in-the-Loop (HIL) features in LangGraph, allowing for human review and approval of tool calls in agents. It covers the use of the `interrupt()` function to pause execution for human input, along with practical examples and code snippets. Additionally, it explains how to create a wrapper to add HIL capabilities to any tool seamlessly.
-- [Building Multi-Agent Systems](https://langchain-ai.github.io/langgraph/agents/multi-agent/): This page provides an overview of multi-agent systems, detailing how to create and manage them using supervisor and swarm architectures. It includes practical examples of implementing a flight and hotel booking assistant using the LangGraph libraries. Additionally, the page explains the concept of handoffs between agents, allowing for seamless communication and task delegation.
-- [Evaluating Agent Performance with LangSmith](https://langchain-ai.github.io/langgraph/agents/evals/): This page provides a comprehensive guide on how to evaluate the performance of agents using the LangSmith evaluations framework. It includes instructions on defining evaluator functions, utilizing prebuilt evaluators from the AgentEvals package, and running evaluations with specific datasets. Additionally, it covers different evaluation techniques, including trajectory matching and using LLMs as judges.
-- [Deploying Your LangGraph Agent](https://langchain-ai.github.io/langgraph/agents/deployment/): This page provides a comprehensive guide on how to deploy a LangGraph agent, including setting up a LangGraph app for both local development and production. It covers essential features, installation steps, and configuration requirements, along with instructions for launching the local server and utilizing the LangGraph Studio Web UI for debugging. Additionally, it offers links to further resources for deployment options.
-- [Agent Chat UI Documentation](https://langchain-ai.github.io/langgraph/agents/ui/): This page provides comprehensive guidance on using the Agent Chat UI for interacting with LangGraph agents. It covers setup instructions, features like human-in-the-loop workflows, and the integration of generative UI components. Users can find links to relevant resources and tips for customizing their chat experience.
-- [Overview of Agent Architectures in LLM Applications](https://langchain-ai.github.io/langgraph/concepts/agentic_concepts/): This page provides a comprehensive overview of various agent architectures used in large language model (LLM) applications, highlighting their control flows and functionalities. It discusses key concepts such as routers, tool-calling agents, memory management, and planning, along with customization options for specific tasks. Additionally, it covers advanced features like human-in-the-loop, parallelization, subgraphs, and reflection mechanisms to enhance agent performance.
-- [Understanding Workflows and Agents in LangGraph](https://langchain-ai.github.io/langgraph/tutorials/workflows/): This documentation page provides an in-depth overview of workflows and agents within LangGraph, highlighting their differences and use cases. It covers various patterns for building agentic systems, including setup instructions, building blocks, and advanced concepts like prompt chaining, parallelization, and routing. Additionally, it offers practical examples and code snippets to help users implement these workflows effectively.
-- [Understanding LangGraph: Core Concepts and Components](https://langchain-ai.github.io/langgraph/concepts/low_level/): This documentation page provides an in-depth overview of the core concepts of LangGraph, focusing on how agent workflows are modeled as graphs. It covers essential components such as States, Nodes, and Edges, and explains how they interact to create complex workflows. Additionally, it discusses graph compilation, message handling, and configuration options to enhance the functionality of your graphs.
-- [LangGraph Runtime Overview](https://langchain-ai.github.io/langgraph/concepts/pregel/): This page provides a comprehensive overview of the LangGraph runtime, specifically focusing on the Pregel execution model. It details the structure and functionality of actors and channels within the Pregel framework, along with examples of how to implement applications. Additionally, it introduces high-level APIs for creating Pregel applications using StateGraph and Functional API.
-- [Using the LangGraph API: A Comprehensive Guide](https://langchain-ai.github.io/langgraph/how-tos/graph-api/): This documentation provides a detailed overview of how to utilize the LangGraph Graph API, covering essential concepts such as state management, node creation, and control flow. It includes practical examples for building sequences, branches, and loops, as well as advanced features like retry policies and async execution. Additionally, the guide offers insights into visualizing graphs and integrating with external tools.
-- [LangGraph Streaming System](https://langchain-ai.github.io/langgraph/concepts/streaming/): This page provides an overview of the streaming capabilities of LangGraph, enabling real-time updates for enhanced user experiences. It details the types of data that can be streamed, including workflow progress, LLM tokens, and custom updates. Additionally, it outlines various functionalities and modes available for streaming within the LangGraph framework.
-- [Streaming Outputs in LangGraph](https://langchain-ai.github.io/langgraph/how-tos/streaming/): This documentation page provides an overview of how to utilize the streaming capabilities of LangGraph, including synchronous and asynchronous streaming methods. It covers various stream modes, such as updates, values, and custom data, along with examples of how to implement them in your graphs. Additionally, it discusses the integration of Large Language Models (LLMs) and how to handle streaming outputs effectively.
-- [LangGraph Persistence and Checkpointing](https://langchain-ai.github.io/langgraph/concepts/persistence/): This page provides an in-depth overview of the persistence layer in LangGraph, focusing on the use of checkpointers to save graph states at each super-step. It covers key concepts such as threads, checkpoints, state retrieval, and memory management, along with practical examples and code snippets. Additionally, it discusses advanced features like time travel, fault tolerance, and the integration of memory stores for cross-thread information retention.
-- [Understanding Durable Execution in LangGraph](https://langchain-ai.github.io/langgraph/concepts/durable_execution/): This page provides an overview of durable execution, a technique that allows workflows to save their progress and resume from key points. It details the requirements for implementing durable execution in LangGraph, including the use of persistence and tasks to ensure deterministic and consistent replay. Additionally, it covers how to handle pausing, resuming, and recovering workflows effectively.
-- [Implementing Memory in LangGraph for AI Applications](https://langchain-ai.github.io/langgraph/how-tos/persistence/): This documentation page provides a comprehensive guide on adding persistence to AI applications using LangGraph. It covers both short-term and long-term memory implementations, including code examples for managing conversation context and user-specific data. Additionally, it discusses the use of various storage backends and semantic search capabilities for enhanced memory management.
-- [Understanding Memory in AI Agents](https://langchain-ai.github.io/langgraph/concepts/memory/): This documentation page provides an in-depth overview of memory types in AI agents, focusing on short-term and long-term memory. It explains how these memory types can be implemented and managed within applications using LangGraph, including techniques for handling conversation history and storing memories. Additionally, it discusses the importance of memory in enhancing user interactions and the various strategies for writing and updating memories.
-- [Memory Management in LangGraph for AI Applications](https://langchain-ai.github.io/langgraph/how-tos/memory/): This page provides an overview of memory management in LangGraph, focusing on short-term and long-term memory functionalities essential for conversational agents. It includes detailed instructions on how to implement memory strategies such as trimming, summarizing, and deleting messages to optimize conversation tracking without exceeding context limits. Code examples are provided to illustrate the implementation of these memory management techniques.
-- [Human-in-the-Loop Workflows in LangGraph](https://langchain-ai.github.io/langgraph/concepts/human_in_the_loop/): This page provides an overview of the human-in-the-loop (HIL) capabilities within LangGraph, highlighting how human intervention can enhance automated processes. It details key features such as persistent execution state and flexible integration points, along with typical use cases for validating outputs and providing context. Additionally, it outlines the implementation of HIL through specific functions and primitives.
-- [Implementing Human-in-the-Loop Workflows with Interrupts](https://langchain-ai.github.io/langgraph/how-tos/human_in_the_loop/add-human-in-the-loop/): This documentation page provides a comprehensive guide on using the `interrupt` function in LangGraph to facilitate human-in-the-loop workflows. It covers the implementation details, design patterns, and best practices for pausing graph execution to gather human input, as well as how to resume execution with that input. Additionally, it highlights common pitfalls and offers extended examples to illustrate various use cases.
-- [Understanding Breakpoints in LangGraph](https://langchain-ai.github.io/langgraph/concepts/breakpoints/): This page provides an overview of breakpoints in LangGraph, which allow users to pause graph execution at specific points for inspection. It explains how breakpoints utilize the persistence layer to save the graph state and how execution can be resumed after inspection. An illustrative example is included to demonstrate the concept visually.
-- [Using Breakpoints in Graph Execution](https://langchain-ai.github.io/langgraph/how-tos/human_in_the_loop/breakpoints/): This page provides a comprehensive guide on how to implement breakpoints in graph execution for debugging purposes. It covers the requirements for setting breakpoints, the difference between static and dynamic breakpoints, and includes code examples for both compile-time and run-time configurations. Additionally, it explains how to manage breakpoints in subgraphs.
-- [Time Travel Functionality in LangGraph](https://langchain-ai.github.io/langgraph/concepts/time-travel/): This page explains the time travel feature in LangGraph, which allows users to analyze and debug decision-making processes in non-deterministic systems. It outlines how to understand reasoning, debug mistakes, and explore alternative solutions by resuming execution from prior checkpoints. The functionality enables users to create new forks in the execution history for deeper insights.
-- [Using Time-Travel in LangGraph](https://langchain-ai.github.io/langgraph/how-tos/human_in_the_loop/time-travel/): This page provides a comprehensive guide on how to implement time-travel functionality in LangGraph. It outlines the steps to run a graph, identify checkpoints, modify graph states, and resume execution from specific checkpoints. Additionally, an example workflow is included to illustrate the process of generating and modifying jokes using LangGraph.
-- [Integrating Tools with AI Models](https://langchain-ai.github.io/langgraph/concepts/tools/): This page provides an overview of how AI models can interact with external systems using tool calling. It explains the concept of tools, their integration with chat models, and how to create or use prebuilt tools for various applications. Additionally, it highlights the importance of relevance in tool invocation and offers links to further resources and guides.
-- [Using Tools in LangChain](https://langchain-ai.github.io/langgraph/how-tos/tool-calling/): This documentation page provides a comprehensive guide on how to create and utilize tools within the LangChain framework. It covers defining simple and customized tools, managing tool arguments, accessing configuration and state, and integrating tools with chat models and agents. Additionally, it discusses error handling and strategies for managing a large number of tools.
-- [Understanding Subgraphs in LangGraph](https://langchain-ai.github.io/langgraph/concepts/subgraphs/): This page provides an overview of subgraphs in LangGraph, explaining their role as encapsulated nodes within larger graphs. It discusses the benefits of using subgraphs, such as facilitating multi-agent systems and enabling independent team work. Additionally, it outlines the communication methods between parent graphs and subgraphs, detailing scenarios involving shared and different state schemas.
-- [Using Subgraphs in LangGraph](https://langchain-ai.github.io/langgraph/how-tos/subgraph/): This guide provides an overview of how to effectively use subgraphs within LangGraph, including communication methods between parent graphs and subgraphs. It covers shared and different state schemas, setup instructions, and examples for implementing subgraphs in multi-agent systems. Additionally, it discusses persistence, state management, and streaming outputs from subgraphs.
-- [Understanding Multi-Agent Systems](https://langchain-ai.github.io/langgraph/concepts/multi_agent/): This page provides an in-depth overview of multi-agent systems, focusing on the architecture and benefits of using multiple independent agents to manage complex applications. It discusses various multi-agent architectures, including network, supervisor, and hierarchical models, as well as communication strategies and state management techniques for effective agent interaction.
-- [Building Multi-Agent Systems with LangGraph](https://langchain-ai.github.io/langgraph/how-tos/multi_agent/): This guide provides an overview of how to build multi-agent systems using LangGraph, focusing on the implementation of handoffs for agent communication. It covers the creation of independent agents, the use of handoffs to transfer control and data between agents, and examples of prebuilt multi-agent architectures. Additionally, it includes code snippets and best practices for managing agent interactions and state.
-- [Understanding the Functional API in LangGraph](https://langchain-ai.github.io/langgraph/concepts/functional_api/): This documentation page provides an overview of the Functional API in LangGraph, detailing its key features such as persistence, memory, and human-in-the-loop capabilities. It explains how to define workflows using the `@entrypoint` and `@task` decorators, along with examples and best practices for implementing workflows with state management and streaming. Additionally, it compares the Functional API with the Graph API, highlighting their differences and use cases.
-- [Functional API Documentation](https://langchain-ai.github.io/langgraph/how-tos/use-functional-api/): This page provides comprehensive guidance on using the Functional API, including creating workflows, handling parallel execution, and integrating with other APIs. It covers various features such as retry policies, caching, and human-in-the-loop workflows, along with practical examples. Additionally, it discusses memory management strategies for both short-term and long-term use cases.
-- [Overview of LangGraph Platform](https://langchain-ai.github.io/langgraph/concepts/langgraph_platform/): The LangGraph Platform is designed for developing, deploying, and managing long-running agent workflows with ease. This page outlines the platform's features, including streaming support, background runs, and memory management, which enhance the performance and reliability of agent applications. Additionally, it provides links to resources for getting started and deploying agents effectively.
-- [LangGraph Platform Quickstart Guide](https://langchain-ai.github.io/langgraph/tutorials/langgraph-platform/local-server/): This quickstart guide provides step-by-step instructions for running a LangGraph application locally. It covers prerequisites, installation of the LangGraph CLI, app creation, dependency installation, and launching the server. Additionally, it includes testing your application using the LangGraph Studio and API.
-- [LangGraph Platform Deployment Quickstart](https://langchain-ai.github.io/langgraph/cloud/quick_start/): This quickstart guide provides step-by-step instructions for deploying an application on the LangGraph Platform using GitHub. It covers prerequisites, repository creation, deployment procedures, and testing your application and API. Follow these steps to successfully set up and run your application in the LangGraph environment.
-- [Overview of LangGraph Platform Components](https://langchain-ai.github.io/langgraph/concepts/langgraph_components/): This page provides a comprehensive overview of the various components that make up the LangGraph Platform. It details the functionalities of each component, including the LangGraph Server, CLI, Studio, SDKs, and the control and data planes. Users can learn how these components work together to facilitate the development, deployment, and management of LangGraph applications.
-- [LangGraph Server Documentation](https://langchain-ai.github.io/langgraph/concepts/langgraph_server/): This page provides an overview of the LangGraph Server, an API designed for creating and managing agent-based applications. It details the server versions, application structure, deployment components, and the use of assistants, persistence, and task queues. Additionally, it includes links to further resources and guides for effective deployment and usage.
-- [LangGraph Application Structure Guide](https://langchain-ai.github.io/langgraph/concepts/application_structure/): This page provides an overview of the structure of a LangGraph application, detailing the essential components such as the configuration file, dependencies, graphs, and environment variables. It includes examples of directory structures for both Python and JavaScript applications, as well as guidance on how to specify the necessary information for deployment. Additionally, it covers key concepts related to the configuration file and the role of dependencies and environment variables in the application.
-- [Setting Up a LangGraph Application with requirements.txt](https://langchain-ai.github.io/langgraph/cloud/deployment/setup/): This guide provides step-by-step instructions for configuring a LangGraph application for deployment using a requirements.txt file to manage dependencies. It covers essential topics such as specifying dependencies, defining environment variables, and creating the LangGraph configuration file. Additionally, it includes examples and tips for alternative setup methods.
-- [Setting Up a LangGraph Application with pyproject.toml](https://langchain-ai.github.io/langgraph/cloud/deployment/setup_pyproject/): This guide provides step-by-step instructions for configuring a LangGraph application using the `pyproject.toml` file for dependency management. It covers the necessary components, including specifying dependencies, environment variables, and defining graphs, along with examples and best practices. Additionally, it offers tips for alternative setups and links to further resources for deployment.
-- [Setting Up a LangGraph.js Application](https://langchain-ai.github.io/langgraph/cloud/deployment/setup_javascript/): This guide provides step-by-step instructions for configuring a LangGraph.js application for deployment on the LangGraph Platform or for self-hosting. It covers essential topics such as specifying dependencies, environment variables, defining graphs, and creating the necessary configuration file. By following this walkthrough, users will learn how to structure their application and prepare it for deployment.
-- [Customizing Your Dockerfile in LangGraph](https://langchain-ai.github.io/langgraph/cloud/deployment/custom_docker/): This page provides a guide on how to customize your Dockerfile by adding additional commands through the `langgraph.json` configuration file. It explains how to specify the `dockerfile_lines` key to include necessary dependencies, such as installing system packages and Python libraries. An example is provided to illustrate the process of integrating the Pillow library for image processing.
-- [LangGraph CLI Documentation](https://langchain-ai.github.io/langgraph/concepts/langgraph_cli/): This page provides an overview of the LangGraph CLI, a command-line tool for building and running the LangGraph API server locally. It includes installation instructions, a list of core commands, and their descriptions to help users effectively utilize the CLI for development and deployment. For further details, users can refer to the LangGraph CLI Reference.
-- [LangGraph Studio Documentation](https://langchain-ai.github.io/langgraph/concepts/langgraph_studio/): This page provides an overview of LangGraph Studio, an IDE for visualizing, interacting with, and debugging agentic systems that utilize the LangGraph Server API. It outlines the prerequisites for using the studio, key features, and the two operational modes: Graph mode and Chat mode. Additionally, it includes links to further resources for getting started with LangGraph Studio.
-- [Getting Started with LangGraph Studio](https://langchain-ai.github.io/langgraph/cloud/how-tos/studio/quick_start/): This page provides a comprehensive guide on how to connect and use LangGraph Studio with both deployed applications on the LangGraph Platform and local development servers. It includes instructions for installation, running the server, accessing the Studio UI, and debugging options. Additionally, troubleshooting tips and next steps for further exploration of LangGraph Studio features are also provided.
-- [Running Applications: A Comprehensive Guide](https://langchain-ai.github.io/langgraph/cloud/how-tos/invoke_studio/): This page provides a detailed guide on how to submit a run to your application, covering both Graph and Chat modes. It includes instructions on specifying input, managing assistants, enabling streaming, and using breakpoints. Additionally, it offers tips for running applications from specific checkpoints in existing threads.
-- [Managing Assistants in LangGraph Studio](https://langchain-ai.github.io/langgraph/cloud/how-tos/studio/manage_assistants/): This page provides guidance on how to manage assistants within LangGraph Studio, including viewing, editing, and updating assistant configurations. It covers both Graph mode and Chat mode, detailing how to activate assistants and make changes to their settings. Users will learn how to navigate the interface to effectively manage their assistant configurations for graph runs.
-- [Managing Threads in Studio](https://langchain-ai.github.io/langgraph/cloud/how-tos/threads_studio/): This page provides a comprehensive guide on how to view and edit threads within the Studio application. It covers both Graph and Chat modes, detailing the steps to create new threads, view thread history, and edit thread states. Additionally, it includes links to related concepts for further learning.
-- [Modifying Prompts in LangGraph Studio](https://langchain-ai.github.io/langgraph/cloud/how-tos/iterate_graph_studio/): This page provides guidance on how to modify prompts within LangGraph Studio using two methods: direct node editing and the LangSmith Playground interface. It details the configuration options available for nodes, including `langgraph_nodes` and `langgraph_type`, along with examples for both Pydantic models and dataclasses. Additionally, it outlines the steps for editing prompts in the UI and utilizing the LangSmith Playground for testing LLM calls.
-- [Debugging LangSmith Traces in LangGraph Studio](https://langchain-ai.github.io/langgraph/cloud/how-tos/clone_traces_studio/): This guide provides step-by-step instructions for opening and debugging LangSmith traces in LangGraph Studio. It covers how to deploy threads and test local agents with remote traces, ensuring a seamless debugging experience. Additionally, it outlines the requirements for local agents and the process for cloning threads for local testing.
-- [How to Add Nodes to LangSmith Datasets](https://langchain-ai.github.io/langgraph/cloud/how-tos/datasets_studio/): This guide provides step-by-step instructions on how to add examples from nodes in the thread log to LangSmith datasets. It covers selecting threads, choosing nodes, and editing inputs/outputs before adding them to the dataset. Additionally, it includes links to further resources on evaluating intermediate steps.
-- [LangGraph SDK Documentation](https://langchain-ai.github.io/langgraph/concepts/sdk/): This page provides an overview of the LangGraph SDK, including installation instructions for both Python and JavaScript. It details the synchronous and asynchronous client options available for interacting with the LangGraph Server. Additionally, it offers links to further resources and references for the SDK.
-- [Integrating Semantic Search in LangGraph](https://langchain-ai.github.io/langgraph/cloud/deployment/semantic_search/): This guide provides step-by-step instructions on how to implement semantic search in your LangGraph deployment. It covers prerequisites, configuration of the store, and usage examples for searching memories and documents by semantic similarity. Additionally, it includes information on using custom embeddings and querying via the LangGraph SDK.
-- [Configuring Time-to-Live (TTL) in LangGraph Applications](https://langchain-ai.github.io/langgraph/how-tos/ttl/configure_ttl/): This guide provides detailed instructions on how to configure Time-to-Live (TTL) settings for checkpoints and store items in LangGraph applications. It covers the necessary configurations in the `langgraph.json` file, including strategies for managing data lifecycle and memory. Additionally, it explains how to combine TTL configurations and override them at runtime.
-- [LangGraph Authentication & Access Control Overview](https://langchain-ai.github.io/langgraph/concepts/auth/): This page provides a comprehensive guide to the authentication and authorization mechanisms within the LangGraph Platform. It explains the core concepts of authentication versus authorization, outlines default security models, and details the system architecture involved in user identity management. Additionally, it covers implementation examples for authentication and authorization handlers, along with common access patterns and supported resources.
-- [Custom Authentication Setup for LangGraph Platform](https://langchain-ai.github.io/langgraph/how-tos/auth/custom_auth/): This guide provides step-by-step instructions on how to implement custom authentication in your LangGraph Platform application. It covers the necessary prerequisites, implementation details, configuration updates, and client connection methods. The guide is applicable to both managed and Enterprise self-hosted deployments, but not to Lite self-hosted plans.
-- [Documenting API Authentication in OpenAPI for LangGraph](https://langchain-ai.github.io/langgraph/how-tos/auth/openapi_security/): This guide provides instructions on how to customize the security schema for your LangGraph Platform API documentation using OpenAPI. It covers default security schemes for both LangGraph Platform and self-hosted deployments, as well as how to implement custom authentication. Additionally, it includes examples for OAuth2 and API key authentication, along with testing procedures.
-- [Managing Assistants in LangGraph](https://langchain-ai.github.io/langgraph/concepts/assistants/): This page provides an overview of how to create and manage assistants within the LangGraph Platform, which allows for separate configuration of agents without altering the core graph logic. It covers the prerequisites, configuration options, and versioning of assistants, highlighting their role in optimizing agent performance for different tasks. Additionally, it includes links to relevant API references and how-to guides for further assistance.
-- [Managing Assistants in LangGraph](https://langchain-ai.github.io/langgraph/cloud/how-tos/configuration_cloud/): This documentation page provides a comprehensive guide on how to create, configure, and manage assistants using the LangGraph SDK and Platform UI. It includes code examples in Python and JavaScript, as well as instructions for creating new versions and using previous versions of assistants. Additionally, it covers the process of utilizing assistants in various environments.
-- [Understanding Threads in LangGraph](https://langchain-ai.github.io/langgraph/cloud/concepts/threads/): This page provides an overview of threads in the LangGraph framework, detailing how they accumulate the state of runs and the importance of checkpoints. It explains the process of creating threads and retrieving their current and historical states. Additionally, it offers links to further resources on threads, checkpoints, and the LangGraph API for managing thread states.
-- [Managing Threads in LangGraph](https://langchain-ai.github.io/langgraph/cloud/how-tos/use_threads/): This documentation page provides a comprehensive guide on how to create, view, and inspect threads using the LangGraph SDK. It includes detailed instructions for creating empty threads, copying existing threads, and initializing threads with prepopulated states. Additionally, it covers how to list and inspect threads, including filtering and sorting options.
-- [Understanding Runs in LangGraph Platform](https://langchain-ai.github.io/langgraph/cloud/concepts/runs/): This page provides an overview of what constitutes a run in the LangGraph Platform, including its input, configuration, and metadata. It also highlights the ability to execute runs on threads and offers links to the API reference for managing runs.
-- [Starting Background Runs for Your Agent](https://langchain-ai.github.io/langgraph/cloud/how-tos/background_run/): This guide provides step-by-step instructions on how to initiate background runs for your agent using Python, JavaScript, and CURL. It covers the setup process, checking current runs, starting new runs, and retrieving the final results. By following this documentation, users can efficiently manage long-running jobs within their applications.
-- [Running Multiple Agents on the Same Thread in LangGraph](https://langchain-ai.github.io/langgraph/cloud/how-tos/same-thread/): This documentation page explains how to run multiple agents on the same thread using the LangGraph Platform. It provides step-by-step examples in Python, JavaScript, and CURL to create agents, run them on a thread, and demonstrate how the second agent can utilize the context from the first agent's responses. By following the examples, users can learn to effectively manage multiple agents and their interactions.
-- [Scheduling Cron Jobs with LangGraph](https://langchain-ai.github.io/langgraph/cloud/how-tos/cron_jobs/): This page provides a comprehensive guide on how to schedule cron jobs using the LangGraph Platform. It includes setup instructions for different programming languages, examples of creating and deleting cron jobs, and details on managing stateless cron jobs. Users will learn how to automate tasks such as sending weekly emails without writing custom scripts.
-- [Guide to Stateless Runs in LangGraph](https://langchain-ai.github.io/langgraph/cloud/how-tos/stateless_runs/): This page provides a comprehensive guide on how to implement stateless runs using the LangGraph Platform. It includes setup instructions for various programming languages, examples of streaming results, and methods for waiting for stateless results. Users will learn how to execute runs without maintaining persistent state, making their applications more efficient.
-- [Configurable Headers in LangGraph](https://langchain-ai.github.io/langgraph/cloud/how-tos/configurable_headers/): This page provides guidance on how to configure headers dynamically in the LangGraph platform to modify agent behavior and permissions. It details how to include or exclude specific headers in the runtime configuration using the `langgraph.json` file. Additionally, it explains how to access these headers within your graph and offers an option to opt-out of configurable headers.
-- [Streaming in LangGraph Platform](https://langchain-ai.github.io/langgraph/cloud/concepts/streaming/): This page provides an overview of streaming capabilities within the LangGraph Platform, detailing the various streaming modes available for LLM applications. It includes instructions for creating streaming runs, handling stateless runs, and joining active background runs. Additionally, code examples in Python, JavaScript, and cURL are provided to illustrate the implementation of these features.
-- [Streaming Outputs with LangGraph SDK](https://langchain-ai.github.io/langgraph/cloud/how-tos/streaming/): This documentation page provides detailed instructions on how to stream outputs from the LangGraph API server using the LangGraph SDK in Python, JavaScript, and cURL. It covers various streaming modes, including updates, values, and custom data, along with examples for each mode. Additionally, it explains how to handle subgraphs, debug information, and LLM tokens during streaming.
-- [Human-in-the-Loop Workflows in LangGraph](https://langchain-ai.github.io/langgraph/cloud/how-tos/add-human-in-the-loop/): This page provides an overview of the human-in-the-loop (HIL) capabilities in LangGraph, allowing for human intervention in automated processes. It details the `interrupt` function, which pauses execution for human input, and includes examples in Python, JavaScript, and cURL for implementing HIL workflows. Additionally, it links to further resources for understanding and utilizing HIL features effectively.
-- [Using Breakpoints in LangGraph](https://langchain-ai.github.io/langgraph/cloud/how-tos/human_in_the_loop_breakpoint/): This page provides an overview of how to set and use breakpoints in LangGraph to pause graph execution for inspection. It includes examples for setting breakpoints at compile time and run time in Python, JavaScript, and cURL. Additionally, it offers guidance on resuming execution after hitting a breakpoint.
-- [Using Time Travel in LangGraph](https://langchain-ai.github.io/langgraph/cloud/how-tos/human_in_the_loop_time_travel/): This page provides a comprehensive guide on how to utilize the time travel functionality in LangGraph, allowing users to resume execution from previous checkpoints. It outlines the steps to run a graph, identify checkpoints, modify graph states, and resume execution. Additionally, the page includes code examples in Python, JavaScript, and cURL for practical implementation.
-- [Model Context Protocol (MCP) Endpoint Documentation](https://langchain-ai.github.io/langgraph/concepts/server-mcp/): This page provides comprehensive documentation on the Model Context Protocol (MCP) endpoint available in LangGraph Server. It covers the requirements for using MCP, how to expose agents as MCP tools, and includes examples for connecting with MCP-compliant clients in various programming languages. Additionally, it outlines session behavior, authentication, and instructions for disabling the MCP endpoint.
-- [Managing Double Texting in LangGraph](https://langchain-ai.github.io/langgraph/concepts/double_texting/): This page provides an overview of how to handle double texting scenarios in LangGraph, where users may send multiple messages before the first has completed. It outlines four strategies: Reject, Enqueue, Interrupt, and Rollback, each with links to detailed configuration guides. Prerequisites for implementing these strategies include having the LangGraph Server set up.
-- [Using the Interrupt Option in Double Texting](https://langchain-ai.github.io/langgraph/cloud/how-tos/interrupt_concurrent/): This guide provides detailed instructions on how to utilize the `interrupt` option for double texting, allowing users to interrupt a prior run of a graph and start a new one. It includes setup instructions, code examples in Python, JavaScript, and CURL, as well as guidance on viewing run results and verifying the status of interrupted runs. Familiarity with double texting is assumed, and a link to a conceptual guide is provided for further understanding.
-- [Using the Rollback Option in Double Texting](https://langchain-ai.github.io/langgraph/cloud/how-tos/rollback_concurrent/): This guide provides detailed instructions on how to utilize the `rollback` option in double texting, which allows users to interrupt a previous run and start a new one while permanently deleting the prior run from the database. It includes setup instructions, code examples in Python, JavaScript, and CURL, and demonstrates how to view run results and verify the deletion of the original run. Familiarity with double texting is assumed, and a link to a conceptual guide is provided for further reading.
-- [Using the Reject Option in Double Texting](https://langchain-ai.github.io/langgraph/cloud/how-tos/reject_concurrent/): This guide provides an overview of the `reject` option in double texting, which prevents new runs of a graph from starting while an original run is still in progress. It includes setup instructions, code examples in Python, JavaScript, and CURL, and demonstrates how to handle errors when attempting to create concurrent runs. Additionally, it shows how to view the results of the original run after the rejection.
-- [Using the Enqueue Option for Double Texting](https://langchain-ai.github.io/langgraph/cloud/how-tos/enqueue_concurrent/): This guide provides an overview of the `enqueue` option for double texting, which allows interruptions to be queued and executed in the order they are received. It includes setup instructions, code examples in Python, JavaScript, and CURL for creating runs, and methods for viewing run results. Familiarity with double texting concepts is assumed, and a helper function for output formatting is also provided.
-- [Understanding Webhooks in LangGraph Platform](https://langchain-ai.github.io/langgraph/cloud/concepts/webhooks/): This page provides an overview of webhooks and their role in enabling event-driven communication between LangGraph Platform applications and external services. It explains how to use the `webhook` parameter in various endpoints to trigger requests upon the completion of API calls. For further details, a link to a comprehensive how-to guide is also included.
-- [Using Webhooks with LangGraph Platform](https://langchain-ai.github.io/langgraph/cloud/how-tos/webhooks/): This documentation page provides a comprehensive guide on how to implement webhooks in the LangGraph Platform to receive updates after API calls. It includes details on supported endpoints, setup instructions for different programming languages, and examples of how to specify webhook parameters in API requests. Additionally, it covers security measures and testing tools for verifying webhook functionality.
-- [Scheduling Tasks with Cron Jobs on LangGraph Platform](https://langchain-ai.github.io/langgraph/cloud/concepts/cron_jobs/): This page provides an overview of how to use cron jobs on the LangGraph Platform to run assistants on a defined schedule. It explains the process of setting up a cron job, including specifying the schedule, assistant, and input. Additionally, it includes links to a how-to guide and API reference for further details.
-- [Scheduling Cron Jobs with LangGraph](https://langchain-ai.github.io/langgraph/cloud/how-tos/cron_jobs/): This page provides a comprehensive guide on how to use cron jobs with the LangGraph Platform to automate graph executions on a schedule. It includes setup instructions for various programming languages, examples of creating and deleting cron jobs, and tips for managing stateless cron jobs. Users will learn how to efficiently schedule tasks without manual intervention, ensuring timely execution of automated processes.
-- [Adding Custom Lifespan Events in LangGraph](https://langchain-ai.github.io/langgraph/how-tos/http/custom_lifespan/): This page provides a guide on how to implement custom lifespan events in your LangGraph Platform applications, specifically for Python deployments. It covers the initialization and cleanup of resources during server startup and shutdown using FastAPI. Additionally, it includes code examples and configuration steps to help you integrate these events into your application.
-- [Adding Custom Middleware to LangGraph Platform](https://langchain-ai.github.io/langgraph/how-tos/http/custom_middleware/): This page provides a step-by-step guide on how to add custom middleware to your server when deploying agents to the LangGraph Platform. It covers the necessary code implementation using FastAPI, configuration settings in `langgraph.json`, and instructions for testing and deploying your application. Additionally, it offers links to related topics such as custom routes and lifespan events for further customization.
-- [Adding Custom Routes in LangGraph](https://langchain-ai.github.io/langgraph/how-tos/http/custom_routes/): This page provides a step-by-step guide on how to add custom routes to your LangGraph platform application using a Starlette or FastAPI app. It includes instructions for creating a new app, configuring the `langgraph.json` file, and testing the server locally. Additionally, it explains how custom routes can override default endpoints and offers suggestions for further customization.
-- [LangGraph Deployment Options](https://langchain-ai.github.io/langgraph/concepts/deployment_options/): This page outlines the various deployment options available for the LangGraph Platform, including Cloud SaaS, Self-Hosted Data Plane, Self-Hosted Control Plane, and Standalone Container. Each option is described in detail, highlighting key features, management responsibilities, and compatibility. A comparison table is also provided to help users choose the best deployment strategy for their needs.
-- [LangGraph Data Plane Overview](https://langchain-ai.github.io/langgraph/concepts/langgraph_data_plane/): This page provides a comprehensive overview of the LangGraph Data Plane, detailing its components including the server infrastructure, listener application, and data management systems like Postgres and Redis. It also covers key features such as autoscaling, static IP addresses, and custom configurations for Postgres and Redis. Additionally, the page outlines telemetry, licensing, and tracing functionalities relevant to different deployment options.
-- [LangGraph Control Plane Overview](https://langchain-ai.github.io/langgraph/concepts/langgraph_control_plane/): This page provides a comprehensive overview of the LangGraph Control Plane, detailing its UI and API functionalities for managing LangGraph Servers. It covers deployment types, environment variables, database provisioning, and asynchronous deployment processes. Additionally, it highlights the integration with LangSmith for tracing projects.
-- [Cloud SaaS Deployment Guide](https://langchain-ai.github.io/langgraph/concepts/langgraph_cloud/): This page provides a comprehensive guide on deploying the LangGraph Server using the Cloud SaaS model. It outlines the roles of the control plane and data plane, detailing their functionalities and management. Additionally, it includes an architectural diagram to illustrate the deployment structure.
-- [Deployment Guide for LangGraph Platform](https://langchain-ai.github.io/langgraph/cloud/deployment/cloud/): This page provides a comprehensive guide on how to deploy applications to the LangGraph Platform using GitHub repositories. It covers prerequisites, steps for creating new deployments and revisions, managing deployment settings, and viewing logs. Additionally, it includes instructions for whitelisting IP addresses and modifying GitHub repository access.
-- [Self-Hosted Data Plane Deployment Guide](https://langchain-ai.github.io/langgraph/concepts/langgraph_self_hosted_data_plane/): This page provides an overview of the Self-Hosted Data Plane deployment option, which allows users to manage their data plane infrastructure while offloading control plane management to LangChain. It outlines the requirements, architecture, and supported compute platforms for deployment. Additionally, it includes important information regarding the beta status of this deployment option.
-- [Deploying a Self-Hosted Data Plane](https://langchain-ai.github.io/langgraph/cloud/deployment/self_hosted_data_plane/): This page provides a comprehensive guide on deploying a Self-Hosted Data Plane using Kubernetes and Amazon ECS. It outlines the prerequisites, setup steps, and configuration details necessary for a successful deployment. Additionally, it highlights the current beta status of this deployment option.
-- [Self-Hosted Control Plane Deployment Guide](https://langchain-ai.github.io/langgraph/concepts/langgraph_self_hosted_control_plane/): This page provides an overview of the Self-Hosted Control Plane deployment option, currently in beta. It outlines the requirements, architecture, and compute platforms supported for deploying the control and data planes in your cloud environment. Additionally, it includes important links and resources for managing your self-hosted infrastructure.
-- [Deploying a Self-Hosted Control Plane](https://langchain-ai.github.io/langgraph/cloud/deployment/self_hosted_control_plane/): This page provides a comprehensive guide on deploying a Self-Hosted Control Plane using Kubernetes. It outlines the prerequisites, setup steps, and configuration details necessary for a successful deployment. Additionally, it highlights the beta status of this deployment option and includes links to relevant resources for further assistance.
-- [Deploying LangGraph Server with Standalone Container](https://langchain-ai.github.io/langgraph/concepts/langgraph_standalone_container/): This page provides a comprehensive guide on deploying a LangGraph Server using the Standalone Container option. It outlines the architecture, supported compute platforms, and differences between Lite and Enterprise server versions. Users will find essential information on managing the data plane infrastructure without a control plane.
-- [Deploying a Standalone Container with LangGraph](https://langchain-ai.github.io/langgraph/cloud/deployment/standalone_container/): This documentation provides a comprehensive guide on deploying a standalone container for the LangGraph application. It covers prerequisites, environment variable configurations, and deployment methods using Docker and Docker Compose. Additionally, it includes instructions for deploying on Kubernetes using Helm.
-- [Scalability and Resilience of LangGraph Platform](https://langchain-ai.github.io/langgraph/concepts/scalability_and_resilience/): This page provides an overview of the scalability and resilience features of the LangGraph Platform. It details how the platform handles server and queue scalability, as well as the mechanisms in place for ensuring resilience during both graceful and hard shutdowns. Additionally, it covers the resilience strategies employed for Postgres and Redis to maintain service availability.
-- [LangGraph Platform Plans Overview](https://langchain-ai.github.io/langgraph/concepts/plans/): This page provides an overview of the different plans available for the LangGraph Platform, including Developer, Plus, and Enterprise options. Each plan offers varying deployment options, usage limits, and features tailored to different user needs. For detailed pricing and related resources, links to additional documentation are also included.
+[Learn the basics](https://langchain-ai.github.io/langgraph/tutorials/introduction/): LLM should read this page when needing to build a LangGraph chatbot or when learning about chat agents with memory, human-in-the-loop functionality, and state management. This page provides a comprehensive LangGraph quickstart tutorial covering building a support chatbot with web search capability, conversation memory, human review routing, custom state management, and time travel functionality to explore alternative conversation paths.
 
-# Examples
+[Local Deploy](https://langchain-ai.github.io/langgraph/tutorials/langgraph-platform/local-server/): LLM should read this page when setting up a LangGraph app locally using `langgraph dev` and troubleshooting LangGraph server deployment. This page contains a quickstart guide for launching a LangGraph server locally, including installation steps, app creation from templates, environment setup, API testing with Python/JS SDKs, and links to deployment options and further documentation.
 
-- [Building an Agentic RAG System](https://langchain-ai.github.io/langgraph/tutorials/rag/langgraph_agentic_rag/): This tutorial guides you through the process of creating a retrieval agent (RAG) system using LangChain and LangGraph. You will learn how to fetch and preprocess documents, create a retriever tool, and build an agentic RAG that intelligently decides when to retrieve information or respond directly to user queries. By the end, you'll have a functional system capable of semantic search and context-aware responses.
-- [Building a Multi-Agent Supervisor System](https://langchain-ai.github.io/langgraph/tutorials/multi_agent/agent_supervisor/): This tutorial guides you through the process of creating a multi-agent supervisor system using specialized agents for research and math tasks. You will learn how to set up the environment, create individual worker agents, and implement a supervisor that orchestrates their interactions. By the end, you'll have a fully functional multi-agent architecture capable of handling complex queries.
-- [Building a SQL Agent with LangChain](https://langchain-ai.github.io/langgraph/tutorials/sql-agent/): This tutorial provides a step-by-step guide on how to create a SQL agent capable of answering questions about a SQL database. It covers the setup of necessary dependencies, configuration of a SQLite database, and the implementation of a prebuilt agent that interacts with the database to generate and execute queries. Additionally, it discusses customizing the agent for more control over its behavior.
-- [Custom Run ID, Tags, and Metadata for LangSmith Graph Runs](https://langchain-ai.github.io/langgraph/how-tos/run-id-langsmith/): This guide provides instructions on how to pass a custom run ID and set tags and metadata for graph runs in LangSmith. It covers prerequisites, configuration options, and includes code examples for setting up and running a graph with LangGraph. Additionally, it explains how to view and filter traces in the LangSmith platform.
-- [Custom Authentication Setup for Chatbots](https://langchain-ai.github.io/langgraph/tutorials/auth/getting_started/): This tutorial guides you through the process of setting up custom authentication for a chatbot using the LangGraph platform. You will learn how to implement token-based security to control user access, starting with a basic example and preparing for more advanced authentication methods in future tutorials. By the end, you'll have a functional chatbot that restricts access to authenticated users.
-- [Implementing Private Conversations in Chatbots](https://langchain-ai.github.io/langgraph/tutorials/auth/resource_auth/): This tutorial guides you through extending a chatbot to enable private conversations for each user by implementing resource-level access control. You'll learn how to add authorization handlers to ensure users can only access their own threads and test the functionality to confirm proper access restrictions. Additionally, the tutorial covers scoped authorization handlers for more granular control over resource access.
-- [Integrating OAuth2 Authentication with Supabase](https://langchain-ai.github.io/langgraph/tutorials/auth/add_auth_server/): This tutorial guides you through replacing hard-coded tokens with real user accounts using OAuth2 for secure authentication in your LangGraph application. You'll learn how to set up Supabase as your identity provider, implement token validation, and ensure proper user authorization. By the end, you'll have a production-ready authentication system that allows users to securely access their own data.
-- [Rebuilding Graphs at Runtime in LangGraph](https://langchain-ai.github.io/langgraph/cloud/deployment/graph_rebuild/): This guide explains how to rebuild your graph at runtime with different configurations in LangGraph. It covers the necessary prerequisites, how to define graphs, and the steps to modify your graph-making function for dynamic behavior based on user input. Additionally, it provides examples of both static and dynamic graph configurations.
-- [Interacting with RemoteGraph in LangGraph](https://langchain-ai.github.io/langgraph/how-tos/use-remote-graph/): This documentation page provides a comprehensive guide on how to interact with a LangGraph Platform deployment using the RemoteGraph interface. It covers the initialization of RemoteGraph, invoking the graph both asynchronously and synchronously, and utilizing it as a subgraph. Additionally, it includes code examples in Python and JavaScript to facilitate understanding and implementation.
-- [Deploying Agents on LangGraph Platform](https://langchain-ai.github.io/langgraph/how-tos/autogen-langgraph-platform/): This page provides a comprehensive guide on how to deploy agents like AutoGen and CrewAI using the LangGraph Platform. It covers the necessary setup, agent definition, and wrapping the agent in a LangGraph node for deployment. Additionally, it highlights the benefits of using LangGraph for scalable infrastructure and memory support.
-- [Integrating LangGraph with React: A Comprehensive Guide](https://langchain-ai.github.io/langgraph/cloud/how-tos/use_stream_react/): This documentation provides a detailed guide on how to integrate the LangGraph platform into your React applications using the `useStream()` hook. It covers installation, key features, example implementations, and customization options for building chat experiences. Additionally, it includes advanced topics such as event handling, TypeScript support, and managing conversation threads.
-- [Implementing Generative User Interfaces with LangGraph](https://langchain-ai.github.io/langgraph/cloud/how-tos/generative_ui_react/): This documentation provides a comprehensive guide on how to implement Generative User Interfaces (Generative UI) using the LangGraph platform. It covers prerequisites, step-by-step tutorials for defining UI components, sending them in graphs, and handling them in React applications. Additionally, it includes how-to guides for customizing components and managing UI state effectively.
+[Workflows and Agents](https://langchain-ai.github.io/langgraph/tutorials/workflows/): LLM should read this page when implementing agent systems, designing workflow architectures, or troubleshooting LLM orchestration strategies. The page covers patterns for LLM system design, comparing workflows (predefined paths) vs agents (dynamic control), with implementations of prompt chaining, parallelization, routing, orchestrator-worker, evaluator-optimizer, and agent patterns using both graph and functional APIs in LangGraph.
 
-# Resources
+## Concepts 
+
+[Concepts](https://langchain-ai.github.io/langgraph/concepts/): LLM should read this page when needing to understand LangGraph's key concepts or when planning to deploy LangGraph applications. Comprehensive guide covering LangGraph fundamentals (graph primitives, agents, multi-agent systems, breakpoints, persistence), features (time travel, memory, streaming), and LangGraph Platform deployment options (self-hosted, cloud, enterprise).
+
+[Agent architectures](https://langchain-ai.github.io/langgraph/concepts/agentic_concepts/): LLM should read this page when designing agent architectures, implementing control flows for LLM applications, or customizing agent behavior patterns. This page covers different LLM agent architectures including routers, tool calling agents (ReAct), structured outputs, memory systems, planning capabilities, and advanced customization options like human-in-the-loop, parallelization, subgraphs, and reflection mechanisms.
+
+[Application Structure](https://langchain-ai.github.io/langgraph/concepts/application_structure/): LLM should read this page when needing to understand LangGraph application structure, preparing to deploy a LangGraph application, or troubleshooting configuration issues. This page details the structure of LangGraph applications, including required components (graphs, langgraph.json config file, dependency files, optional .env), file organization patterns for Python/JavaScript projects, configuration file format with all supported fields, and how to specify dependencies, graphs, and environment variables.
+
+[Assistants](https://langchain-ai.github.io/langgraph/concepts/assistants/): LLM should read this page when looking for information about LangGraph assistants, understanding assistant configuration in LangGraph Platform, or learning about versioning agent configurations. This page explains LangGraph assistants, which allow developers to modify agent configurations (prompts, models, etc.) without changing graph logic, supports versioning for tracking changes, and is available only in LangGraph Platform (not open source).
+
+[Authentication & Access Control](https://langchain-ai.github.io/langgraph/concepts/auth/): LLM should read this page when implementing authentication in LangGraph Platform, designing access control for LangGraph applications, or troubleshooting security issues in LangGraph deployments. This page explains LangGraph's authentication and authorization system, covering the difference between authentication and authorization, system architecture, implementing custom auth handlers, common access patterns, and supported resources/actions for access control.
+
+[Deployment Options](https://langchain-ai.github.io/langgraph/concepts/deployment_options/): LLM should read this page when needing information about LangGraph deployment options, comparing different deployment methods, or understanding LangGraph Platform plans. This page outlines four deployment options for LangGraph Platform: Self-Hosted Lite (available for all plans), Self-Hosted Enterprise (Enterprise plan only), Cloud SaaS (Plus and Enterprise plans), and Bring Your Own Cloud (Enterprise plan only, AWS-only).
+
+[Double Texting](https://langchain-ai.github.io/langgraph/concepts/double_texting/): LLM should read this page when handling concurrent user interactions in LangGraph Platform, implementing double-texting safeguards, or designing stateful conversation systems. This page explains four approaches to handling "double texting" in LangGraph (when users send a second message before the first completes): Reject, Enqueue, Interrupt, and Rollback, noting these features are currently only available in LangGraph Platform.
+
+[Durable Execution](https://langchain-ai.github.io/langgraph/concepts/durable_execution/): LLM should read this page when needing to understand durable execution in LangGraph, implementing workflow persistence, or troubleshooting workflow resumption. This page explains durable execution in LangGraph: how workflows save progress to resume later, requirements (checkpointers and thread IDs), determinism guidelines for consistent replay, using tasks to encapsulate non-deterministic operations, and approaches for pausing/resuming workflows.
+
+[FAQ](https://langchain-ai.github.io/langgraph/concepts/faq/): LLM should read this page when needing to understand differences between LangGraph and LangChain, exploring deployment options for LangGraph Platform, or determining compatibility with various LLMs. FAQ covering LangGraph basics, comparisons with other frameworks, deployment options (free self-hosted, Cloud SaaS, Enterprise), compatibility with different LLMs including OSS models, and feature differences between open-source LangGraph and proprietary LangGraph Platform.
+
+[Functional API](https://langchain-ai.github.io/langgraph/concepts/functional_api/): LLM should read this page when implementing workflows with persistent state, adding human-in-the-loop features, or converting existing code to use LangGraph. The page documents LangGraph's Functional API, which allows adding persistence, memory, and human-in-the-loop capabilities with minimal code changes using @entrypoint and @task decorators, handling serialization requirements, state management, and common patterns for parallel execution and error handling.
+
+[Why LangGraph?](https://langchain-ai.github.io/langgraph/concepts/high_level/): LLM should read this page when understanding LangGraph's core capabilities, exploring LLM application infrastructure, or evaluating agent/workflow persistence options. LangGraph provides infrastructure for LLM applications with three key benefits: persistence for memory and human-in-the-loop capabilities, streaming of workflow events and LLM outputs, and tools for debugging and deployment via LangGraph Platform.
+
+[Human-in-the-loop](https://langchain-ai.github.io/langgraph/concepts/human_in_the_loop/): LLM should read this page when implementing human-in-the-loop workflows in LangGraph, designing approval systems with LLMs, or creating interactive multi-turn conversation agents. This page explains human-in-the-loop patterns in LangGraph using the interrupt function, showing how to pause graph execution for human review/input and resume with Command. Includes design patterns for approval workflows, state editing, tool call reviews, and multi-turn conversations, with code examples and warnings about execution flow and common pitfalls.
+
+[LangGraph CLI](https://langchain-ai.github.io/langgraph/concepts/langgraph_cli/): LLM should read this page when looking for information about LangGraph CLI installation or when needing to deploy a LangGraph API server locally. The page covers LangGraph CLI installation methods (Homebrew, pip), key commands (build, dev, up, dockerfile), and features like hot reloading, debugger support, and database management for running LangGraph servers.
+
+[Cloud SaaS](https://langchain-ai.github.io/langgraph/concepts/langgraph_cloud/): LLM should read this page when learning about LangGraph's Cloud SaaS offering, understanding deployment options for LangGraph Servers, or planning autoscaling infrastructure for LangGraph applications. This page describes LangGraph Cloud SaaS, a managed deployment service for LangGraph Servers with details on deployment types (Development/Production), revisions, persistence, autoscaling capabilities (up to 10 containers), LangSmith integration, IP whitelisting, and automatic deletion policies after 28 days of non-use.
+
+[LangGraph Platform](https://langchain-ai.github.io/langgraph/concepts/langgraph_platform/): LLM should read this page when seeking information about LangGraph Platform's components or evaluating production deployment options for agentic applications. The page details the LangGraph Platform, a commercial solution for deploying agentic applications, including its components (Server, Studio, CLI, SDK, Remote Graph) and key benefits like streaming support, background runs, long run handling, burstiness management, and human-in-the-loop capabilities.
+
+[LangGraph Server](https://langchain-ai.github.io/langgraph/concepts/langgraph_server/): LLM should read this page when developing applications with LangGraph Server, deploying agent-based applications, or integrating persistent state management in agent workflows. LangGraph Server provides an API for creating and managing agent applications with key features like streaming endpoints, background runs, task queues, persistence, webhooks, cron jobs, and monitoring capabilities through a structured system of assistants, threads, runs, and stores.
+
+[LangGraph Studio](https://langchain-ai.github.io/langgraph/concepts/langgraph_studio/): LLM should read this page when looking for information about LangGraph Studio features, needing to troubleshoot LangGraph Studio issues, or learning how to connect a LangGraph application to the Studio. LangGraph Studio is a specialized agent IDE for visualizing, interacting with, and debugging LLM applications, offering features such as graph visualization, state editing, assistant management, and integration with LangSmith, with instructions for connecting via deployed applications or local development servers, plus troubleshooting FAQs.
+
+[LangGraph Glossary](https://langchain-ai.github.io/langgraph/concepts/low_level/): LLM should read this page when needing to understand LangGraph terminology, implementing agent workflows as graphs, or developing modular multi-step AI systems. The page covers core LangGraph concepts including StateGraph, nodes, edges, state management, messaging, persistence, configuration, human-in-the-loop features, subgraphs, and visualization capabilities.
+
+[Memory](https://langchain-ai.github.io/langgraph/concepts/memory/): LLM should read this page when implementing memory systems for AI agents, managing conversation context across sessions, or designing systems that require both short-term and long-term information retention. This page explains memory systems in LangGraph, covering short-term (thread-scoped) memory for managing conversation history and long-term memory across threads, with techniques for handling long conversations, summarizing past interactions, and organizing persistent memories in namespaces.
+
+[Multi-agent Systems](https://langchain-ai.github.io/langgraph/concepts/multi_agent/): LLM should read this page when implementing multi-agent systems, troubleshooting complex agent architectures, or designing agent communication patterns. Multi-agent systems organize LLMs into modular architectures (network, supervisor, hierarchical, custom) with different communication patterns, using Command objects for handoffs between agents, and supporting various state management approaches.
+
+[Persistence](https://langchain-ai.github.io/langgraph/concepts/persistence/): LLM should read this page when needing to understand LangGraph persistence mechanisms, implementing stateful workflows, or managing conversation history across interactions. This page covers LangGraph's persistence features including checkpointers, threads, state snapshots, replay functionality, forking state, cross-thread memory via InMemoryStore, and semantic search capabilities for stored memories.
+
+[LangGraph Platform Plans](https://langchain-ai.github.io/langgraph/concepts/plans/): LLM should read this page when determining LangGraph Platform pricing tiers, comparing deployment options, or researching features available across different plans. This page outlines LangGraph Platform plans (Developer, Plus, Enterprise), detailing deployment options, usage limitations, feature availability, and pricing structure for agentic application deployment.
+
+[LangGraph Platform Architecture](https://langchain-ai.github.io/langgraph/concepts/platform_architecture/): LLM should read this page when needing to understand LangGraph Platform's technical architecture or troubleshooting deployment issues. The page details how LangGraph Platform uses Postgres for persistent storage of user/run data and Redis for worker communication (run cancellation, output streaming) and ephemeral metadata storage (retry attempts).
+
+[LangGraph's Runtime (Pregel)](https://langchain-ai.github.io/langgraph/concepts/pregel/): LLM should read this page when learning about LangGraph's runtime, implementing applications with Pregel directly, or understanding how LangGraph executes graph applications. Explains LangGraph's Pregel runtime which manages graph application execution through a three-phase process (Plan, Execution, Update), describes different channel types (LastValue, Topic, Context, BinaryOperatorAggregate), provides direct implementation examples, and contrasts the StateGraph API with the Functional API.
+
+[LangGraph Platform: Scalability & Resilience](https://langchain-ai.github.io/langgraph/concepts/scalability_and_resilience/): LLM should read this page when needing to understand LangGraph Platform's scaling capabilities, designing high-availability LangGraph deployments, or troubleshooting resilience issues. This page details LangGraph Platform's horizontal scaling features including stateless server instances, queue worker scaling, resilience mechanisms for handling crashes, and database failover strategies in Postgres and Redis.
+
+[LangGraph SDK](https://langchain-ai.github.io/langgraph/concepts/sdk/): LLM should read this page when looking for installation instructions for LangGraph SDK, needing to choose between sync and async Python clients, or requiring SDK API references. The page covers LangGraph SDK installation for Python and JS, provides API reference links, explains the difference between synchronous and asynchronous Python clients, and includes code examples for both client types.
+
+[Self-Hosted](https://langchain-ai.github.io/langgraph/concepts/self_hosted/): LLM should read this page when looking for LangGraph deployment options, understanding self-hosted versions, or seeking requirements for self-hosting LangGraph. This page details two self-hosted deployment options for LangGraph Platform: Self-Hosted Lite (limited to 1M nodes/year) and Self-Hosted Enterprise (full version requiring license). Includes requirements, deployment process using Redis/Postgres, Docker, and optional Kubernetes deployment via Helm chart.
+
+[Streaming](https://langchain-ai.github.io/langgraph/concepts/streaming/): LLM should read this page when implementing streaming features in LangGraph applications, understanding different streaming modes, or building responsive LLM applications. This page explains streaming in LangGraph, covering the main types (workflow progress, LLM tokens, custom updates) and streaming modes (values, updates, custom, messages, debug, events), with details on how to use multiple modes simultaneously and differences between LangGraph library and Platform implementations.
+
+[Template Applications](https://langchain-ai.github.io/langgraph/concepts/template_applications/): LLM should read this page when looking for LangGraph template applications, setting up a new LangGraph project, or finding reference implementations for agentic workflows. This page presents LangGraph template applications with installation requirements, available templates (including ReAct Agent, Memory Agent, Retrieval Agent, etc.), instructions for creating new apps using the CLI, deployment options, and links to further learning resources.
+
+[Time Travel ⏱️](https://langchain-ai.github.io/langgraph/concepts/time-travel/): LLM should read this page when debugging LLM-based agent behavior, analyzing decision-making paths, or exploring alternative execution branches in LangGraph. This page explains LangGraph's Time Travel debugging features: Replaying (reproducing past actions up to specific checkpoints) and Forking (creating alternative execution paths from specific points), with code examples for retrieving checkpoints, configuring replay, and creating forked states.
+
+## How Tos
+
+[How-to Guides](https://langchain-ai.github.io/langgraph/how-tos/): LLM should read this page when looking for specific implementation techniques in LangGraph or when trying to deploy LangGraph applications to production environments. This page contains an extensive collection of how-to guides for LangGraph, covering graph fundamentals, persistence, memory management, human-in-the-loop features, tool calling, multi-agent systems, streaming, and deployment options through LangGraph Platform.
+
+[How to implement handoffs between agents](https://langchain-ai.github.io/langgraph/how-tos/agent-handoffs/): LLM should read this page when implementing multi-agent systems that require agent coordination, when building systems with specialized agents that need to work together, or when needing to implement handoffs between agents. This page explains how to implement handoffs between agents in LangGraph using Command objects, both directly from agent nodes and through specialized handoff tools, with code examples for creating multi-agent systems.
+
+[How to run a graph asynchronously](https://langchain-ai.github.io/langgraph/how-tos/async/): LLM should read this page when needing to implement asynchronous graph execution in LangGraph or when optimizing IO-bound LLM applications. This page explains how to convert synchronous graphs to asynchronous in LangGraph, including updating node definitions with async/await, using StateGraph with TypedDict, implementing conditional edges, and streaming results.
+
+[How to integrate LangGraph with AutoGen, CrewAI, and other frameworks](https://langchain-ai.github.io/langgraph/how-tos/autogen-integration/): LLM should read this page when integrating LangGraph with other agent frameworks, building multi-agent systems, or adding persistence features to agents. The page demonstrates how to combine LangGraph with AutoGen by calling AutoGen agents inside LangGraph nodes, showing code examples for setting up the integration with memory and conversation persistence.
+
+[How to integrate LangGraph (functional API) with AutoGen, CrewAI, and other frameworks](https://langchain-ai.github.io/langgraph/how-tos/autogen-integration-functional/): LLM should read this page when integrating LangGraph with other agent frameworks, building multi-agent systems with different frameworks, or adding LangGraph features to existing agent systems. This page demonstrates how to integrate LangGraph's functional API with AutoGen, including code examples for creating a workflow that calls AutoGen agents, leveraging LangGraph's memory and persistence features.
+
+[How to create branches for parallel node execution](https://langchain-ai.github.io/langgraph/how-tos/branching/): LLM should read this page when needing to implement parallel node execution in LangGraph, optimizing graph performance, or handling conditional branching in workflows. This page explains how to create branches for parallel execution in LangGraph using fan-out/fan-in mechanisms, reducer functions for state accumulation, handling exceptions during parallel execution, and implementing conditional branching logic between nodes.
+
+[How to combine control flow and state updates with Command](https://langchain-ai.github.io/langgraph/how-tos/command): LLM should read this page when learning how to combine control flow with state updates in LangGraph, understanding Command objects, or navigating between parent graphs and subgraphs. This page explains how to use Command objects to simultaneously update state and control flow between nodes, demonstrates using Command.PARENT to navigate from subgraphs to parent graphs, and includes examples of implementing reducers for state updates across graph hierarchies.
+
+[How to add runtime configuration to your graph](https://langchain-ai.github.io/langgraph/how-tos/configuration/): LLM should read this page when implementing runtime configuration for LangGraph, adding model selection options to agents, or enabling dynamic system messages. This page demonstrates how to configure LangGraph at runtime, including selecting different LLMs dynamically and adding custom configuration options like system messages through the configurable dictionary.
+
+[How to use the pre-built ReAct agent](https://langchain-ai.github.io/langgraph/how-tos/create-react-agent/): LLM should read this page when implementing a ReAct agent, needing pre-built agent solutions, or learning how to integrate tools with LLM agents. This page covers how to use the pre-built ReAct agent in LangGraph, including setup instructions, creating a weather checking tool, implementing the agent architecture, and examples of running the agent with and without tool calls.
+
+[How to add human-in-the-loop processes to the prebuilt ReAct agent](https://langchain-ai.github.io/langgraph/how-tos/create-react-agent-hitl/): LLM should read this page when implementing human-in-the-loop processes for ReAct agents, debugging tool calls, or learning about interrupts in LangGraph. This guide demonstrates how to add human-in-the-loop functionality to prebuilt ReAct agents using interrupt_before=["tools"], working with MemorySaver checkpoints, and showing how to approve or edit tool calls before they execute.
+
+[How to add thread-level memory to a ReAct Agent](https://langchain-ai.github.io/langgraph/how-tos/create-react-agent-memory/): LLM should read this page when adding memory to ReAct agents, implementing thread-level persistence in LangGraph, or building stateful conversational agents. This guide demonstrates how to add memory to a ReAct agent using LangGraph's checkpointer interface, with code examples showing MemorySaver implementation, thread_id configuration, and persistent chat context across multiple interactions.
+
+[How to return structured output from the prebuilt ReAct agent](https://langchain-ai.github.io/langgraph/how-tos/create-react-agent-structured-output/): LLM should read this page when implementing structured output with ReAct agents, customizing agent response formats, or working with LangGraph agents. This page explains how to return structured output from prebuilt ReAct agents by providing a response_format parameter with a Pydantic schema, including examples with weather data and options for customizing the prompt.
+
+[How to add a custom system prompt to the prebuilt ReAct agent](https://langchain-ai.github.io/langgraph/how-tos/create-react-agent-system-prompt/): LLM should read this page when learning to customize ReAct agents, needing to add system prompts to agents, or working with LangGraph's prebuilt agents. This tutorial demonstrates how to add a custom system prompt to a prebuilt ReAct agent, with code examples showing model setup, tool creation, and using the prompt parameter in the create_react_agent function.
+
+[How to add cross-thread persistence to your graph](https://langchain-ai.github.io/langgraph/how-tos/cross-thread-persistence): LLM should read this page when needing to implement persistence across multiple threads in LangGraph, when storing user data between conversations, or when implementing shared memory in graph-based LLM applications. This page demonstrates how to use LangGraph's Store API to persist data across threads, including creating an InMemoryStore with embedding search capabilities, passing stores to graph nodes, and accessing user-specific memories in different conversation threads.
+
+[How to add cross-thread persistence (functional API)](https://langchain-ai.github.io/langgraph/how-tos/cross-thread-persistence-functional): LLM should read this page when needing to implement cross-thread persistence in LangGraph functional API, storing user data across different conversation threads, or creating shared memory between workflows. This page explains how to add cross-thread persistence to LangGraph using the Store interface, including defining a store, configuring the entrypoint decorator, and implementing a workflow that can store and retrieve user information across different conversation threads.
+
+[How to do a Self-hosted deployment of LangGraph](https://langchain-ai.github.io/langgraph/how-tos/deploy-self-hosted/): LLM should read this page when implementing a self-hosted deployment of LangGraph, configuring required environment variables, or building Docker images for LangGraph applications. This page explains how to deploy LangGraph applications using Docker, covering environment requirements (Redis, Postgres), how to build Docker images with the LangGraph CLI, configuration using environment variables, and deployment options using Docker or Docker Compose.
+
+[How to disable streaming for models that don't support it](https://langchain-ai.github.io/langgraph/how-tos/disable-streaming/): LLM should read this page when handling models that don't support streaming, implementing LangGraph with non-streaming models, or troubleshooting streaming errors with OpenAI's O1 models. This page explains how to use the disable_streaming=True parameter with ChatOpenAI to make non-streaming models work with LangGraph's astream_events API, with code examples showing the error case and proper implementation.
+
+[How to edit graph state](https://langchain-ai.github.io/langgraph/how-tos/human_in_the_loop/edit-graph-state/): LLM should read this page when needing to implement human intervention in LangGraph workflows, wanting to edit graph state during execution, or implementing breakpoints in agent systems. This page explains how to edit graph state in LangGraph using breakpoints, including implementing human-in-the-loop interactions, setting up interruptions before specific nodes, and updating state during agent execution.
+
+[How to Review Tool Calls](https://langchain-ai.github.io/langgraph/how-tos/human_in_the_loop/review-tool-calls/): LLM should read this page when implementing human review of tool calls, creating interactive agent workflows, or building approval systems for AI actions. This page explains how to implement human-in-the-loop review for tool calls in LangGraph, including approving tool calls, modifying tool calls manually, and providing natural language feedback to agents with complete code examples and explanations.
+
+[How to view and update past graph state](https://langchain-ai.github.io/langgraph/how-tos/human_in_the_loop/time-travel/): LLM should read this page when needing to access or modify past states in LangGraph, when debugging agent execution, or when implementing user interventions in agent workflows. This page demonstrates how to view and update past graph states in LangGraph using get_state and update_state methods, with examples of replaying execution from checkpoints and branching workflows.
+
+[How to wait for user input using interrupt](https://langchain-ai.github.io/langgraph/how-tos/human_in_the_loop/wait-user-input/): LLM should read this page when implementing wait-for-user functions in LangGraph, implementing human-in-the-loop interactions, or learning how to use the interrupt() function. This page explains how to pause graph execution to collect user input using LangGraph's interrupt() function, with examples of simple feedback collection and more complex agent interactions that ask clarifying questions.
+
+[How to define input/output schema for your graph](https://langchain-ai.github.io/langgraph/how-tos/input_output_schema/): LLM should read this page when needing to define separate input/output schemas for LangGraph, implementing schema-based data filtering, or understanding schema definitions in StateGraph. This page explains how to define distinct input and output schemas for a StateGraph, showing how input schema validates the provided data structure while output schema filters internal data to return only relevant information, with code examples demonstrating implementation.
+
+[How to handle large numbers of tools](https://langchain-ai.github.io/langgraph/how-tos/many-tools/): LLM should read this page when handling large tool collections, implementing dynamic tool selection, or creating retrieval-based tool management in LangGraph. This page demonstrates how to manage large numbers of tools by using vector search to dynamically select relevant tools based on user queries, implementing tool selection nodes in LangGraph, and handling tool selection errors with retry mechanisms.
+
+[How to create map-reduce branches for parallel execution](https://langchain-ai.github.io/langgraph/how-tos/map-reduce/): LLM should read this page when learning to implement parallel execution in LangGraph, creating map-reduce operations, or handling dynamic task decomposition. This guide explains how to use LangGraph's Send API to create map-reduce workflows, breaking tasks into parallel sub-tasks and recombining results, with examples showing joke generation across multiple subjects.
+
+[How to add summary of the conversation history](https://langchain-ai.github.io/langgraph/how-tos/memory/add-summary-conversation-history/): LLM should read this page when implementing conversation summarization, managing context windows, or building chatbots with memory management. This page demonstrates how to add summary functionality to conversation history using LangGraph, including checking conversation length, creating summaries, and removing old messages while maintaining context.
+
+[How to delete messages](https://langchain-ai.github.io/langgraph/how-tos/memory/delete-messages): LLM should read this page when attempting to manage message history in LangGraph, needing to delete specific messages from conversational state, or implementing memory management in LLM applications. This page explains how to delete messages from a LangGraph application using RemoveMessage modifiers, covering both manual deletion with message IDs and programmatic deletion within graph logic to maintain conversation history limits.
+
+[How to manage conversation history](https://langchain-ai.github.io/langgraph/how-tos/memory/manage-conversation-history/): LLM should read this page when managing conversation history in LangGraph, preventing context window issues, or implementing custom message filtering. This page explains how to manage conversation history in LangGraph to prevent context window overflow by implementing message filtering functions that control which messages are sent to the LLM.
+
+[How to add semantic search to your agent's memory](https://langchain-ai.github.io/langgraph/how-tos/memory/semantic-search/): LLM should read this page when implementing semantic search in agent memory, enabling memory-aware AI assistants, or configuring advanced memory retrieval systems. This page demonstrates how to add semantic search to LangGraph agent memory stores, covering basic setup with embeddings, storing memories, searching by semantic similarity, integrating memory in agents and ReAct agents, and advanced usage like multi-vector indexing and selective memory indexing.
+
+[How to add multi-turn conversation in a multi-agent application](https://langchain-ai.github.io/langgraph/how-tos/multi-agent-multi-turn-convo/): LLM should read this page when implementing multi-turn conversations between agents, creating interactive agent systems with human input, or learning about langgraph interrupts and agent handoffs. This page demonstrates how to build a multi-agent system with multi-turn conversations, including human-in-the-loop interactions, agent handoffs, and state management using LangGraph, Command objects, and interrupts.
+
+[How to add multi-turn conversation in a multi-agent application (functional API)](https://langchain-ai.github.io/langgraph/how-tos/multi-agent-multi-turn-convo-functional/): LLM should read this page when building multi-turn conversational agents, implementing agent-to-agent handoffs, or using interrupts to collect user input in LangGraph. This guide demonstrates how to create a multi-agent system with multi-turn conversations using LangGraph's functional API, featuring agent handoffs, interrupt mechanics for user input, and a complete example of travel and hotel advisor agents that can transfer control between each other.
+
+[How to build a multi-agent network](https://langchain-ai.github.io/langgraph/how-tos/multi-agent-network/): LLM should read this page when implementing multi-agent networks, setting up agent communication via handoffs, or building travel assistance agents. This page explains how to create a fully-connected multi-agent network with LangGraph where agents can communicate with each other via handoffs, including custom agent implementation and using prebuilt ReAct agents with tools.
+
+[How to build a multi-agent network (functional API)](https://langchain-ai.github.io/langgraph/how-tos/multi-agent-network-functional/): LLM should read this page when building multi-agent systems, implementing agent handoffs between specialists, or creating fully-connected agent networks. This guide demonstrates how to create a multi-agent network using LangGraph's functional API, with tasks for individual agents and entrypoint functions to manage agent handoffs based on tool calls.
+
+[How to add node retry policies](https://langchain-ai.github.io/langgraph/how-tos/node-retries/): LLM should read this page when implementing error handling in LangGraph nodes, configuring API retry mechanisms, or troubleshooting node failures in graph workflows. Shows how to add custom retry policies to LangGraph nodes, including specifying which exceptions to retry on, setting max attempts, intervals, backoff factors, and implementing different retry behaviors for different node types.
+
+[How to pass config to tools](https://langchain-ai.github.io/langgraph/how-tos/pass-config-to-tools/): LLM should read this page when implementing secure tool configuration in LangChain, passing user-specific parameters to tools, or configuring tools with runtime values. This page explains how to pass configuration to LangChain tools using RunnableConfig, allowing application-controlled values (like user IDs) to be securely passed to tools without LLM control, with examples of implementing tools that access user-specific data.
+
+[How to pass private state between nodes](https://langchain-ai.github.io/langgraph/how-tos/pass_private_state/): LLM should read this page when implementing data sharing between specific nodes in LangGraph, handling private state in graph workflows, or designing multi-node sequential processes with selective data visibility. This page demonstrates how to pass private data between specific nodes in a LangGraph without making it part of the main schema, using typed dictionaries to define both public and private states, and showing a three-node example where private data flows only between the first two nodes.
+
+[How to add thread-level persistence to your graph](https://langchain-ai.github.io/langgraph/how-tos/persistence/): LLM should read this page when implementing persistence in LangGraph, needing to preserve context across user interactions, or learning about thread-level state management. This page explains how to add thread-level persistence to LangGraph applications using MemorySaver, including code examples for creating stateful conversations where context is maintained across multiple interactions.
+
+[How to add thread-level persistence (functional API)](https://langchain-ai.github.io/langgraph/how-tos/persistence-functional/): LLM should read this page when implementing thread-level persistence in LangGraph, creating conversational agents with memory, or using functional API with state management. This page explains how to add thread-level persistence to LangGraph functional API workflows using checkpointers, including code examples for creating a simple chatbot with memory across conversation turns.
+
+[How to use MongoDB checkpointer for persistence](https://langchain-ai.github.io/langgraph/how-tos/persistence_mongodb/): LLM should read this page when implementing persistence in LangGraph agents, setting up MongoDB for state checkpointing, or working with MongoDB connections in LangGraph applications. This page explains how to use the MongoDB checkpointer for LangGraph persistence, covering connection methods (direct, client-based, async), basic setup requirements, and practical examples of saving and retrieving agent state between interactions.
+
+[How to use Postgres checkpointer for persistence](https://langchain-ai.github.io/langgraph/how-tos/persistence_postgres/): LLM should read this page when setting up persistence for LangGraph agents, implementing PostgreSQL as a checkpoint storage backend, or working with either synchronous or asynchronous database connections. This page details how to use PostgreSQL for persisting LangGraph agent state, covering setup and configuration of PostgresSaver and AsyncPostgresSaver with different connection methods (pool, direct connection, connection string).
+
+[How to create a custom checkpointer using Redis](https://langchain-ai.github.io/langgraph/how-tos/persistence_redis/): LLM should read this page when implementing persistence in LangGraph applications, creating custom checkpoint mechanisms for agents, or working with Redis as a storage backend. This page demonstrates how to create custom checkpointers for LangGraph agents using Redis, including implementations for both synchronous and asynchronous interfaces that save and retrieve agent state.
+
+[How to create a ReAct agent from scratch](https://langchain-ai.github.io/langgraph/how-tos/react-agent-from-scratch/): LLM should read this page when needing to create a custom ReAct agent, wanting more control than prebuilt agents, or implementing ReAct from scratch with LangGraph. This guide shows how to build a custom ReAct agent using LangGraph, covering state definition, model/tool setup, node/edge configuration, graph creation, and testing the implementation with a weather query example.
+
+[How to create a ReAct agent from scratch (Functional API)](https://langchain-ai.github.io/langgraph/how-tos/react-agent-from-scratch-functional): LLM should read this page when creating a ReAct agent using LangGraph's Functional API, implementing tool-calling workflows, or building conversational agents with thread persistence. This page explains how to build a ReAct agent from scratch using LangGraph's Functional API, including model and tool setup, defining tasks for model/tool calling, creating an entrypoint for orchestration, and adding thread-level persistence for conversational experiences.
+
+[How to force tool-calling agent to structure output](https://langchain-ai.github.io/langgraph/how-tos/react-agent-structured-output): LLM should read this page when needing to force tool-calling agents to produce structured output, implementing consistent output formats for downstream software, or choosing between single-LLM vs two-LLM structured output approaches. The page explains two methods for implementing structured output with tool-calling agents: binding output as a tool (single LLM approach) and using two LLMs with structured output conversion, with code examples for both approaches using LangGraph.
+
+[How to create and control loops](https://langchain-ai.github.io/langgraph/how-tos/recursion-limit/): LLM should read this page when building loops in computational graphs, needing to implement termination conditions, or handling recursion limits in LangGraph. The page explains how to create graphs with loops using conditional edges for termination, set recursion limits, handle GraphRecursionError, and implement complex loops with branches.
+
+[How to review tool calls (Functional API)](https://langchain-ai.github.io/langgraph/how-tos/review-tool-calls-functional/): LLM should read this page when implementing human review of tool calls, creating ReAct agents with Functional API, or adding human-in-the-loop workflows. This page demonstrates how to review tool calls before execution in a ReAct agent using LangGraph's Functional API, including accepting, revising, or generating custom tool messages with the interrupt function.
+
+[How to pass custom run ID or set tags and metadata for graph runs in LangSmith](https://langchain-ai.github.io/langgraph/how-tos/run-id-langsmith/): LLM should read this page when needing to customize trace information in LangSmith for LangGraph runs or when debugging graph runs with custom identifiers. The page explains how to pass custom run_id, set tags, add metadata, and customize run names for LangGraph traces in LangSmith using RunnableConfig, with examples showing implementation with a ReAct agent.
+
+[How to create a sequence of steps](https://langchain-ai.github.io/langgraph/how-tos/sequence/): LLM should read this page when implementing sequential workflows in LangGraph, creating multi-step processes in applications, or learning about state management in graph-based systems. This page explains how to create sequences in LangGraph, covering methods for building sequential graphs using .add_node/.add_edge or the shorthand .add_sequence, defining state with TypedDict, creating nodes as functions that update state, and compiling/invoking graphs with examples.
+
+[How to use Pydantic model as graph state](https://langchain-ai.github.io/langgraph/how-tos/state-model): LLM should read this page when implementing Pydantic models for state validation in LangGraph, handling complex state schema definitions, or troubleshooting validation errors in graph nodes. This guide explains how to use Pydantic BaseModel as a state schema in LangGraph for runtime validation, covering basic implementation, limitations, validation behavior across multiple nodes, serialization patterns, type coercion, and working with message models.
+
+[How to update graph state from nodes](https://langchain-ai.github.io/langgraph/how-tos/state-reducers/): LLM should read this page when needing to update state in LangGraph, designing graphs with nodes that modify state, or implementing reducers for state management. This page explains how to define state schemas in LangGraph using TypedDict, how nodes can update state, and how to use reducers to control state updates, with specific examples using message handling.
+
+[How to stream](https://langchain-ai.github.io/langgraph/how-tos/streaming/): LLM should read this page when needing to implement streaming in LangGraph applications, understanding different streaming modes, or troubleshooting LLM response delivery. This page explains how to stream LLM outputs using LangGraph, covering different streaming modes (values, updates, custom, messages, debug), with code examples for each mode and how to combine multiple streaming modes.
+
+[How to stream data from within a tool](https://langchain-ai.github.io/langgraph/how-tos/streaming-events-from-within-tools/): LLM should read this page when implementing streaming functionality in tools, integrating LLM outputs with custom data streams, or developing LangGraph applications with real-time feedback. This page explains how to stream data from within tools using LangGraph, covering custom data streaming with stream_mode="custom", LLM token streaming with stream_mode="messages", and implementation approaches both with and without LangChain.
+
+[How to stream LLM tokens from specific nodes](https://langchain-ai.github.io/langgraph/how-tos/streaming-specific-nodes/): LLM should read this page when needing to filter token streaming from specific nodes in LangGraph, implementing selective streaming in multi-node workflows, or controlling which node outputs are displayed. Guide explains how to stream LLM tokens from specific nodes using stream_mode="messages" and filtering by the langgraph_node metadata field, with complete code examples for implementing this in StateGraph applications.
+
+[How to stream from subgraphs](https://langchain-ai.github.io/langgraph/how-tos/streaming-subgraphs/): LLM should read this page when needing to stream outputs from subgraphs in LangGraph, implementing nested graph streaming, or debugging hierarchical graph execution. This page explains how to stream outputs from subgraphs in LangGraph by using the subgraphs=True parameter in the parent graph's stream() method, with a complete code example showing the difference between regular streaming and subgraph streaming.
+
+[How to stream LLM tokens from your graph](https://langchain-ai.github.io/langgraph/how-tos/streaming-tokens): LLM should read this page when needing to stream LLM tokens from a LangGraph application, implementing custom token streaming, or filtering streamed outputs. This page explains how to stream individual LLM tokens from LangGraph nodes using graph.stream() with different stream_mode options, including examples with and without LangChain, async implementations, and how to filter streamed tokens using metadata.
+
+[How to use subgraphs](https://langchain-ai.github.io/langgraph/how-tos/subgraph/): LLM should read this page when building complex systems with subgraphs, implementing multi-agent systems, or needing to share state between parent graphs and subgraphs. The page explains two methods for using subgraphs: adding compiled subgraphs when schemas share keys, and invoking subgraphs via node functions when schemas differ, with code examples for both approaches.
+
+[How to add thread-level persistence to a subgraph](https://langchain-ai.github.io/langgraph/how-tos/subgraph-persistence/): LLM should read this page when implementing persistence in nested LangGraph architectures, adding thread-level storage to subgraphs, or debugging state propagation in LangGraph applications. This guide demonstrates how to add thread-level persistence to subgraphs by passing a checkpointer only to the parent graph during compilation, accessing persisted states from both parent and child graphs, and retrieving subgraph state using the proper configuration parameters.
+
+[How to transform inputs and outputs of a subgraph](https://langchain-ai.github.io/langgraph/how-tos/subgraph-transform-state/): LLM should read this page when needing to work with nested subgraphs, transforming state between parent and child graphs, or integrating independent state components in LangGraph. This page demonstrates how to transform inputs and outputs between parent graphs and subgraphs with different state structures, showing implementation of three nested graphs (parent, child, grandchild) with separate state dictionaries and transformation functions.
+
+[How to view and update state in subgraphs](https://langchain-ai.github.io/langgraph/how-tos/subgraphs-manage-state/): LLM should read this page when working with state management in nested subgraphs, implementing human-in-the-loop patterns, or debugging complex graph flows. This guide covers viewing and updating state in LangGraph subgraphs, including how to resume execution from breakpoints, modify subgraph state, act as specific nodes, and work with multi-level nested subgraphs.
+
+[How to call tools using ToolNode](https://langchain-ai.github.io/langgraph/how-tos/tool-calling/): LLM should read this page when learning how to implement tool calling with LangGraph, when working with the ToolNode component, or when building ReAct agents. This page covers using LangGraph's ToolNode for tool calling, including setup, manual invocation, working with chat models, building a ReAct agent, handling single and parallel tool calls, and error handling.
+
+[How to handle tool calling errors](https://langchain-ai.github.io/langgraph/how-tos/tool-calling-errors/): LLM should read this page when handling tool call errors, implementing error handling for LLM-tool interactions, or creating fallback strategies for failed tool calls. This page covers strategies for handling tool calling errors in LangGraph, including using the prebuilt ToolNode with built-in error handling, implementing custom error handling patterns, and fallback mechanisms with model upgrades when tools fail.
+
+[How to update graph state from tools](https://langchain-ai.github.io/langgraph/how-tos/update-state-from-tools/): LLM should read this page when needing to update graph state from tools in LangGraph, implementing personalized responses based on tool updates, or using Command objects to modify state. This page details how to update graph state from tools using Command objects, creating personalized agents with state tracking, and implementing dynamic prompt construction based on updated state values.
+
+[How to interact with the deployment using RemoteGraph](https://langchain-ai.github.io/langgraph/how-tos/use-remote-graph/): LLM should read this page when needing to interact with LangGraph Platform deployments remotely, when implementing RemoteGraph interfaces, or when using deployed graphs as subgraphs. This page explains how to use RemoteGraph to interact with LangGraph Platform deployments, covering initialization methods (URL-based or client-based), synchronous/asynchronous invocation, thread-level persistence, and using RemoteGraph as a subgraph in larger applications.
+
+[How to visualize your graph](https://langchain-ai.github.io/langgraph/how-tos/visualization): LLM should read this page when needing to visualize LangGraph graphs, looking for graph visualization methods, or working with graph visualization in Python. Comprehensive guide for visualizing graphs in LangGraph with multiple methods: Mermaid syntax, Mermaid.ink API for PNG rendering, Pyppeteer-based visualization, and Graphviz, with customization options for colors, styles, and layout.
+
+[How to wait for user input (Functional API)](https://langchain-ai.github.io/langgraph/how-tos/wait-user-input-functional/): LLM should read this page when implementing human-in-the-loop workflows, integrating user input into agent systems, or adding interruption capabilities to LangGraph applications. The page explains how to use the `interrupt()` function in LangGraph's Functional API to pause execution for human input, with examples for both simple workflows and ReAct agents, including code implementations with checkpointing.
 
-- [LangGraph FAQ](https://langchain-ai.github.io/langgraph/concepts/faq/): This FAQ page provides answers to common questions about LangGraph, an orchestration framework for complex agentic systems. It covers topics such as the differences between LangGraph and LangChain, performance impacts, open-source status, and compatibility with various LLMs. Additionally, it outlines the distinctions between LangGraph and LangGraph Platform, including features and deployment options.
-- [Getting Started with LangGraph Templates](https://langchain-ai.github.io/langgraph/concepts/template_applications/): This page provides an overview of open source reference applications known as templates, designed to help users quickly build applications with LangGraph. It includes installation instructions for the LangGraph CLI, a list of available templates with their descriptions, and guidance on creating and deploying a new LangGraph app. Users can find links to repositories for each template and next steps for customizing their applications.
-- [Guide to Using llms.txt and llms-full.txt for LLMs](https://langchain-ai.github.io/langgraph/llms-txt-overview/): This page provides an overview of the `llms.txt` and `llms-full.txt` formats, which facilitate access to programming documentation for large language models (LLMs) and agents. It outlines the differences between the two formats, usage instructions via an MCP server, and best practices for integrating these files into integrated development environments (IDEs). Additionally, it highlights considerations for managing large documentation files effectively.
-- [Community Agents for LangGraph](https://langchain-ai.github.io/langgraph/agents/prebuilt/): This page provides a list of community-built libraries that extend the functionality of LangGraph. Each entry includes the library name, GitHub URL, a brief description, and additional metrics like weekly downloads and stars. Additionally, it outlines how to contribute your own library to the LangGraph documentation.
-- [LangGraph Error Reference Guide](https://langchain-ai.github.io/langgraph/troubleshooting/errors/index/): This page serves as a comprehensive reference for resolving common errors encountered while using the LangGraph platform. It includes a list of error codes and links to detailed guides for troubleshooting specific issues. Users can find solutions for errors related to graph recursion, concurrent updates, node return values, and more.
-- [Handling Recursion Limits in LangGraph](https://langchain-ai.github.io/langgraph/troubleshooting/errors/GRAPH_RECURSION_LIMIT/): This page provides guidance on managing recursion limits in LangGraph's StateGraph. It explains how to identify potential infinite loops in your graph and offers solutions for increasing the recursion limit when working with complex graphs. Additionally, it includes code examples to illustrate the concepts discussed.
-- [Handling INVALID_CONCURRENT_GRAPH_UPDATE in LangGraph](https://langchain-ai.github.io/langgraph/troubleshooting/errors/INVALID_CONCURRENT_GRAPH_UPDATE/): This page explains the INVALID_CONCURRENT_GRAPH_UPDATE error that occurs in LangGraph when multiple nodes attempt to update the same state property concurrently. It provides an example of how this error can arise and offers a solution by using a reducer to combine values from parallel node executions. Additionally, troubleshooting tips are included to help resolve this issue.
-- [Handling Invalid Node Return Values in LangGraph](https://langchain-ai.github.io/langgraph/troubleshooting/errors/INVALID_GRAPH_NODE_RETURN_VALUE/): This page provides guidance on the error encountered when a LangGraph node returns a non-dict value. It includes an example of incorrect node implementation and the resulting error message. Additionally, troubleshooting tips are offered to ensure that all nodes return the expected dictionary format.
-- [Handling Multiple Subgraphs in LangGraph](https://langchain-ai.github.io/langgraph/troubleshooting/errors/MULTIPLE_SUBGRAPHS/): This page discusses the limitations of calling multiple subgraphs within a single LangGraph node when checkpointing is enabled. It provides troubleshooting tips to resolve related errors, including suggestions for compiling subgraphs without checkpointing and using the Send API for graph calls.
-- [Handling INVALID_CHAT_HISTORY Error in create_react_agent](https://langchain-ai.github.io/langgraph/troubleshooting/errors/INVALID_CHAT_HISTORY/): This page provides an overview of the INVALID_CHAT_HISTORY error encountered in the create_react_agent function when a malformed list of messages is passed. It outlines the potential causes of the error and offers troubleshooting steps to resolve it. Users can learn how to properly invoke the graph and manage tool calls to avoid this issue.
-- [Handling INVALID_LICENSE Error in LangGraph Platform](https://langchain-ai.github.io/langgraph/troubleshooting/errors/INVALID_LICENSE/): This page provides guidance on troubleshooting the INVALID_LICENSE error encountered when starting a self-hosted LangGraph Platform server. It outlines the scenarios in which this error may occur and offers solutions based on different deployment types. Additionally, it includes steps to verify the necessary credentials for successful deployment.
-- [LangGraph Studio Troubleshooting Guide](https://langchain-ai.github.io/langgraph/troubleshooting/studio/): This page provides troubleshooting solutions for common connection issues encountered in LangGraph Studio, particularly with Safari and Brave browsers. It also addresses potential graph edge issues and offers methods to define routing paths for conditional edges. Users can find step-by-step instructions for resolving these issues using Cloudflare Tunnel and browser settings.
-- [LangGraph Case Studies](https://langchain-ai.github.io/langgraph/adopters/): This page provides a comprehensive list of companies that have successfully implemented LangGraph, showcasing their unique use cases and the benefits they have achieved. Each entry includes links to detailed case studies or blog posts for further reading. If your company uses LangGraph, you are encouraged to share your success story to contribute to this growing collection.

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/stylesheets/agent_graph_widget.css

@@ -1,57 +0,0 @@
-.agent-layout {
-    display: flex;
-    flex-wrap: nowrap;
-    gap: 1rem;
-    align-items: flex-start;
-    margin-top: 1rem;
-}
-
-.agent-layout h3 {
-    margin: 0;
-}
-
-.agent-graph-features {
-    display: flex;
-    flex-direction: column;
-    gap: 0.5rem;
-    padding: 1rem;
-    max-width: 300px;
-    flex-shrink: 0;
-
-    border: 1px solid var(--md-default-fg-color--lightest);
-    border-radius: 0.5rem;
-    background-color: var(--md-default-bg-color);
-}
-
-.agent-graph-features label {
-    display: flex;
-    align-items: center;
-    gap: 0.5rem;
-    font-size: 0.9rem;
-    color: var(--md-typeset-color);
-    cursor: pointer;
-}
-
-.agent-graph-features input[type="checkbox"] {
-    accent-color: var(--md-accent-fg-color);
-    transform: scale(1.2);
-}
-
-.agent-graph-container {
-    flex: 1 1 50%;
-    max-width: 70%;
-    padding: 1rem;
-
-    overflow: auto;
-    height: auto;
-    box-sizing: border-box;
-
-    border: 1px solid var(--md-default-fg-color--lightest);
-    border-radius: 0.5rem;
-    background-color: var(--md-default-bg-color);
-}
-
-.agent-graph-container img {
-    display: block;
-    margin: 0 auto;
-}

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

@@ -19,6 +19,7 @@ theme:
     - content.tabs.link
     - content.action.edit
     - content.tooltips
+    - header.autohide
     - navigation.indexes
     - navigation.footer
     - navigation.instant
@@ -27,6 +28,7 @@ theme:
     - navigation.instant.progress
     - navigation.path
     - navigation.tabs
+    - navigation.tabs.sticky
     - navigation.top
     - navigation.prune
     - navigation.tracking
@@ -253,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
@@ -416,5 +417,3 @@ extra_css:
   - stylesheets/version_admonitions.css
   - stylesheets/logos.css
   - stylesheets/sticky_navigation.css
-  - stylesheets/agent_graph_widget.css
-

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