langgraph 0.5.0rc0

langgraph-checkpoint 2.1.0
Preparation for 0.5 release: langgraph-checkpoint (#5124 )
2026-08-26 17:42:24 +02:00 · 2025-06-16 15:17:56 -07:00 · 2025-06-16 14:58:50 -07:00 · 2025-06-16 21:57:11 +00:00 · 2025-06-16 13:14:25 -07:00 · 2025-06-16 13:07:52 -07:00
374 changed files with 40494 additions and 52343 deletions
@@ -1,6 +1,6 @@
 name: "\U0001F41B Bug Report"
 description: Report a bug in LangGraph. To report a security issue, please instead use the security option below. For questions, please use the GitHub Discussions.
-labels: ["02 Bug Report"]
+labels: [pending,bug]
 body:
  - type: markdown
    attributes:
@@ -1,4 +1,4 @@
-blank_issues_enabled: false
+blank_issues_enabled: true
 version: 2.1
 contact_links:
  - name: 🤔 Question or Problem
@@ -1,7 +1,7 @@
 name: Documentation
 description: Report an issue related to the LangGraph documentation.
 title: "DOC: <Please write a comprehensive title after the 'DOC: ' prefix>"
-labels: [03 - Documentation]
+labels: [documentation]

 body:
 - type: textarea
@@ -1,88 +0,0 @@
-# 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') }}
@@ -0,0 +1,11 @@
+# Please see the documentation for all configuration options:
+# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+# and
+# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
+
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
@@ -3,9 +3,6 @@ name: CLI integration test
 on:
  workflow_call:

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

@@ -36,42 +34,28 @@ jobs:
        uses: Ana06/get-changed-files@v2.3.0
        with:
          filter: "${{ inputs.working-directory }}/**"
-      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
+      - name: Set up Python ${{ matrix.python-version }}
        if: steps.changed-files.outputs.all
-        uses: "./.github/actions/poetry_setup"
+        uses: astral-sh/setup-uv@v6
        with:
          python-version: ${{ matrix.python-version }}
-          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
+          enable-cache: true
+          cache-suffix: lint-${{ inputs.working-directory }}

      - 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: poetry install --with dev
+        run: uv sync --frozen --group dev

      - name: Get .mypy_cache to speed up mypy
        if: steps.changed-files.outputs.all
-        uses: actions/cache@v3
+        uses: actions/cache@v4
        env:
          SEGMENT_DOWNLOAD_TIMEOUT_MIN: "2"
        with:
          path: |
            ${{ inputs.working-directory }}/.mypy_cache
-          key: mypy-lint-${{ runner.os }}-${{ runner.arch }}-py${{ matrix.python-version }}-${{ inputs.working-directory }}-${{ hashFiles(format('{0}/poetry.lock', inputs.working-directory)) }}
+          key: mypy-lint-${{ runner.os }}-${{ runner.arch }}-py${{ matrix.python-version }}-${{ inputs.working-directory }}-${{ hashFiles(format('{0}/uv.lock', inputs.working-directory)) }}

      - name: Analysing package code with our lint
        if: steps.changed-files.outputs.all
@@ -86,27 +70,18 @@ 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: |
-          poetry install --with dev
+        run: uv sync --group dev

      - name: Get .mypy_cache_test to speed up mypy
        if: steps.changed-files.outputs.all
-        uses: actions/cache@v3
+        uses: actions/cache@v4
        env:
          SEGMENT_DOWNLOAD_TIMEOUT_MIN: "2"
        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}/poetry.lock', inputs.working-directory)) }}
+          key: mypy-test-${{ runner.os }}-${{ runner.arch }}-py${{ matrix.python-version }}-${{ inputs.working-directory }}-${{ hashFiles(format('{0}/uv.lock', inputs.working-directory)) }}

      - name: Analysing tests with our lint
        if: steps.changed-files.outputs.all
@@ -8,9 +8,6 @@ on:
        type: string
        description: "From which folder this pipeline executes"

-env:
-  POETRY_VERSION: "2.1.2"
-
 jobs:
  build:
    runs-on: ubuntu-latest
@@ -26,12 +23,12 @@ jobs:
    name: "test #${{ matrix.python-version }}"
    steps:
      - uses: actions/checkout@v4
-      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
-        uses: "./.github/actions/poetry_setup"
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: astral-sh/setup-uv@v6
        with:
          python-version: ${{ matrix.python-version }}
-          poetry-version: ${{ env.POETRY_VERSION }}
-          cache-key: test-${{ inputs.working-directory }}
+          enable-cache: true
+          cache-suffix: test-${{ inputs.working-directory }}
      - name: Login to Docker Hub
        uses: docker/login-action@v3
        if: ${{ !github.event.pull_request.head.repo.fork }}
@@ -42,14 +39,12 @@ jobs:
      - name: Install dependencies
        shell: bash
        working-directory: ${{ inputs.working-directory }}
-        run: |
-          poetry install --with dev
+        run: uv sync --frozen --group 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
@@ -3,9 +3,6 @@ name: test
 on:
  workflow_call:

-env:
-  POETRY_VERSION: "2.1.2"
-
 jobs:
  build:
    runs-on: ubuntu-latest
@@ -24,12 +21,12 @@ jobs:
    name: "test #${{ matrix.python-version }}"
    steps:
      - uses: actions/checkout@v4
-      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
-        uses: "./.github/actions/poetry_setup"
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: astral-sh/setup-uv@v6
        with:
          python-version: ${{ matrix.python-version }}
-          poetry-version: ${{ env.POETRY_VERSION }}
-          cache-key: test-langgraph
+          enable-cache: true
+          cache-suffix: "test-langgraph"
      - name: Login to Docker Hub
        uses: docker/login-action@v3
        if: ${{ !github.event.pull_request.head.repo.fork }}
@@ -39,13 +36,11 @@ jobs:

      - name: Install dependencies
        shell: bash
-        run: |
-          poetry install --with dev
+        run: uv sync --frozen --group 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
@@ -9,7 +9,6 @@ on:
        description: "From which folder this pipeline executes"

 env:
-  POETRY_VERSION: "2.1.2"
  PYTHON_VERSION: "3.10"

 jobs:
@@ -24,12 +23,12 @@ jobs:
    steps:
      - uses: actions/checkout@v4

-      - name: Set up Python + Poetry ${{ env.POETRY_VERSION }}
-        uses: "./.github/actions/poetry_setup"
+      - name: Set up Python $${ env.PYTHON_VERSION }}
+        uses: astral-sh/setup-uv@v6
        with:
          python-version: ${{ env.PYTHON_VERSION }}
-          poetry-version: ${{ env.POETRY_VERSION }}
-          cache-key: release
+          enable-cache: true
+          cache-suffix: "release"

      # We want to keep this build stage *separate* from the release stage,
      # so that there's no sharing of permissions between them.
@@ -43,7 +42,7 @@ jobs:
      # > from the publish job.
      # https://github.com/pypa/gh-action-pypi-publish#non-goals
      - name: Build project for distribution
-        run: poetry build
+        run: uv build
        working-directory: ${{ inputs.working-directory }}

      - name: Upload build
@@ -57,8 +56,8 @@ jobs:
        shell: bash
        working-directory: ${{ inputs.working-directory }}
        run: |
-          echo pkg-name="$(poetry version | cut -d ' ' -f 1)" >> $GITHUB_OUTPUT
-          echo version="$(poetry version --short)" >> $GITHUB_OUTPUT
+          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)

  publish:
    needs:
@@ -1,57 +0,0 @@
-name: test
-
-on:
-  workflow_call:
-
-env:
-  POETRY_VERSION: "2.1.2"
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        python-version:
-          - "3.11"
-          - "3.12"
-
-    defaults:
-      run:
-        working-directory: libs/scheduler-kafka
-    name: "test #${{ matrix.python-version }}"
-    steps:
-      - uses: actions/checkout@v4
-      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
-        uses: "./.github/actions/poetry_setup"
-        with:
-          python-version: ${{ matrix.python-version }}
-          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 }}
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_RO_TOKEN }}
-
-      - name: Install dependencies
-        shell: bash
-        run: |
-          poetry install --with dev
-
-      - name: Run tests
-        shell: bash
-        run: |
-          make test
-
-      - name: Ensure the tests did not create any additional files
-        shell: bash
-        run: |
-          set -eu
-
-          STATUS="$(git status)"
-          echo "$STATUS"
-
-          # grep will exit non-zero if the target message isn't found,
-          # and `set -e` above will cause the step to fail.
-          echo "$STATUS" | grep 'nothing to commit, working tree clean'
@@ -7,9 +7,6 @@ on:
    paths:
      - "libs/**"

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

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

-env:
-  POETRY_VERSION: "2.1.2"
-
 jobs:
  changes:
    runs-on: ubuntu-latest
@@ -38,7 +35,6 @@ jobs:
              - 'libs/checkpoint/**'
              - 'libs/checkpoint-sqlite/**'
              - 'libs/checkpoint-postgres/**'
-              - 'libs/scheduler-kafka/**'
              - 'libs/prebuilt/**'
            sdk-js:
              - 'libs/sdk-js/**'
@@ -56,7 +52,7 @@ jobs:
            "libs/checkpoint",
            "libs/checkpoint-sqlite",
            "libs/checkpoint-postgres",
-            "libs/scheduler-kafka",
+
            "libs/prebuilt",
          ]
    if: needs.changes.outputs.python == 'true'
@@ -92,14 +88,6 @@ jobs:
    uses: ./.github/workflows/_test_langgraph.yml
    secrets: inherit

-  # NOTE: we're testing scheduler-kafka separately because it requires a different matrix
-  test-scheduler-kafka:
-    needs: changes
-    if: needs.changes.outputs.python == 'true'
-    name: "cd libs/scheduler-kafka"
-    uses: ./.github/workflows/_test_scheduler_kafka.yml
-    secrets: inherit
-
  check-sdk-methods:
    needs: changes
    if: needs.changes.outputs.python == 'true'
@@ -125,26 +113,26 @@ jobs:
          - "3.11"
    steps:
      - uses: actions/checkout@v4
-      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
-        uses: "./.github/actions/poetry_setup"
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: astral-sh/setup-uv@v6
        with:
          python-version: "3.11"
-          poetry-version: ${{ env.POETRY_VERSION }}
-          cache-key: schema-check-cli
+          enable-cache: true
+          cache-suffix: "schema-check-cli"
      - name: Install CLI dependencies
        run: |
          cd libs/cli
-          poetry install
+          uv sync
      - 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
-          poetry run python generate_schema.py
+          uv 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 'poetry run python generate_schema.py' in the libs/cli directory and commit the changes."
+            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."
            diff schemas/schema.json schemas/schema.current.json
            exit 1
          fi
@@ -169,9 +157,9 @@ jobs:
      run:
        working-directory: ${{ matrix.working-directory }}
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - name: Setup Node.js (LTS)
-        uses: actions/setup-node@v3
+        uses: actions/setup-node@v4
        with:
          node-version: "20"
          cache: "yarn"
@@ -195,9 +183,9 @@ jobs:
      run:
        working-directory: ${{ matrix.working-directory }}
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - name: Setup Node.js (LTS)
-        uses: actions/setup-node@v3
+        uses: actions/setup-node@v4
        with:
          node-version: "20"
          cache: "yarn"
@@ -215,7 +203,6 @@ jobs:
        lint-js,
        test,
        test-langgraph,
-        test-scheduler-kafka,
        check-sdk-methods,
        check-schema,
        integration-test,
@@ -4,14 +4,13 @@ on:
  push:
    branches:
      - main
+      - v0
  pull_request:
    branches:
      - main
+      - v0
  workflow_dispatch:

-env:
-  POETRY_VERSION: "2.1.2"
-
 permissions:
  contents: read
  pages: write
@@ -57,21 +56,21 @@ jobs:
        with:
          fetch-depth: 0

-      - name: Set up Python + Poetry ${{ env.POETRY_VERSION }}
-        uses: "./.github/actions/poetry_setup"
+      - name: Set up Python
+        uses: astral-sh/setup-uv@v6
        with:
          python-version: "3.12"
-          poetry-version: ${{ env.POETRY_VERSION }}
-          cache-key: docs
+          enable-cache: true
+          cache-suffix: "docs"

      - name: Install dependencies
        run: |
          yarn
-          poetry install --with test --with docs --no-root
+          uv sync --all-groups
          # we run this installation only for internal PRs
          # as GITHUB_TOKEN is not available for PRs from outside contributors
          if [ -n "${GITHUB_TOKEN}" ]; then
-            poetry run pip install "git+https://${GITHUB_TOKEN}@github.com/langchain-ai/mkdocs-material-insiders.git"
+            uv run pip install "git+https://${GITHUB_TOKEN}@github.com/langchain-ai/mkdocs-material-insiders.git"
          fi

      - name: Run unit tests
@@ -85,9 +84,9 @@ jobs:
        run: make llms-text
      - name: Build site
        run: |
-          # If this is main branch, then we want to download stats. we do this 
+          # If this is v0 branch, then we want to download stats. we do this 
          # with the env variable DOWNLOAD_STATS=true
-          if [ "${{ github.ref }}" == "refs/heads/main" ]; then
+          if [ "${{ github.ref }}" == "refs/heads/v0" ]; then
            DOWNLOAD_STATS=true make build-docs
          else
            make build-docs
@@ -103,7 +102,7 @@ jobs:
        run: |
          if [ "${{ github.event_name }}" == "schedule" ]; then
            echo "Running link check on all HTML files matching notebooks in docs directory..."
-            poetry run pytest -v \
+            uv 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/.*" \
@@ -128,7 +127,7 @@ jobs:
            echo "Changed files: ${CHANGED_FILES}"
            if [ -n "${CHANGED_FILES}" ]; then
              echo "Running link check on HTML files matching changed notebook files..."
-              poetry run pytest -v \
+              uv 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/.*" \
@@ -147,8 +146,8 @@ jobs:
          fi

      - name: Configure GitHub Pages
-        if: github.ref == 'refs/heads/main'
-        uses: actions/configure-pages@v4
+        if: github.ref == 'refs/heads/v0'
+        uses: actions/configure-pages@v5

      - name: Upload Pages Artifact
        # if: github.ref == 'refs/heads/main'
@@ -157,6 +156,6 @@ jobs:
          path: ./docs/site/

      - name: Deploy to GitHub Pages
-        if: github.ref == 'refs/heads/main'
+        if: github.ref == 'refs/heads/v0'
        id: deployment
        uses: actions/deploy-pages@v4
@@ -11,9 +11,6 @@ on:
    - cron: "0 5 * * *"
  workflow_dispatch:

-env:
-  POETRY_VERSION: "2.1.2"
-
 jobs:
  markdown-link-check:
    runs-on: ubuntu-latest
@@ -10,7 +10,6 @@ on:

 env:
  PYTHON_VERSION: "3.11"
-  POETRY_VERSION: "2.1.2"

 jobs:
  build:
@@ -26,12 +25,12 @@ jobs:
    steps:
      - uses: actions/checkout@v4

-      - name: Set up Python + Poetry ${{ env.POETRY_VERSION }}
-        uses: "./.github/actions/poetry_setup"
+      - name: Set up Python
+        uses: astral-sh/setup-uv@v6
        with:
          python-version: ${{ env.PYTHON_VERSION }}
-          poetry-version: ${{ env.POETRY_VERSION }}
-          cache-key: release
+          enable-cache: true
+          cache-suffix: "release"

      # We want to keep this build stage *separate* from the release stage,
      # so that there's no sharing of permissions between them.
@@ -45,7 +44,7 @@ jobs:
      # > from the publish job.
      # https://github.com/pypa/gh-action-pypi-publish#non-goals
      - name: Build project for distribution
-        run: poetry build
+        run: uv build
        working-directory: ${{ inputs.working-directory }}

      - name: Upload build
@@ -59,8 +58,8 @@ jobs:
        shell: bash
        working-directory: ${{ inputs.working-directory }}
        run: |
-          PKG_NAME="$(poetry version | cut -d ' ' -f 1)"
-          VERSION="$(poetry version --short)"
+          PKG_NAME=$(grep -m 1 "^name = " pyproject.toml | cut -d '"' -f 2)
+          VERSION=$(grep -m 1 "^version = " pyproject.toml | cut -d '"' -f 2)
          SHORT_PKG_NAME="$(echo "$PKG_NAME" | sed -e 's/langgraph//g' -e 's/-//g')"
          if [ -z $SHORT_PKG_NAME ]; then
            TAG="$VERSION"
@@ -163,11 +162,11 @@ jobs:
      # - The package is published, and it breaks on the missing dependency when
      #   used in the real world.

-      - name: Set up Python + Poetry ${{ env.POETRY_VERSION }}
-        uses: "./.github/actions/poetry_setup"
+      - name: Set up Python
+        uses: astral-sh/setup-uv@v6
        with:
          python-version: ${{ env.PYTHON_VERSION }}
-          poetry-version: ${{ env.POETRY_VERSION }}
+          enable-cache: true

      - name: Import published package
        shell: bash
@@ -185,18 +184,18 @@ jobs:
        # - attempt install again after 5 seconds if it fails because there is
        #   sometimes a delay in availability on test pypi
        run: |
-          poetry run pip install \
+          uv run pip install \
            --extra-index-url https://test.pypi.org/simple/ \
            "$PKG_NAME==$VERSION" || \
          ( \
            sleep 5 && \
-            poetry run pip install \
+            uv run pip install \
              --extra-index-url https://test.pypi.org/simple/ \
              "$PKG_NAME==$VERSION" \
          )

          if [[ "$PKG_NAME" == *prebuilt* ]]; then
-            poetry run pip install langgraph
+            uv run pip install langgraph
          fi

          if [[ "$PKG_NAME" == *checkpoint* || "$PKG_NAME" == *prebuilt* ]]; then
@@ -209,10 +208,10 @@ jobs:
            IMPORT_NAME="$(echo "$PKG_NAME" | sed s/-/_/g)"
          fi

-          poetry run python -c "import $IMPORT_NAME; print(dir($IMPORT_NAME))"
+          uv run python -c "import $IMPORT_NAME; print(dir($IMPORT_NAME))"

      - name: Import test dependencies
-        run: poetry install --with dev
+        run: uv sync --group dev
        working-directory: ${{ inputs.working-directory }}

      # Overwrite the local version of the package with the test PyPI version.
@@ -223,7 +222,7 @@ jobs:
          PKG_NAME: ${{ needs.build.outputs.pkg-name }}
          VERSION: ${{ needs.build.outputs.version }}
        run: |
-          poetry run pip install \
+          uv run pip install \
            --extra-index-url https://test.pypi.org/simple/ \
            "$PKG_NAME==$VERSION"

@@ -253,12 +252,12 @@ jobs:
    steps:
      - uses: actions/checkout@v4

-      - name: Set up Python + Poetry ${{ env.POETRY_VERSION }}
-        uses: "./.github/actions/poetry_setup"
+      - name: Set up Python
+        uses: astral-sh/setup-uv@v6
        with:
          python-version: ${{ env.PYTHON_VERSION }}
-          poetry-version: ${{ env.POETRY_VERSION }}
-          cache-key: release
+          enable-cache: true
+          cache-suffix: "release"

      - uses: actions/download-artifact@v4
        with:
@@ -294,12 +293,12 @@ jobs:
    steps:
      - uses: actions/checkout@v4

-      - name: Set up Python + Poetry ${{ env.POETRY_VERSION }}
-        uses: "./.github/actions/poetry_setup"
+      - name: Set up Python
+        uses: astral-sh/setup-uv@v6
        with:
          python-version: ${{ env.PYTHON_VERSION }}
-          poetry-version: ${{ env.POETRY_VERSION }}
-          cache-key: release
+          enable-cache: true
+          cache-suffix: "release"

      - uses: actions/download-artifact@v4
        with:
@@ -22,7 +22,7 @@ jobs:
      - uses: actions/checkout@v4
      # JS Build
      - name: Use Node.js
-        uses: actions/setup-node@v3
+        uses: actions/setup-node@v4
        with:
          node-version: "20"
          cache: "yarn"
@@ -27,30 +27,30 @@ jobs:
    steps:
      - uses: actions/checkout@v4
      - name: Set up Python + Poetry
-        uses: "./.github/actions/poetry_setup"
+        uses: astral-sh/setup-uv@v6
        with:
-          python-version: 3.11
-          poetry-version: 2.1.2
-          cache-key: test-langgraph-notebooks
+          python-version: "3.11"
+          enable-cache: true
+          cache-suffix: "test-langgraph-notebooks"

      - name: Install dependencies
        run: |
-          poetry install --with test --no-root
-          poetry run pip install jupyter
+          uv sync --group test
+          uv run pip install jupyter

      - name: Start services
        run: make start-services

      - name: Pre-download tiktoken files
        run: |
-          poetry run python _scripts/download_tiktoken.py
+          uv run python _scripts/download_tiktoken.py

      - name: Prepare notebooks
        run: |
          if [ "${{ matrix.lib-version }}" = "development" ]; then
-            poetry run python _scripts/prepare_notebooks_for_ci.py --comment-install-cells
+            uv run python _scripts/prepare_notebooks_for_ci.py --comment-install-cells
          else
-            poetry run python _scripts/prepare_notebooks_for_ci.py
+            uv run python _scripts/prepare_notebooks_for_ci.py
          fi

      - name: Run notebooks
@@ -181,3 +181,4 @@ Chinook.db
 .vercel
 .turbo
 .editorconfig
+.scratch
@@ -0,0 +1,55 @@
+# AGENTS Instructions
+
+This repository is a monorepo. Each library lives in a subdirectory under `libs/`.
+
+When you modify code in any library, run the following commands in that library's directory before creating a pull request:
+
+- `make format` – run code formatters
+- `make lint` – run the linter
+- `make test` – execute the test suite
+
+To run a particular test file or to pass additional pytest options you can specify the `TEST` variable:
+
+```
+TEST=path/to/test.py make test
+```
+
+Other pytest arguments can also be supplied inside the `TEST` variable.
+
+## Libraries
+
+The repository contains several Python and JavaScript/TypeScript libraries.
+Below is a high-level overview:
+
+- **checkpoint** – base interfaces for LangGraph checkpointers.
+- **checkpoint-postgres** – Postgres implementation of the checkpoint saver.
+- **checkpoint-sqlite** – SQLite implementation of the checkpoint saver.
+- **cli** – official command-line interface for LangGraph.
+- **langgraph** – core framework for building stateful, multi-actor agents.
+- **prebuilt** – high-level APIs for creating and running agents and tools.
+- **sdk-js** – JS/TS SDK for interacting with the LangGraph REST API.
+- **sdk-py** – Python SDK for the LangGraph Platform API.
+
+### Dependency map
+
+The diagram below lists downstream libraries for each production dependency as
+declared in that library's `pyproject.toml` (or `package.json`).
+
+```text
+checkpoint
+├── checkpoint-postgres
+├── checkpoint-sqlite
+├── prebuilt
+└── langgraph
+
+prebuilt
+└── langgraph
+
+sdk-py
+├── langgraph
+└── cli
+
+sdk-js (standalone)
+```
+
+Changes to a library may impact all of its dependents shown above.
@@ -109,7 +109,7 @@ Here are some high-level tips on writing a good how-to guide:
 LangGraph's conceptual guides fall under the **Explanation** quadrant of Diataxis. They should cover LangChain terms and concepts
 in a more abstract way than how-to guides or tutorials, and should be geared towards curious users interested in
 gaining a deeper understanding of the framework. Try to avoid excessively large code examples. The goal here is to
-impart perspective to the user rather than to finish a practical project. These guides should cover **why** things work they way they do.
+impart perspective to the user rather than to finish a practical project. These guides should cover **why** things work the way they do.


 To quote the Diataxis website:
@@ -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 actue need.
+We generally do not merge new tutorials from outside contributors without an actual need.
 We welcome updates as well as new integration docs, how-tos, and references.

 ### Avoid duplication
@@ -227,6 +227,7 @@ 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
 ```
@@ -0,0 +1,58 @@
+# Define the directories containing projects
+LIBS_DIRS := $(wildcard libs/*)
+
+# Default target
+.PHONY: all
+all: lint format lock test
+
+# Install dependencies for all projects
+.PHONY: install
+install:
+	@echo "Creating virtual environment..."
+	@uv venv
+	@for dir in $(LIBS_DIRS); do \
+		if [ -f $$dir/pyproject.toml ]; then \
+			echo "Installing dependencies for $$dir"; \
+			uv pip install -e $$dir; \
+		fi; \
+	done
+
+# Lint all projects
+.PHONY: lint
+lint:
+	@for dir in $(LIBS_DIRS); do \
+		if [ -f $$dir/Makefile ]; then \
+			echo "Running lint in $$dir"; \
+			$(MAKE) -C $$dir lint; \
+		fi; \
+	done
+
+# Format all projects
+.PHONY: format
+format:
+	@for dir in $(LIBS_DIRS); do \
+		if [ -f $$dir/Makefile ]; then \
+			echo "Running format in $$dir"; \
+			$(MAKE) -C $$dir format; \
+		fi; \
+	done
+
+# Lock all projects
+.PHONY: lock
+lock:
+	@for dir in $(LIBS_DIRS); do \
+		if [ -f $$dir/Makefile ]; then \
+			echo "Running lock in $$dir"; \
+			(cd $$dir && uv lock); \
+		fi; \
+	done
+
+# Test all projects
+.PHONY: test
+test:
+	@for dir in $(LIBS_DIRS); do \
+		if [ -f $$dir/Makefile ]; then \
+			echo "Running test in $$dir"; \
+			$(MAKE) -C $$dir test; \
+		fi; \
+	done
@@ -12,9 +12,8 @@
 [![Downloads](https://static.pepy.tech/badge/langgraph/month)](https://pepy.tech/project/langgraph)
 [![Open Issues](https://img.shields.io/github/issues-raw/langchain-ai/langgraph)](https://github.com/langchain-ai/langgraph/issues)
 [![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 powerful 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 low-level orchestration framework for building, managing, and deploying long-running, stateful agents.

 ## Get started

@@ -74,10 +73,10 @@ While LangGraph can be used standalone, it also integrates seamlessly with any L

 - [Guides](https://langchain-ai.github.io/langgraph/how-tos/): Quick, actionable code snippets for topics such as streaming, adding memory & persistence, and design patterns (e.g. branching, subgraphs, etc.).
 - [Reference](https://langchain-ai.github.io/langgraph/reference/graphs/): Detailed reference on core classes, methods, how to use the graph and checkpointing APIs, and higher-level prebuilt components.
- [Examples](https://langchain-ai.github.io/langgraph/tutorials/): Guided examples on getting started with LangGraph.
+- [Examples](https://langchain-ai.github.io/langgraph/tutorials/overview/): 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 powerful, production-ready AI applications.
+- [Case studies](https://www.langchain.com/built-with-langgraph): Hear how industry leaders use LangGraph to ship AI applications at scale.

 ## Acknowledgements

@@ -12,32 +12,30 @@ build-prebuilt:
 	# generates the final prebuilt page.
 	@if [ "$(DOWNLOAD_STATS)" = "true" ]; then \
 		set -x; \
-		poetry run python -m _scripts.third_party_page.get_download_stats stats.yml; \
+		uv run python -m _scripts.third_party_page.get_download_stats stats.yml; \
 		set +x; \
 	else \
 		set -x; \
-		poetry run python -m _scripts.third_party_page.get_download_stats --fake stats.yml; \
+		uv run python -m _scripts.third_party_page.get_download_stats --fake stats.yml; \
 		set +x; \
 	fi
-	poetry run python -m _scripts.third_party_page.create_third_party_page stats.yml docs/agents/prebuilt.md --language python
+	uv 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
-	poetry run python -m mkdocs build --clean -f mkdocs.yml --strict
+	uv run python -m mkdocs build --clean -f mkdocs.yml --strict

 llms-text:
-	poetry run python -m _scripts.generate_llms_text docs/llms-full.txt
+	uv run python -m _scripts.generate_llms_text docs/llms-full.txt

 install-vercel-deps:
-	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
+	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

 tests:
 	# Run unit tests
-	poetry run pytest tests/unit_tests
+	uv run pytest tests/unit_tests


 vercel-build-docs: install-vercel-deps
@@ -45,10 +43,10 @@ vercel-build-docs: install-vercel-deps


 serve-clean-docs: clean-docs
-	poetry run python -m mkdocs serve -c -f mkdocs.yml --strict -w ../libs/langgraph
+	uv run python -m mkdocs serve -c -f mkdocs.yml --strict -w ../libs/langgraph

 serve-docs: build-typedoc
-	poetry run python -m mkdocs serve -f mkdocs.yml -w ../libs/langgraph  -w ../libs/checkpoint -w ../libs/sdk-py --dirty
+	uv 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
@@ -56,13 +54,13 @@ clean-docs:

 ## Run format against the project documentation.
 format-docs:
-	poetry run ruff format docs
-	poetry run ruff check --fix docs
+	uv run ruff format docs
+	uv run ruff check --fix docs

 # Check the docs for linting violations
 lint-docs:
-	poetry run ruff format --check docs
-	poetry run ruff check docs
+	uv run ruff format --check docs
+	uv run ruff check docs

 codespell:
 	./codespell_notebooks.sh .
@@ -3,7 +3,7 @@
 To setup requirements for building docs you can run:

 ```bash
-poetry install --with test
+uv sync --group test
 ```

 ## Serving documentation locally
@@ -8,7 +8,7 @@ execute_notebook() {
    file="$1"
    echo "Starting execution of $file"
    start_time=$(date +%s)
-    if ! output=$(time poetry run jupyter execute "$file" 2>&1); then
+    if ! output=$(time uv 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"
@@ -1,10 +1,19 @@
 """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

@@ -13,7 +22,49 @@ HERE = os.path.dirname(os.path.abspath(__file__))
 SOURCE_DIR = os.path.abspath(os.path.join(os.path.dirname(HERE), "docs"))


-def _make_llms_text(output_file: str) -> str:
+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:
    """Generate a consolidated text file from markdown/notebook files for LLM training.

    Args:
@@ -21,11 +72,9 @@ def _make_llms_text(output_file: str) -> str:
    """
    # 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)
    )
@@ -35,30 +84,14 @@ def _make_llms_text(output_file: str) -> str:

    all_content = []

-    # Process each file
-    for file_path in all_files:
-        print(f"Processing {file_path}")
-        rel_path = os.path.relpath(file_path, SOURCE_DIR)
+    # Process files concurrently
+    tasks = [convert_ipynb_to_md(file_path) for file_path in all_files]
+    results = await asyncio.gather(*tasks)

-        # 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
-        )
+    # Combine results with file paths
+    for file_path, processed_content in zip(all_files, results):
        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
@@ -69,6 +102,168 @@ def _make_llms_text(output_file: str) -> str:
        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

@@ -78,6 +273,23 @@ 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()
-    _make_llms_text(args.output_file)
+    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)
@@ -1,9 +1,16 @@
+"""mkdocs hooks for adding custom logic to documentation pipeline.
+
+Lifecycle events: https://www.mkdocs.org/dev-guide/plugins/#events
+"""
+
 import logging
 import os
 import posixpath
 import re
 from typing import Any, Dict

+from bs4 import BeautifulSoup
+from mkdocs.config.defaults import MkDocsConfig
 from mkdocs.structure.files import Files, File
 from mkdocs.structure.pages import Page

@@ -39,6 +46,7 @@ REDIRECT_MAP = {
    "how-tos/configuration.ipynb": "how-tos/graph-api/#add-runtime-configuration",
    "how-tos/node-retries.ipynb": "how-tos/graph-api/#add-retry-policies",
    "how-tos/return-when-recursion-limit-hits.ipynb": "how-tos/graph-api/#impose-a-recursion-limit",
+    "how-tos/async.ipynb": "how-tos/graph-api/#async",
    # memory how-tos
    "how-tos/memory/manage-conversation-history.ipynb": "how-tos/memory.ipynb",
    "how-tos/memory/delete-messages.ipynb": "how-tos/memory.ipynb#delete-messages",
@@ -52,6 +60,7 @@ 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",
@@ -69,6 +78,7 @@ 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",
@@ -98,8 +108,7 @@ REDIRECT_MAP = {
    "how-tos/deploy-self-hosted.md": "cloud/deployment/self_hosted_data_plane.md",
    "concepts/self_hosted.md": "concepts/langgraph_self_hosted_data_plane.md",
    # assistant redirects
-    "cloud/how-tos/assistant_versioning.md": "cloud/how-tos/configuration_cloud.md"
-
+    "cloud/how-tos/assistant_versioning.md": "cloud/how-tos/configuration_cloud.md",
 }


@@ -289,7 +298,7 @@ Redirecting...
 """


-def write_html(site_dir, old_path, new_path):
+def _write_html(site_dir, old_path, new_path):
    """Write an HTML file in the site_dir with a meta redirect to the new page"""
    # Determine all relevant paths
    old_path_abs = os.path.join(site_dir, old_path)
@@ -305,6 +314,52 @@ def write_html(site_dir, old_path, new_path):
        f.write(content)


+def _inject_gtm(html: str) -> str:
+    """Inject Google Tag Manager code into the HTML.
+
+    Code to inject Google Tag Manager noscript tag immediately after <body>.
+
+    This is done via hooks rather than via a template because the MkDocs material
+    theme does not seem to allow placing the code immediately after the <body> tag
+    without modifying the template files directly.
+
+    Args:
+        html: The HTML content to modify.
+
+    Returns:
+        The modified HTML content with GTM code injected.
+    """
+    # Code was copied from Google Tag Manager setup instructions.
+    gtm_code = """
+<!-- Google Tag Manager (noscript) -->
+<noscript><iframe src="https://www.googletagmanager.com/ns.html?id=GTM-T35S4S46"
+height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
+<!-- End Google Tag Manager (noscript) -->
+"""
+    soup = BeautifulSoup(html, "html.parser")
+    body = soup.body
+    if body:
+        # Insert the GTM code as raw HTML at the top of <body>
+        body.insert(0, BeautifulSoup(gtm_code, "html.parser"))
+        return str(soup)
+    else:
+        return html  # fallback if no <body> found
+
+
+def on_post_page(output: str, page: Page, config: MkDocsConfig) -> str:
+    """Inject Google Tag Manager noscript tag immediately after <body>.
+
+    Args:
+        output: The HTML output of the page.
+        page: The page instance.
+        config: The MkDocs configuration object.
+
+    Returns:
+        modified HTML output with GTM code injected.
+    """
+    return _inject_gtm(output)
+
+
 # Create HTML files for redirects after site dir has been built
 def on_post_build(config):
    use_directory_urls = config.get("use_directory_urls")
@@ -321,4 +376,4 @@ def on_post_build(config):
            + hash
            + suffix
        )
-        write_html(config["site_dir"], old_html_path, new_html_path)
+        _write_html(config["site_dir"], old_html_path, new_html_path)
@@ -15,7 +15,7 @@ This guide shows you how to set up and use LangGraph's **prebuilt**, **reusable*

 Before you start this tutorial, ensure you have the following:

- An [Anthropic](https://console.anthropic.com/settings/admin-keys) API key 
+- An [Anthropic](https://console.anthropic.com/settings/keys) API key 

 ## 1. Install dependencies

@@ -106,7 +106,7 @@ for chunk in agent.stream(
    print("\n")
 ```

-1. The [`interrupt` function][langgraph.types.interrupt] is used in conjunction with the [`Command`](../reference/types.md#langgraph.types.Command) object to resume the graph with a value provided by the human.
+1. The [`interrupt` function][langgraph.types.interrupt] is used in conjunction with the [`Command`][langgraph.types.Command] object to resume the graph with a value provided by the human.

 ## Using with Agent Inbox

@@ -29,7 +29,7 @@ from langchain_mcp_adapters.client import MultiServerMCPClient
 from langgraph.prebuilt import create_react_agent

 # highlight-next-line
-async with MultiServerMCPClient(
+client = MultiServerMCPClient(
    {
        "math": {
            "command": "python",
@@ -38,23 +38,25 @@ async with MultiServerMCPClient(
            "transport": "stdio",
        },
        "weather": {
-            # Ensure your start your weather server on port 8000
-            "url": "http://localhost:8000/sse",
-            "transport": "sse",
+            # Ensure you start your weather server on port 8000
+            "url": "http://localhost:8000/mcp",
+            "transport": "streamable_http",
        }
    }
-) 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?"}]}
-    )
+)
+# 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?"}]}
+)
 ```

 ## Custom MCP servers
@@ -87,7 +89,7 @@ if __name__ == "__main__":
    mcp.run(transport="stdio")
 ```

-```python title="Example Weather Server (SSE transport)"
+```python title="Example Weather Server (Streamable HTTP transport)"
 from mcp.server.fastmcp import FastMCP

 mcp = FastMCP("Weather")
@@ -98,7 +100,7 @@ async def get_weather(location: str) -> str:
    return "It's always sunny in New York"

 if __name__ == "__main__":
-    mcp.run(transport="sse")
+    mcp.run(transport="streamable-http")
 ```

 ## Additional resources
@@ -82,13 +82,13 @@ ny_response = agent.invoke(
 ```

 1. The `InMemorySaver` is a checkpointer that stores the agent's state in memory. In a production setting, you would typically use a database or other persistent storage. Please review the [checkpointer documentation](../reference/checkpoints.md) for more options. If you're deploying with **LangGraph Platform**, the platform will provide a production-ready checkpointer for you.
-2. The `checkpointer` is passed to the agent. This enables the agent to persist its state across invocations. Please note that 
+2. The `checkpointer` is passed to the agent. This enables the agent to persist its state across invocations.
 3. A unique `thread_id` is provided in the config. This ID is used to identify the conversation session. The value is controlled by the user and can be any string.
 4. The agent will continue the conversation using the same `thread_id`. This will allow the agent to infer that the user is asking specifically about the **weather** in New York. 

 When the agent is invoked the second time with the same `thread_id`, the original message history from the first conversation is automatically included, allowing the agent to infer that the user is asking specifically about the **weather** in New York.

-!!! Note "LangGraph Platform providers a production-ready checkpointer"
+!!! Note "LangGraph Platform provides a production-ready checkpointer"

    If you're using [LangGraph Platform](./deployment.md), during deployment your checkpointer will be automatically configured to use a production-ready database.

@@ -294,7 +294,7 @@ agent.invoke(
 )
 ```

-For more details, see [how to update state from tools](../how-tos/update-state-from-tools.ipynb).
+For more details, see [how to update state from tools](../how-tos/tool-calling.ipynb#update).

 ## Long-term memory

@@ -302,7 +302,7 @@ Use long-term memory to store user-specific or application-specific data across

 To use long-term memory, you need to:

-1. [Configure a store](../how-tos/cross-thread-persistence.ipynb) to persist data across invocations.
+1. [Configure a store](../how-tos/persistence.ipynb#add-long-term-memory) to persist data across invocations.
 2. Use the [`get_store`][langgraph.config.get_store] function to access the store from within tools or prompts.

 ### Read { #read-long-term }
@@ -23,29 +23,182 @@ Compatible models can be found in the [LangChain integrations directory](https:/

 You can configure an agent with a model name string:

-```python
-from langgraph.prebuilt import create_react_agent
+=== "OpenAI"
+
+    ```python
+    import os
+    from langgraph.prebuilt import create_react_agent
+
+    os.environ["OPENAI_API_KEY"] = "sk-..."
+
+    agent = create_react_agent(
+        # highlight-next-line
+        model="openai:gpt-4.1",
+        # other parameters
+    )
+    ```
+
+=== "Anthropic"
+
+    ```python
+    import os
+    from langgraph.prebuilt import create_react_agent
+
+    os.environ["ANTHROPIC_API_KEY"] = "sk-..."
+
+    agent = create_react_agent(
+        # highlight-next-line
+        model="anthropic:claude-3-7-sonnet-latest",
+        # other parameters
+    )
+    ```
+
+=== "Azure"
+
+    ```python
+    import os
+    from langgraph.prebuilt import create_react_agent
+
+    os.environ["AZURE_OPENAI_API_KEY"] = "..."
+    os.environ["AZURE_OPENAI_ENDPOINT"] = "..."
+    os.environ["OPENAI_API_VERSION"] = "2025-03-01-preview"
+
+    agent = create_react_agent(
+        # highlight-next-line
+        model="azure_openai:gpt-4.1",
+        # other parameters
+    )
+    ```
+
+=== "Google Gemini"
+
+    ```python
+    import os
+    from langgraph.prebuilt import create_react_agent
+
+    os.environ["GOOGLE_API_KEY"] = "..."
+
+    agent = create_react_agent(
+        # highlight-next-line
+        model="google_genai:gemini-2.0-flash",
+        # other parameters
+    )
+    ```
+
+=== "AWS Bedrock"
+
+    ```python
+    from langgraph.prebuilt import create_react_agent
+
+    # Follow the steps here to configure your credentials:
+    # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started.html
+
+    agent = create_react_agent(
+        # highlight-next-line
+        model="bedrock_converse:anthropic.claude-3-5-sonnet-20240620-v1:0",
+        # other parameters
+    )
+    ```

-agent = create_react_agent(
-    # highlight-next-line
-    model="anthropic:claude-3-7-sonnet-latest",
-    # other parameters
-)
-```

 ## Using `init_chat_model`

 The [`init_chat_model`](https://python.langchain.com/docs/how_to/chat_models_universal_init/) utility simplifies model initialization with configurable parameters:

-```python
-from langchain.chat_models import init_chat_model
+=== "OpenAI"
+
+    ```
+    pip install -U "langchain[openai]"
+    ```
+    ```python
+    import os
+    from langchain.chat_models import init_chat_model
+
+    os.environ["OPENAI_API_KEY"] = "sk-..."
+
+    model = init_chat_model(
+        "openai:gpt-4.1",
+        temperature=0,
+        # other parameters
+    )
+    ```
+
+=== "Anthropic"
+
+    ```
+    pip install -U "langchain[anthropic]"
+    ```
+    ```python
+    import os
+    from langchain.chat_models import init_chat_model
+
+    os.environ["ANTHROPIC_API_KEY"] = "sk-..."
+
+    model = init_chat_model(
+        "anthropic:claude-3-5-sonnet-latest",
+        temperature=0,
+        # other parameters
+    )
+    ```
+
+=== "Azure"
+
+    ```
+    pip install -U "langchain[openai]"
+    ```
+    ```python
+    import os
+    from langchain.chat_models import init_chat_model
+
+    os.environ["AZURE_OPENAI_API_KEY"] = "..."
+    os.environ["AZURE_OPENAI_ENDPOINT"] = "..."
+    os.environ["OPENAI_API_VERSION"] = "2025-03-01-preview"
+
+    model = init_chat_model(
+        "azure_openai:gpt-4.1",
+        azure_deployment=os.environ["AZURE_OPENAI_DEPLOYMENT_NAME"],
+        temperature=0,
+        # other parameters
+    )
+    ```
+
+=== "Google Gemini"
+
+    ```
+    pip install -U "langchain[google-genai]"
+    ```
+    ```python
+    import os
+    from langchain.chat_models import init_chat_model
+
+    os.environ["GOOGLE_API_KEY"] = "..."
+
+    model = init_chat_model(
+        "google_genai:gemini-2.0-flash",
+        temperature=0,
+        # other parameters
+    )
+    ```
+
+=== "AWS Bedrock"
+
+    ```
+    pip install -U "langchain[aws]"
+    ```
+    ```python
+    from langchain.chat_models import init_chat_model
+
+    # Follow the steps here to configure your credentials:
+    # https://docs.aws.amazon.com/bedrock/latest/userguide/getting-started.html
+
+    model = init_chat_model(
+        "anthropic.claude-3-5-sonnet-20240620-v1:0",
+        model_provider="bedrock_converse",
+        temperature=0,
+        # other parameters
+    )
+    ```

-model = init_chat_model(
-    "anthropic:claude-3-7-sonnet-latest",
-    temperature=0,
-    max_tokens=2048
-)
-```

 Refer to the [API reference](https://python.langchain.com/api_reference/langchain/chat_models/langchain.chat_models.base.init_chat_model.html) for advanced options.

@@ -9,7 +9,7 @@ hide:

 # Multi-agent

-A single agent might struggle if it needs to specialize in multiple domains or manage many tools. To tackle this, you can break your agent into smaller, independent agents and composing them into a [multi-agent system](../concepts/multi_agent.md).
+A single agent might struggle if it needs to specialize in multiple domains or manage many tools. To tackle this, you can break your agent into smaller, independent agents and compose them into a [multi-agent system](../concepts/multi_agent.md).

 In multi-agent systems, agents need to communicate between each other. They do so via [handoffs](#handoffs) — a primitive that describes which agent to hand control to and the payload to send to that agent.

@@ -53,3 +53,139 @@ 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>
@@ -10,7 +10,7 @@ hide:
 # Running agents


-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.
+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.


 ## 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 .invoke()` or `async for` with `.astream()`
+- **Asynchronous** using `await .ainvoke()` or `async for` with `.astream()`

 === "Sync invocation"
    ```python
@@ -280,7 +280,21 @@ LangGraph allows access to short-term and long-term memory from tools. See [Memo

 ## Prebuilt tools

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

 You can browse the full list of available integrations in the [LangChain integrations directory](https://python.langchain.com/docs/integrations/tools/).

@@ -0,0 +1,19 @@
+{
+    "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__;"
+}
+  
@@ -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 a 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 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.
@@ -62,6 +62,15 @@ Starting from the `LangGraph Platform` view...
 1. In the panel, select the `Server` tab to view server logs for the revision. Server logs are only available after a revision has been deployed.
 1. Within the `Server` tab, adjust the date/time range picker as needed. By default, the date/time range picker is set to the `Last 7 days`.

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

 Interrupting a revision will stop deployment of the revision.
@@ -16,4 +16,4 @@ Users can add an array of additional lines to add to the Dockerfile following th
 }
 ```

-This would install the system packages required to use Pillow if we were working with `jpeq` or `png` image formats. 
+This would install the system packages required to use Pillow if we were working with `jpeg` or `png` image formats. 
@@ -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.

-!!! important "Beta"
-    The Self-Hosted Control Plane deployment option is currently in beta stage.
+!!! info "Important"
+    The Self-Hosted Control Plane deployment option is currently in beta stage and requires an [Enterprise](../../concepts/plans.md) plan.

 ## Prerequisites

@@ -30,18 +30,17 @@ Before deploying, review the [conceptual guide for the Self-Hosted Control Plane
    1. `LangGraphPlatform CRD`: A CRD for LangGraph Platform deployments. This contains the spec for managing an instance of a LangGraph platform deployment.
    1. `operator`: This operator handles changes to your LangGraph Platform CRDs.
    1. `host-backend`: This is the [control plane](../../concepts/langgraph_control_plane.md).
-1. Two additional images will be used by the chart.
+1. Two additional images will be used by the chart. Use the images that are specified in the latest release.

        hostBackendImage:
          repository: "docker.io/langchain/hosted-langserve-backend"
          pullPolicy: IfNotPresent
-          tag: "0.9.80"
        operatorImage:
          repository: "docker.io/langchain/langgraph-operator"
          pullPolicy: IfNotPresent
-          tag: "aa9dff4"

-1. In your `values.yaml` file, enable the `langgraphPlatform` option. Note that you must also have a valid ingress setup:
+1. In your config file for langsmith (usually `langsmith_config.yaml`, enable the `langgraphPlatform` option. Note that you must also have a valid ingress setup:
+
        config:
          langgraphPlatform:
            enabled: true
@@ -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.

-!!! important "Beta"
-    The Self-Hosted Data Plane deployment option is currently in beta stage.
+!!! info "Important"
+    The Self-Hosted Data Plane deployment option is currently in beta stage and requires an [Enterprise](../../concepts/plans.md) plan.

 ## 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 install on your cluster.
+1. A valid `Ingress` controller is installed on your cluster.
 1. You have slack space in your cluster for multiple deployments. `Cluster-Autoscaler` is recommended to automatically provision new nodes.

 ### Setup
@@ -95,7 +95,7 @@ my-app/

 ## Define Graphs

-Implement your graphs! Graphs can be defined in a single file or multiple files. Make note of the variable names of each [CompiledGraph][langgraph.graph.graph.CompiledGraph] to be included in the LangGraph application. The variable names will be used later when creating the [LangGraph configuration file](../reference/cli.md#configuration-file).
+Implement your graphs! Graphs can be defined in a single file or multiple files. Make note of the variable names of each [CompiledStateGraph][langgraph.graph.state.CompiledStateGraph] to be included in the LangGraph application. The variable names will be used later when creating the [LangGraph configuration file](../reference/cli.md#configuration-file).

 Example `agent.py` file, which shows how to import from other modules you define (code for the modules is not shown here, please see [this repository](https://github.com/langchain-ai/langgraph-example) to see their implementation):

@@ -129,9 +129,6 @@ 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
@@ -155,10 +155,6 @@ 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
@@ -56,22 +56,27 @@ cloudpickle>=3.0.0
 Example `pyproject.toml` file:

 ```toml
-[tool.poetry]
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
 name = "my-agent"
 version = "0.0.1"
 description = "An excellent agent build for LangGraph Platform."
-authors = ["Polly the parrot <1223+polly@users.noreply.github.com>"]
-license = "MIT"
+authors = [
+    {name = "Polly the parrot", email = "1223+polly@users.noreply.github.com"}
+]
+license = {text = "MIT"}
 readme = "README.md"
+requires-python = ">=3.9"
+dependencies = [
+    "langgraph>=0.2.0",
+    "langchain-fireworks>=0.1.3"
+]

-[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"
+[tool.hatch.build.targets.wheel]
+packages = ["my_agent"]
 ```

 Example file directory:
@@ -103,7 +108,7 @@ my-app/

 ## Define Graphs

-Implement your graphs! Graphs can be defined in a single file or multiple files. Make note of the variable names of each [CompiledGraph][langgraph.graph.graph.CompiledGraph] to be included in the LangGraph application. The variable names will be used later when creating the [LangGraph configuration file](../reference/cli.md#configuration-file).
+Implement your graphs! Graphs can be defined in a single file or multiple files. Make note of the variable names of each [CompiledStateGraph][langgraph.graph.state.CompiledStateGraph] to be included in the LangGraph application. The variable names will be used later when creating the [LangGraph configuration file](../reference/cli.md#configuration-file).

 Example `agent.py` file, which shows how to import from other modules you define (code for the modules is not shown here, please see [this repository](https://github.com/langchain-ai/langgraph-example-pyproject) to see their implementation):

@@ -137,9 +142,6 @@ 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
@@ -8,7 +8,7 @@ Please see [the overview of LangGraph human-in-the-loop](../../concepts/human_in

 The [`interrupt` function][langgraph.types.interrupt] in LangGraph enables human-in-the-loop workflows by pausing the graph at a specific node, presenting information to a human, and resuming the graph with their input. It's useful for tasks like approvals, edits, or gathering additional context.

-The graph is resumed using a [`Command`](../reference/types.md#langgraph.types.Command) object that provides the human's response.
+The graph is resumed using a [`Command`][langgraph.types.Command] object that provides the human's response.

 **Graph node with `interrupt`:**

@@ -1,31 +1,36 @@
-# Testing local agents with remote traces
+# Debug LangSmith traces

-## Overview
+This guide explains how to open LangSmith traces in LangGraph Studio for interactive investigation and debugging.

-A common workflow when debugging production-deployed agents is to test the same thread against a local version of the same agent, which may have modifications.
+## Open deployed threads

-To support this, LangGraph Studio, in combination with LangSmith, allows you to clone remote threads traced in LangSmith into your locally running agent. This cloned thread can then be used to re-run specific nodes within Studio.
+1. Open the LangSmith trace, selecting the root run.
+2. Click "Run in Studio".

-## Requirements
+This will open LangGraph Studio connected to the associated LangGraph Platform deployment with the trace's parent thread selected.

-!!! info "Prerequisites"
+## Testing local agents with remote traces
+
+This section explains how to test a local agent against remote traces from LangSmith. This enables you to use production traces as input for local testing, allowing you to debug and verify agent modifications in your development environment.
+
+### Requirements
+
+- A LangSmith traced thread
+- A locally running agent. See [here](../how-tos/studio/quick_start.md#local-development-server) for setup
+  instructions.
+
+!!! info "Local agent requirements"

    - langgraph>=0.3.18
    - langgraph-api>=0.0.32
+    - Contains the same set of nodes present in the remote trace

- A thread traced in LangSmith.
- A locally running agent. See [here](../../how-tos/local-studio.md) for setup instructions.
-  - Note that your local agent must be using the above specified `langgraph` and `langgraph-api` versions.
-  - The nodes present in the remote trace must exist in at least one of the graphs in your local agent.
+### Cloning Thread

-## Cloning Thread
+1. Open the LangSmith trace, selecting the root run.
+2. Click the dropdown next to "Run in Studio".
+3. Enter your local agent's URL.
+4. Select "Clone thread locally".
+5. If multiple graphs exist, select the target graph.

-First navigate to the LangSmith trace. Here you should see a button to "Run in Studio".
-
-![Run in Studio](img/run_in_studio.png){width=1200}
-
-This will prompt you to enter the url that your locally running agent is accessible at. Once provided, select "Clone thread locally". If you have multiple graphs in your agent, you will also be prompted to select a graph to clone this thread under.
-
-Once selected, a will a new thread in your local agent will be created and the thread history will be reconstruced to reflect the original trace.
-
-Alternatively, if your trace originates from an agent deployed on LangGraph Platform, you can "View original thread" to open Studio with the actual deployed thread.
+A new thread will be created in your local agent with the thread history inferred and copied from the remote thread, and you will be navigated to LangGraph Studio for your locally running application.
@@ -50,7 +50,7 @@ For more information on configurations, [see here](../../concepts/low_level.md#c

 ### LangGraph SDK

-To create an assistant, use the [LangGraph SDK](../../concepts/sdk.md) `create` method. See the [Python](../reference/sdk/python_sdk_ref.md#langgraph_sdk.client.AssistantsClient.create) and [JS](../reference/sdk/js_ts_sdk_ref.md#create) SDK reference docs for more information.
+To create an assistant, use the [LangGraph SDK](../../concepts/sdk.md) `create` method. See the [Python](https://langchain-ai.github.io/langgraph/cloud/reference/sdk/python_sdk_ref/#langgraph_sdk.client.AssistantsClient.create) and [JS](https://langchain-ai.github.io/langgraph/cloud/reference/sdk/js_ts_sdk_ref/#create) SDK reference docs for more information.

 This example uses the same configuration schema as above, and creates an assistant with `model_name` set to `openai`.

@@ -228,10 +228,10 @@ Inside your deployment, select the "Assistants" tab. For the assistant you would

 ### LangGraph SDK

-To edit the assistant, use the `update` method. This will create a new version of the assistant with the provided edits. See the [Python](../reference/sdk/python_sdk_ref.md#langgraph_sdk.client.AssistantsClient.update) and [JS](../reference/sdk/js_ts_sdk_ref.md#update) SDK reference docs for more information.
+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 previously 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 previous 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 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.
+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.

 !!! warning "Deleting Assistants"
-    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.
+    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.
@@ -4,7 +4,7 @@ Sometimes you don't want to run your graph based on user interaction, but rather

 ## Setup

-First, let's setup our SDK client, assistant, and thread:
+First, let's set up our SDK client, assistant, and thread:

 === "Python"

@@ -1,17 +1,12 @@
-# Adding nodes as dataset examples in Studio
+# Add node to dataset

-In LangGraph Studio you can create dataset examples from the thread history in the right-hand pane. This can be especially useful when you want to evaluate intermediate 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 individual steps of the agent.

-1. Click on the `Add to Dataset` button to enter the dataset mode.
-1. Select nodes which you want to add to dataset.
-1. Select the target dataset to create the example in.
-
-You can edit the example payload before sending it to the dataset, which is useful if you need to make changes to conform the example to the dataset schema.
-
-Finally, you can customise the target dataset by clicking on the `Settings` button.
+1. Select a thread.
+2. Click on the `Add to Dataset` button.
+3. Select nodes whose input/output you want to add to a dataset.
+4. For each selected node, select the target dataset to create the example in. By default a dataset for the specific assistant and node will be selected. If this dataset does not yet exist, it will be created.
+5. Edit the example's input/output as needed before adding it to the dataset.
+6. Select "Add to dataset" at the bottom of the page to add all selected nodes to their respective datasets.

 See [Evaluating intermediate steps](https://docs.smith.langchain.com/evaluation/how_to_guides/langgraph#evaluating-intermediate-steps) for more details on how to evaluate intermediate steps.
-
-<video controls allowfullscreen="true" poster="../img/studio_datasets.jpg">
-    <source src="https://langgraph-docs-assets.pages.dev/studio_datasets.mp4" type="video/mp4">
-</video>
@@ -335,7 +335,7 @@ const { thread, submit } = useStream({
 });
 ```

-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.
+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.

 === "Python"

@@ -1,19 +1,48 @@
-# How to manage Assistants
+# Run application

-!!! info "Prerequisites"
+!!!info  "Prerequisites"
+    - [Running agents](../../agents/run_agents.md#running-agents)

-    - [Assistants Overview](../../concepts/assistants.md)
-
-LangGraph Studio lets you view, edit, and update your assistants, and allows you to run your graph using these assistant configurations.
+This guide shows how to submit a [run](../concepts/runs.md) to your application.

 ## Graph mode

-To view your assistants, click the "Manage Assistants" button in the bottom left corner.
+### Specify input
+First define the input to your graph with in the "Input" section on the left side of the page, below the graph interface.

-This opens a modal for you to view all the assistants for the selected graph. Specify the assistant and its version you would like to mark as "Active", and this assistant will be used when submitting runs.
+Studio will attempt to render a form for your input based on the graph's defined [state schema](../../concepts/low_level.md/#schema). To disable this, click the "View Raw" button, which will present you with a JSON editor.
+
+Click the up/down arrows at the top of the "Input" section to toggle through and use previously submitted inputs.
+
+### Run settings
+
+#### Assistant
+
+To specify the [assistant](../../concepts/assistants.md) that is used for the run click the settings button in the bottom left corner. If an assistant is currently selected the button will also list the assistant name. If no assistant is selected it will say "Manage Assistants".
+
+Select the assistant to run and click the "Active" toggle at the top of the modal to activate it. [See here](./studio/manage_assistants.md) for more information on managing assistants.
+
+#### Streaming
+Click the dropdown next to "Submit" and click the toggle to enable/disable streaming.
+
+#### Breakpoints
+To run your graph with breakpoints, click the "Interrupt" button. Select a node and whether to pause before and/or after that node has executed. Click "Continue" in the thread log to resume execution.
+
+
+For more information on breakpoints see [here](../../concepts/breakpoints.md).
+
+### Submit run
+
+To submit the run with the specified input and run settings, click the "Submit" button. This will add a [run](../concepts/runs.md) to the existing selected [thread](../concepts/threads.md). If no thread is currently selected, a new one will be created.
+
+To cancel the ongoing run, click the "Cancel" button.

-By default, the "Default configuration" option will be active. This option reflects the default configuration defined in your graph. Edits made to this configuration will be used to update the run-time configuration, but will not update or create a new assistant unless you click "Create new assistant".

 ## Chat mode
+Specify the input to your chat application in the bottom of the conversation panel. Click the "Send message" button to submit the input as a Human message and have the response streamed back.

-Chat mode enables you to switch through the different assistants in your graph via the dropdown selector at the top of the page. To create, edit, or delete assistants, use Graph mode.
+To cancel the ongoing run, click the "Cancel" button. Click the "Show tool calls" toggle to hide/show tool calls in the conversation.
+
+## Learn more
+
+To run your application from a specific checkpoint in an existing thread, see [this guide](./threads_studio.md#edit-thread-history).
@@ -1,23 +1,28 @@
-# Prompt Engineering in LangGraph Studio
+# Iterate on prompts

 ## Overview

-A central aspect of agent development is prompt engineering. LangGraph Studio makes it easy to iterate on the prompts used within your graph directly within the UI.
+LangGraph Studio supports two methods for modifying prompts in your graph: direct node editing and the LangSmith Playground interface.

-## Setup
+## Direct Node Editing

-The first step is to define your [configuration](https://langchain-ai.github.io/langgraph/how-tos/configuration/) such that LangGraph Studio is aware of the prompts you want to iterate on and which nodes they are associated with.
+Studio allows you to edit prompts used inside individual nodes, directly from the graph interface.

-### Reference
+!!! info "Prerequisites"

-When defining your configuration, you can use special metadata keys to instruct LangGraph Studio how to handle different fields. Here's a reference for the available configuration options:
+    - [Assistants overview](../../concepts/assistants.md)

-#### `langgraph_nodes`
+### Graph Configuration

- **Description**: Specifies which graph nodes a configuration field is associated with.
+Define your [configuration](https://langchain-ai.github.io/langgraph/how-tos/configuration/) to specify prompt fields and their associated nodes using `langgraph_nodes` and `langgraph_type` keys.
+
+#### Configuration Reference
+
+##### `langgraph_nodes`
+
+- **Description**: Specifies which nodes of the graph a configuration field is associated with.
 - **Value Type**: Array of strings, where each string is the name of a node in your graph.
 - **Usage Context**: Include in the `json_schema_extra` dictionary for Pydantic models or the `metadata["json_schema_extra"]` dictionary for dataclasses.
- **Required**: No, but necessary if you want a field to be editable for specific nodes in the UI.
 - **Example**:
  ```python
  system_prompt: str = Field(
@@ -26,14 +31,13 @@ When defining your configuration, you can use special metadata keys to instruct
  )
  ```

-#### `langgraph_type`
+##### `langgraph_type`

 - **Description**: Specifies the type of configuration field, which determines how it's handled in the UI.
 - **Value Type**: String
 - **Supported Values**:
  - `"prompt"`: Indicates the field contains prompt text that should be treated specially in the UI.
 - **Usage Context**: Include in the `json_schema_extra` dictionary for Pydantic models or the `metadata["json_schema_extra"]` dictionary for dataclasses.
- **Required**: No, but helpful for prompt fields to enable special handling.
 - **Example**:
  ```python
  system_prompt: str = Field(
@@ -45,9 +49,7 @@ When defining your configuration, you can use special metadata keys to instruct
  )
  ```

-### Example
-
-For example, if you have a node called `call_model` whose system prompt you want to iterate on, you can define a configuration like the following.
+#### Example Configuration

 ```python
 ## Using Pydantic
@@ -111,30 +113,22 @@ class Configuration:

 ```

-## Iterating on prompts
+### Editing prompts in UI

-### Node Configuration
+1. Locate the gear icon on nodes with associated configuration fields
+2. Click to open the configuration modal
+3. Edit the values
+4. Save to update the current assistant version or create a new one

-With this set up, running your graph and viewing in LangGraph Studio will result in the graph rendering like such.
+## LangSmith Playground

-**Note the configuration icon in the top right corner of the `call_model` node**:
+The [LangSmith Playground](https://
+docs.smith.langchain.com/prompt_engineering/how_to_guides#playground) interface allows testing individual LLM calls without running the full graph:

-![Graph in Studio](img/studio_graph_with_configuration.png){width=1200}
+1. Select a thread
+2. Click "View LLM Runs" on a node. This lists all the LLM calls (if any) made inside the node.
+3. Select an LLM run to open in Playground
+4. Modify prompts and test different model and tool settings
+5. Copy updated prompts back to your graph

-Clicking this icon will open a modal where you can edit the configuration for all of the fields associated with the `call_model` node. From here, you can save your changes and apply them to the graph. Note that these values reflect the currently active assistant, and saving will update the assistant with the new values.
-
-![Configuration modal](img/studio_node_configuration.png){width=1200}
-
-### Playground
-
-LangGraph Studio also supports prompt engineering through an integration with the LangSmith Playground. To do so:
-
-1. Open an existing thread or create a new one.
-2. Within the thread log, any nodes that have made an LLM call will have a "View LLM Runs" button. Clicking this will open a popover with the LLM runs for that node.
-3. Select the LLM run you want to edit. This will open the LangSmith Playground with the selected LLM run.
-
-![Playground in Studio](img/studio_playground.png){width=1200}
-
-From here you can edit the prompt, test different model configurations and re-run just this LLM call without having to re-run the entire graph. When you are happy with your changes, you can copy the updated prompt back into your graph.
-
-For more information on how to use the LangSmith Playground, see the [LangSmith Playground documentation](https://docs.smith.langchain.com/prompt_engineering/how_to_guides#playground).
+For advanced Playground features, click the expand button in the top right corner.
@@ -1,50 +0,0 @@
-# LangGraph Studio FAQs
-
-## Why is my project failing to start?
-
-A project may fail to start if the configuration file is defined incorrectly, or if required environment variables are missing. See [here](../../reference/cli.md#configuration-file) for how your configuration file should be defined.
-
-## How does interrupt work?
-
-When you select the `Interrupts` dropdown and select a node to interrupt the graph will pause execution before and after (unless the node goes straight to `END`) that node has run. This means that you will be able to both edit the state before the node is ran and the state after the node has ran. This is intended to allow developers more fine-grained control over the behavior of a node and make it easier to observe how the node is behaving. You will not be able to edit the state after the node has ran if the node is the final node in the graph.
-
-For more information on interrupts and human in the loop, see [here](./human_in_the_loop.md).
-
-## Why are extra edges showing up in my graph?
-
-If you don't define your conditional edges carefully, you might notice extra edges appearing in your graph. This is because without proper definition, LangGraph Studio assumes the conditional edge could access all other nodes. In order for this to not be the case, you need to be explicit about how you define the nodes the conditional edge routes to. There are two ways you can do this:
-
-### Solution 1: Include a path map
-
-The first way to solve this is to add path maps to your conditional edges. A path map is just a dictionary or array that maps the possible outputs of your router function with the names of the nodes that each output corresponds to. The path map is passed as the third argument to the `add_conditional_edges` function like so:
-
-=== "Python"
-
-    ```python
-    graph.add_conditional_edges("node_a", routing_function, {True: "node_b", False: "node_c"})
-    ```
-
-=== "Javascript"
-
-    ```ts
-    graph.addConditionalEdges("node_a", routingFunction, { true: "node_b", false: "node_c" });
-    ```
-
-In this case, the routing function returns either True or False, which map to `node_b` and `node_c` respectively.
-
-### Solution 2: Update the typing of the router (Python only)
-
-Instead of passing a path map, you can also be explicit about the typing of your routing function by specifying the nodes it can map to using the `Literal` python definition. Here is an example of how to define a routing function in that way:
-
-```python
-def routing_function(state: GraphState) -> Literal["node_b","node_c"]:
-    if state['some_condition'] == True:
-        return "node_b"
-    else:
-        return "node_c"
-```
-
-
-## Why is my graph taking so long to startup?
-
-The LangGraph Studio interacts with a local LangGraph API server. To stay aligned with ongoing updates, the LangGraph API requires regular rebuilding. As a result, you may occasionally experience slight delays when starting up your project.
@@ -0,0 +1,19 @@
+# Manage assistants
+
+!!! info "Prerequisites"
+
+    - [Assistants Overview](../../../concepts/assistants.md)
+
+LangGraph Studio lets you view, edit, and update your assistants, and allows you to run your graph using these assistant configurations.
+
+## Graph mode
+
+To view your assistants, click the "Manage Assistants" button in the bottom left corner.
+
+This opens a modal for you to view all the assistants for the selected graph. Specify the assistant and its version you would like to mark as "Active", and this assistant will be used when submitting runs.
+
+By default, the "Default configuration" option will be active. This option reflects the default configuration defined in your graph. Edits made to this configuration will be used to update the run-time configuration, but will not update or create a new assistant unless you click "Create new assistant".
+
+## Chat mode
+
+Chat mode enables you to switch through the different assistants in your graph via the dropdown selector at the top of the page. To create, edit, or delete assistants, use Graph mode.
@@ -7,16 +7,21 @@ LangGraph Studio supports connecting to two types of graphs:
 - Graphs deployed on [LangGraph Platform](../../../cloud/quick_start.md)
 - Graphs running locally via the [LangGraph Server](../../../tutorials/langgraph-platform/local-server.md).

-## Deployed Application
+LangGraph Studio is accessed from the LangSmith UI, within the LangGraph Platform Deployments tab.

-For applications that are deployed on LangGraph Platform, you can access Studio as part of that deployment. To do so, navigate to the deployment in LangGraph Platform within the LangSmith UI and click the "LangGraph Studio" button.
+## Deployed application
+
+For applications that are [deployed](../../quick_start.md) on LangGraph Platform, you can access Studio as part of that deployment. To do so, navigate to the deployment in LangGraph Platform within the LangSmith UI and click the "LangGraph Studio" button.

 This will load the Studio UI connected to your live deployment, allowing you to create, read, and update the [threads](../../concepts/threads.md), [assistants](../../../concepts/assistants.md), and [memory](../../../concepts//memory.md) in that deployment.

-## Local Development Server
+## Local development server

 To test your locally running application using LangGraph Studio, ensure your application is set up following [this guide](https://langchain-ai.github.io/langgraph/cloud/deployment/setup/).

+!!! info "LangSmith Tracing"
+    For local development, if you do not wish to have data traced to LangSmith, set `LANGSMITH_TRACING=false` in your application's `.env` file. With tracing disabled, no data will leave your local server.
+
 Next, install the [LangGraph CLI](../../../concepts/langgraph_cli.md):

 ```
@@ -44,15 +49,14 @@ If successful, you will see the following logs:
 >
 > - LangGraph Studio Web UI: https://smith.langchain.com/studio/?baseUrl=http://127.0.0.1:2024

-Once running, you will automatically be directed to LangGraph Studio. 
+Once running, you will automatically be directed to LangGraph Studio.

+For an already running server, access Studio by either:

-If your server is already running, to access Studio, either:
+1.  Directly navigate to the following URL: `https://smith.langchain.com/studio/?baseUrl=http://127.0.0.1:2024`.
+2.  Within LangSmith, navigate to the LangGraph Platform Deployments tab, click the "LangGraph Studio" button, enter `http://127.0.0.1:2024` and click "Connect".

- 1. Directly navigate to the following URL: `https://smith.langchain.com/studio/?baseUrl=http://127.0.0.1:2024`. 
- 2. Within LangSmith, navigate to the LangGraph Platform Deployments tab, click the "LangGraph Studio" button, enter `http://127.0.0.1:2024` and click "Connect".
- 
- If running your server at a different host or port, simply update the `baseUrl` to match.
+If running your server at a different host or port, simply update the `baseUrl` to match.

 ### (Optional) Attach a debugger

@@ -69,8 +73,8 @@ langgraph dev --debug-port 5678
 Then attach your preferred debugger:

 === "VS Code"
-    Add this configuration to `launch.json`:
-    ```json
+Add this configuration to `launch.json`:
+`json
      {
        "name": "Attach to LangGraph",
        "type": "debugpy",
@@ -80,23 +84,22 @@ Then attach your preferred debugger:
          "port": 5678
        }
      }
-    ```
-    Specify the port number you chose in the previous step.
+    `
+Specify the port number you chose in the previous step.

-=== "PyCharm" 
-    1. Go to Run → Edit Configurations 
-    2. Click + and select "Python Debug Server" 
-    3. Set IDE host name: `localhost` 
-    4. Set port: `5678` (or the port number you chose in the previous step) 
-    5. Click "OK" and start debugging
+=== "PyCharm" 1. Go to Run → Edit Configurations 2. Click + and select "Python Debug Server" 3. Set IDE host name: `localhost` 4. Set port: `5678` (or the port number you chose in the previous step) 5. Click "OK" and start debugging

+## Troubleshooting
+
+For issues getting started, please see this [troubleshooting guide](../../../troubleshooting/studio.md).

 ## Next steps

-See the following how-tos for more information on how to use Studio:
+See the following guides for more information on how to use Studio:

- [How to manage Assistants](../invoke_studio.md)
- [How to manage Threads](../threads_studio.md)
- [How to create datasets](../datasets_studio.md)
- [How to prompt engineer](../iterate_graph_studio.md)
- [How to locally debug remote traces](../clone_traces_studio.md)
+- [Run application](../invoke_studio.md)
+- [Manage assistants](./manage_assistants.md)
+- [Manage threads](../threads_studio.md)
+- [Iterate on prompts](../iterate_graph_studio.md)
+- [Debug LangSmith traces](../clone_traces_studio.md)
+- [Add node to dataset](../datasets_studio.md)
@@ -1,4 +1,4 @@
-# How to manage Threads
+# Manage threads

 !!! info "Prerequisites"

@@ -6,25 +6,36 @@

 Studio allows you to view threads from the server and edit their state.

-## View Threads
+## View threads

 ### Graph mode

-1. In the top of the right-hand pane, select the `New Thread` dropdown menu to view existing threads.
+1. In the top of the right-hand pane, select the dropdown menu to view existing threads.
 1. Select the desired thread, and the thread history will populate in the right-hand side of the page.
-1. To create a new thread, select `+ New Thread`.
+1. To create a new thread, click `+ New Thread` and [submit a run](../how-tos/invoke_studio.md#graph-mode).
+
+To view more granular information in the thread, drag the slider at the top of the page to the right. To view less information, drag the slider to the left. Additionally, collapse or expand individual turns, nodes, and keys of the state.
+
+Switch between `Pretty` and `JSON` mode for different rendering formats.

 ### Chat mode

 1. View all threads in the right-hand pane of the page.
-2. Click the plus button to create a new thread.
+2. Select the desired thread and the thread history will populate in the center panel.
+3. To create a new thread, click the plus button and [submit a run](../how-tos/invoke_studio.md#chat-mode).

-## Edit Thread State
+## Edit thread history

 ### Graph mode

-To edit the state of the thread, select "edit node state" next to the desired node. This enables you to edit the node's output and create a new fork of the thread history. For more information about time travel, [see here](../../concepts/time-travel.md).
+To edit the state of the thread, select "edit node state" next to the desired node. Edit the node's output as desired and click "fork" to confirm. This will create a new forked run from the checkpoint of the selected node.
+
+If you instead want to re-run the thread from a given checkpoint without editing the state, click the "Re-run from here". This will again create a new forked run from the selected checkpoint. This is useful for re-running with changes that are not specific to the state, such as the selected assistant.

 ### Chat mode

 To edit a human message in the thread, click the edit button below the human message. Edit the message as desired and submit. This will create a new fork of the conversation history. To re-generate an AI message, click the retry icon below the AI message.
+
+## Learn more
+
+For more information about time travel, [see here](../../concepts/time-travel.md).
@@ -1,8 +1,8 @@
-# How to integrate LangGraph into your React application
+How to integrate LangGraph into your React application# How to integrate LangGraph into your React application

-!!! info "Prerequisites" 
+!!! info "Prerequisites"

-    - [LangGraph Platform](../../concepts/langgraph_platform.md) 
+    - [LangGraph Platform](../../concepts/langgraph_platform.md)
    - [LangGraph Server](../../concepts/langgraph_server.md)

 The `useStream()` React hook provides a seamless way to integrate LangGraph into your React applications. It handles all the complexities of streaming, state management, and branching logic, letting you focus on building great chat experiences.
@@ -113,6 +113,115 @@ export default function App() {
 }
 ```

+### Resume a stream after page refresh
+
+The `useStream()` hook can automatically resume an ongoing run upon mounting by setting `reconnectOnMount: true`. This is useful for continuing a stream after a page refresh, ensuring no messages and events generated during the downtime are lost.
+
+```tsx
+const thread = useStream<{ messages: Message[] }>({
+  apiUrl: "http://localhost:2024",
+  assistantId: "agent",
+  reconnectOnMount: true,
+});
+```
+
+By default the ID of the created run is stored in `window.sessionStorage`, which can be swapped by passing a custom storage in `reconnectOnMount` instead. The storage is used to persist the in-flight run ID for a thread (under `lg:stream:${threadId}` key).
+
+```tsx
+const thread = useStream<{ messages: Message[] }>({
+  apiUrl: "http://localhost:2024",
+  assistantId: "agent",
+  reconnectOnMount: () => window.localStorage,
+});
+```
+
+You can also manually manage the resuming process by using the run callbacks to persist the run metadata and the `joinStream` function to resume the stream. Make sure to pass `streamResumable: true` when creating the run; otherwise some events might be lost.
+
+````tsx
+import type { Message } from "@langchain/langgraph-sdk";
+import { useStream } from "@langchain/langgraph-sdk/react";
+import { useCallback, useState, useEffect, useRef } from "react";
+
+export default function App() {
+  const [threadId, onThreadId] = useSearchParam("threadId");
+
+  const thread = useStream<{ messages: Message[] }>({
+    apiUrl: "http://localhost:2024",
+    assistantId: "agent",
+
+    threadId,
+    onThreadId,
+
+    onCreated: (run) => {
+      window.sessionStorage.setItem(`resume:${run.thread_id}`, run.run_id);
+    },
+    onFinish: (_, run) => {
+      window.sessionStorage.removeItem(`resume:${run?.thread_id}`);
+    },
+  });
+
+  // Ensure that we only join the stream once per thread.
+  const joinedThreadId = useRef<string | null>(null);
+  useEffect(() => {
+    if (!threadId) return;
+
+    const resume = window.sessionStorage.getItem(`resume:${threadId}`);
+    if (resume && joinedThreadId.current !== threadId) {
+      thread.joinStream(resume);
+      joinedThreadId.current = threadId;
+    }
+  }, [threadId]);
+
+  return (
+    <form
+      onSubmit={(e) => {
+        e.preventDefault();
+        const form = e.target as HTMLFormElement;
+        const message = new FormData(form).get("message") as string;
+        thread.submit(
+          { messages: [{ type: "human", content: message }] },
+          { streamResumable: true }
+        );
+      }}
+    >
+      <div>
+        {thread.messages.map((message) => (
+          <div key={message.id}>{message.content as string}</div>
+        ))}
+      </div>
+      <input type="text" name="message" />
+      <button type="submit">Send</button>
+    </form>
+  );
+}
+
+// Utility method to retrieve and persist data in URL as search param
+function useSearchParam(key: string) {
+  const [value, setValue] = useState<string | null>(() => {
+    const params = new URLSearchParams(window.location.search);
+    return params.get(key) ?? null;
+  });
+
+  const update = useCallback(
+    (value: string | null) => {
+      setValue(value);
+
+      const url = new URL(window.location.href);
+      if (value == null) {
+        url.searchParams.delete(key);
+      } else {
+        url.searchParams.set(key, value);
+      }
+
+      window.history.pushState({}, "", url.toString());
+    },
+    [key]
+  );
+
+  return [value, update] as const;
+}
+```
+
 ### Thread Management

 Keep track of conversations with built-in thread management. You can access the current thread ID and get notified when new threads are created:
@@ -127,7 +236,7 @@ const thread = useStream<{ messages: Message[] }>({
  threadId: threadId,
  onThreadId: setThreadId,
 });
-```
+````

 We recommend storing the `threadId` in your URL's query parameters to let users resume conversations after page refreshes.

@@ -158,7 +267,7 @@ export default function HomePage() {
 }
 ```

-Under the hood, the `useStream()` hook will use the `streamMode: "messages-tuple"` to receive a stream of messages (i.e. individual LLM tokens) from any LangChain chat model invocations inside your graph nodes. Learn more about messages streaming in the [How to stream messages from your graph](./stream_messages.md) guide.
+Under the hood, the `useStream()` hook will use the `streamMode: "messages-tuple"` to receive a stream of messages (i.e. individual LLM tokens) from any LangChain chat model invocations inside your graph nodes. Learn more about messages streaming in the [streaming](../how-tos/streaming.md#messages) guide.

 ### Interrupts

@@ -476,7 +585,7 @@ The `useStream()` hook provides several callback options to help you respond to
 - `onError`: Called when an error occurs.
 - `onFinish`: Called when the stream is finished.
 - `onUpdateEvent`: Called when an update event is received.
- `onCustomEvent`: Called when a custom event is received. See [Custom events](../../how-tos/streaming.ipynb#custom) to learn how to stream custom events.
+- `onCustomEvent`: Called when a custom event is received. See the [streaming](../../how-tos/streaming.md#stream-custom-data) guide to learn how to stream custom events.
 - `onMetadataEvent`: Called when a metadata event is received, which contains the Run ID and Thread ID.

 ## Learn More
@@ -1,4 +1,4 @@
-# How to use threads
+# Use threads

 !!! info "Prerequisites"

@@ -12,7 +12,7 @@ To run your graph and the state persisted, you must first create a thread.

 ### Empty thread

-To create a new thread, use the [LangGraph SDK](../../concepts/sdk.md) `create` method. See the [Python](../reference/sdk/python_sdk_ref.md#langgraph_sdk.client.ThreadsClient.create) and [JS](../reference/sdk/js_ts_sdk_ref.md#create_3) SDK reference docs for more information.
+To create a new thread, use the [LangGraph SDK](../../concepts/sdk.md) `create` method. See the [Python](https://langchain-ai.github.io/langgraph/cloud/reference/sdk/python_sdk_ref/#langgraph_sdk.client.ThreadsClient.create) and [JS](https://langchain-ai.github.io/langgraph/cloud/reference/sdk/js_ts_sdk_ref/#create_3) SDK reference docs for more information.

 === "Python"

@@ -58,7 +58,7 @@ Output:

 ### Copy thread

-Alternatively, if you already have a thread in your application whose state you wish to copy, you can use the `copy` method. This will create an independent thread whose history is identical to the original thread at the time of the operation. See the [Python](../reference/sdk/python_sdk_ref.md#langgraph_sdk.client.ThreadsClient.copy) and [JS](../reference/sdk/js_ts_sdk_ref.md#copy) SDK reference docs for more information.
+Alternatively, if you already have a thread in your application whose state you wish to copy, you can use the `copy` method. This will create an independent thread whose history is identical to the original thread at the time of the operation. See the [Python](https://langchain-ai.github.io/langgraph/cloud/reference/sdk/python_sdk_ref/#langgraph_sdk.client.ThreadsClient.copy) and [JS](https://langchain-ai.github.io/langgraph/cloud/reference/sdk/js_ts_sdk_ref/#copy) SDK reference docs for more information.

 === "Python"

@@ -237,11 +237,11 @@ Output:

 ### LangGraph SDK

-To list threads, use the [LangGraph SDK](../../concepts/sdk.md) `search` method. This will list the threads in the application that match the provided filters. See the [Python](../reference/sdk/python_sdk_ref.md#langgraph_sdk.client.ThreadsClient.search) and [JS](../reference/sdk/js_ts_sdk_ref.md#search_2) SDK reference docs for more information.
+To list threads, use the [LangGraph SDK](../../concepts/sdk.md) `search` method. This will list the threads in the application that match the provided filters. See the [Python](https://langchain-ai.github.io/langgraph/cloud/reference/sdk/python_sdk_ref/#langgraph_sdk.client.ThreadsClient.search) and [JS](https://langchain-ai.github.io/langgraph/cloud/reference/sdk/js_ts_sdk_ref/#search_2) SDK reference docs for more information.

 #### Filter by thread status

-Use the `status` field to filter threads based on their status. Supported values are `idle`, `busy`, `interrupted`, and `error`. See [here](../reference/sdk/python_sdk_ref.md/?h=thread+status#langgraph_sdk.auth.types.ThreadStatus) for information on each status. For example, to view `idle` threads:
+Use the `status` field to filter threads based on their status. Supported values are `idle`, `busy`, `interrupted`, and `error`. See [here](https://langchain-ai.github.io/langgraph/cloud/reference/sdk/python_sdk_ref/?h=thread+status#langgraph_sdk.auth.types.ThreadStatus) for information on each status. For example, to view `idle` threads:

 === "Python"

@@ -480,7 +480,7 @@ Optionally, to view the state of a thread at a given checkpoint, simply pass in

 #### Inspect Full Thread History

-To view a thread's history, use the `get_history` method. This returns a list of every state the thread experienced. For more information see the [Python](../reference/sdk/python_sdk_ref.md/#langgraph_sdk.client.ThreadsClient.get_history) and [JS](../reference/sdk/js_ts_sdk_ref.md/#gethistory) reference docs.
+To view a thread's history, use the `get_history` method. This returns a list of every state the thread experienced. For more information see the [Python](https://langchain-ai.github.io/langgraph/cloud/reference/sdk/python_sdk_ref/?h=thread+status#langgraph_sdk.client.ThreadsClient.get_history) and [JS](https://langchain-ai.github.io/langgraph/cloud/reference/sdk/js_ts_sdk_ref/#gethistory) reference docs.

 ### LangGraph Platform UI

@@ -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 it's 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 its full history and for further debugging, open the thread in [LangGraph Studio](../../concepts//langgraph_studio.md).
@@ -9,31 +9,21 @@ Before you begin, ensure you have the following:
 - A [GitHub account](https://github.com/)
 - A [LangSmith account](https://smith.langchain.com/) – free to sign up

-This quickstart uses the [pre-built Python ReAct agent template](https://github.com/langchain-ai/react-agent), which requires the following:
-
- An API key for [Anthropic](https://console.anthropic.com/)
- An API key for [Tavily](https://app.tavily.com/)
-
 ## 1. Create a repository on GitHub

-To deploy a LangGraph application to **LangGraph Platform**, your application code must reside in a GitHub repository. Both public and private repositories are supported. For this quickstart, use the [pre-built Python ReAct agent template](https://github.com/langchain-ai/react-agent) for your application:
+To deploy an application to **LangGraph Platform**, your application code must reside in a GitHub repository. Both public and private repositories are supported. For this quickstart, use the [`new-langgraph-project` template](https://github.com/langchain-ai/react-agent) for your application:

-1. Go to the [ReAct Agent](https://github.com/langchain-ai/react-agent) repository.
+1. Go to the [`new-langgraph-project` repository](https://github.com/langchain-ai/new-langgraph-project) or [`new-langgraphjs-project` template](https://github.com/langchain-ai/new-langgraphjs-project).
 1. Click the `Fork` button in the top right corner to fork the repository to your GitHub account.
 1. Click **Create fork**. 

 ## 2. Deploy to LangGraph Platform

 1. Log in to [LangSmith](https://smith.langchain.com/).
-1. In the left sidebar, select **LangGraph Platform**.
-1. Click the **+ New Deployment** button. A modal will open where you can fill in the required fields.
+1. In the left sidebar, select **Deployments**.
+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 ReAct Agent repository.
-1. In the **Environment Variables** section, set the following secrets:
-    
-    - **ANTHROPIC_API_KEY**: Get an API key from [Anthropic](https://console.anthropic.com/).
-    - **TAVILY_API_KEY**: Get an API key on the [Tavily website](https://app.tavily.com/).
-
+1. Select your New LangGraph Project repository.
 1. Click **Submit** to deploy.

    This may take about 15 minutes to complete. You can check the status in the **Deployment details** view.
@@ -48,7 +38,7 @@ Once your application is deployed:
    LangGraph Studio will open to display your graph.

    <figure markdown="1">
-    [![image](deployment/img/09_langgraph_studio.png){: style="max-height:400px"}](deployment/img/09_langgraph_studio.png)
+    [![image](deployment/img/langgraph_studio.png){: style="max-height:400px"}](deployment/img/langgraph_studio.png)
    <figcaption>
        Sample graph run in LangGraph Studio.
    </figcaption>
@@ -125,7 +115,7 @@ You can now test the API:
            print("\n\n")
        ```

-=== "Javascript SDK"
+=== "JavaScript SDK"

    1. Install the LangGraph JS SDK

@@ -181,7 +171,7 @@ You can now test the API:
    ```


-## Next Steps
+## Next steps

 Congratulations! You have deployed an application using LangGraph Platform.

@@ -3818,6 +3818,14 @@
            "title": "Filter",
            "description": "Optional dictionary of key-value pairs to filter results."
          },
+          "query": {
+            "type": [
+              "string",
+              "null"
+            ],
+            "title": "Query",
+            "description": "Query string for semantic/vector search."
+          },
          "limit": {
            "type": "integer",
            "default": 10,
@@ -40,9 +40,10 @@ 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 creates an instance of `langgraph.graph.state.StateGraph` / `langgraph.graph.state.CompiledStateGraph`.</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;">`auth`</span>             | _(Added in v0.0.11)_ Auth configuration containing the path to your authentication handler. Example: `./your_package/auth.py:auth`, where `auth` is an instance of `langgraph_sdk.Auth`. See [authentication guide](../../concepts/auth.md) for details.                                                                                                                                                                                                                                                                                                                        |
    | <span style="white-space: nowrap;">`base_image`</span>       | Optional. Base image to use for the LangGraph API server. Defaults to `langchain/langgraph-api` or `langchain/langgraphjs-api`. Use this to pin your builds to a particular version of the langgraph API, such as `"langchain/langgraph-server:0.2"`. See https://hub.docker.com/r/langchain/langgraph-server/tags for more details. (added in `langgraph-cli==0.2.8`) |
+    | <span style="white-space: nowrap;">`image_distro`</span>     | Optional. Linux distribution for the base image. Must be either `"debian"` or `"wolfi"`. If omitted, defaults to `"debian"`. Available in `langgraph-cli>=0.2.11`.|
    | <span style="white-space: nowrap;">`env`</span>              | Path to `.env` file or a mapping from environment variable to its value.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
    | <span style="white-space: nowrap;">`store`</span>            | Configuration for adding semantic search and/or time-to-live (TTL) to the BaseStore. Contains the following fields: <ul><li>`index` (optional): Configuration for semantic search indexing with fields `embed`, `dims`, and optional `fields`.</li><li>`ttl` (optional): Configuration for item expiration. An object with optional fields: `refresh_on_read` (boolean, defaults to `true`), `default_ttl` (float, lifespan in **minutes**, defaults to no expiration), and `sweep_interval_minutes` (integer, how often to check for expired items, defaults to no sweeping).</li></ul> |
    | <span style="white-space: nowrap;">`ui`</span>               | Optional. Named definitions of UI components emitted by the agent, each pointing to a JS/TS file. (added in `langgraph-cli==0.1.84`)                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
@@ -57,7 +58,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 creates an instance of `StateGraph` / `CompiledStateGraph`.</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 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;">`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.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
@@ -79,6 +80,20 @@ The LangGraph CLI requires a JSON configuration file that follows this [schema](
    }
    ```

+    #### Using Wolfi Base Images
+
+    You can specify the Linux distribution for your base image using the `image_distro` field. Valid options are `debian` or `wolfi`. Wolfi is the recommended option as it provides smaller and more secure images. This is available in `langgraph-cli>=0.2.11`.
+
+    ```json
+    {
+      "dependencies": ["."],
+      "graphs": {
+        "chat": "./chat/graph.py:graph"
+      },
+      "image_distro": "wolfi"
+    }
+    ```
+
    #### Adding semantic search to the store

    All deployments come with a DB-backed BaseStore. Adding an "index" configuration to your `langgraph.json` will enable [semantic search](../deployment/semantic_search.md) within the BaseStore of your deployment.
@@ -123,3 +123,12 @@ Defaults to `''`.
 Set `REDIS_CLUSTER` to `True` to enable Redis Cluster mode. When enabled, the system will connect to Redis using cluster mode. This is useful when connecting to a Redis Cluster deployment.

 Defaults to `False`.
+
+## `MOUNT_PREFIX`
+
+!!! info "Only Allowed in Self-Hosted Deployments"
+    The `MOUNT_PREFIX` environment variable is only allowed in Self-Hosted Deployment models, LangGraph Platform SaaS will not allow this environment variable.
+
+Set `MOUNT_PREFIX` to serve the LangGraph Server under a specific path prefix. This is useful for deployments where the server is behind a reverse proxy or load balancer that requires a specific path prefix.
+
+For example, if the server is to be served under `https://example.com/langgraph`, set `MOUNT_PREFIX` to `/langgraph`.
@@ -46,7 +46,7 @@ While a router allows an LLM to make a single decision, more complex agent archi

 This architecture allows for more complex and flexible agent behaviors, going beyond simple routing to enable dynamic problem-solving with multiple steps. Unlike the original [paper](https://arxiv.org/abs/2210.03629), today's agents rely on LLMs' [tool calling](#tool-calling) capabilities and operate on a list of [messages](./low_level.md#why-use-messages).

-In LangGraph, you can use the prebuilt [agent](../agent/overview.md) to get started with tool-calling agents.
+In LangGraph, you can use the prebuilt [agent](../agents/agents.md#2-create-an-agent) to get started with tool-calling agents.

 ### Tool calling

@@ -75,7 +75,7 @@ Effective [memory management](../how-tos/memory.ipynb) enhances an agent's abili

 ### Planning

-In a tool-calling [agent](../agent/overview.md), an LLM is called repeatedly in a while-loop. At each step the agent decides which tools to call, and what the inputs to those tools should be. Those tools are then executed, and the outputs are fed back into the LLM as observations. The while-loop terminates when the agent decides it has enough information to solve the user request and it is not worth calling any more tools.
+In a tool-calling [agent](../agents/overview.md#what-is-an-agent), an LLM is called repeatedly in a while-loop. At each step the agent decides which tools to call, and what the inputs to those tools should be. Those tools are then executed, and the outputs are fed back into the LLM as observations. The while-loop terminates when the agent decides it has enough information to solve the user request and it is not worth calling any more tools.

 ## Custom agent architectures

@@ -32,7 +32,7 @@ Below are examples of directory structures for Python and JavaScript application
    │   ├── utils # utilities for your graph
    │   │   ├── __init__.py
    │   │   ├── tools.py # tools for your graph
-    │   │   ├── nodes.py # node functions for you graph
+    │   │   ├── nodes.py # node functions for your graph
    │   │   └── state.py # state definition of your graph
    │   ├── __init__.py
    │   └── agent.py # code for constructing your graph
@@ -15,15 +15,15 @@ Imagine a general-purpose writing agent built on a common graph architecture. Wh

 Assistants build on the LangGraph open source concept of [configuration](low_level.md#configuration).
 While configuration is available in the open source LangGraph library, assistants are only present in [LangGraph Platform](langgraph_platform.md).
-This is due to the fact that Assistants are tightly coupled to your deployed graph. Upon deployment, LangGraph Server will automatically create a default assistant for each graph using the graph's default configuration settings.
+This is due to the fact that assistants are tightly coupled to your deployed graph. Upon deployment, LangGraph Server will automatically create a default assistant for each graph using the graph's default configuration settings.

 In practice, an assistant is just an _instance_ of a graph with a specific configuration. Therefore, multiple assistants can reference the same graph but can contain different configurations (e.g. prompts, models, tools). The LangGraph Server API provides several endpoints for creating and managing assistants. See the [API reference](../cloud/reference/api/api_ref.html) and [this how-to](../cloud/how-tos/configuration_cloud.md) for more details on how to create assistants.

 ## Versioning assistants

 Assistants support versioning to track changes over time.
-Once you've created an assistant, subsequent edits to that assistant will create new versions. See [this how-to](../cloud/how-tos/assistant_versioning.md) for more details on how to manage assistant versions.
+Once you've created an assistant, subsequent edits to that assistant will create new versions. See [this how-to](../cloud/how-tos/configuration_cloud.md#create-a-new-version-for-your-assistant) for more details on how to manage assistant versions.

 ## Learn more

-* The LangGraph Cloud API provides several endpoints for creating and managing assistants their versions. See the [API reference](../../cloud/reference/api/api_ref.html#tag/assistants) for more details.
+* The LangGraph Cloud API provides several endpoints for creating and managing assistants and their versions. See the [API reference](../cloud/reference/api/api_ref.html#tag/assistants) for more details.
@@ -198,7 +198,7 @@ async def add_owner(
 You can register handlers for specific resources and actions by chaining the resource and action names together with the [`@auth.on`](../cloud/reference/sdk/python_sdk_ref.md#langgraph_sdk.auth.Auth.on) decorator.
 When a request is made, the most specific handler that matches that resource and action is called. Below is an example of how to register handlers for specific resources and actions. For the following setup:

-1. Authenticated users are able to create threads, read thread, create runs on threads
+1. Authenticated users are able to create threads, read threads, and create runs on threads
 2. Only users with the "assistants:create" permission are allowed to create new assistants
 3. All other endpoints (e.g., e.g., delete assistant, crons, store) are disabled for all users.

@@ -40,8 +40,8 @@ For more information, please see:

 ## Self-Hosted Data Plane

-!!! important "Beta"
-    The Self-Hosted Data Plane deployment option is currently in beta stage.
+!!! info "Important"
+    The Self-Hosted Data Plane deployment option is currently in beta stage and requires an [Enterprise](../concepts/plans.md) plan.

 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,10 +56,10 @@ For more information, please see:

 ## Self-Hosted Control Plane

-!!! important "Beta"
-    The Self-Hosted Control Plane deployment option is currently in beta stage.
+!!! info "Important"
+    The Self-Hosted Control Plane deployment option is currently in beta stage and requires an [Enterprise](../concepts/plans.md) plan.

-The [Self-Hosted Control Plane](./langgraph_self_hosted_control_plane.md) deployment option is a fully self-hosted model for deployment where you manage the [control plane](./langgraph_control_plane.md) and [data plane](./langgraph_data_plane.md) in your cloud. This option give you full control and responsibility of the control plane and data plane infrastructure.
+The [Self-Hosted Control Plane](./langgraph_self_hosted_control_plane.md) deployment option is a fully self-hosted model for deployment where you manage the [control plane](./langgraph_control_plane.md) and [data plane](./langgraph_data_plane.md) in your cloud. This option gives you full control and responsibility of the control plane and data plane infrastructure.

 Build a Docker image using the [LangGraph CLI](./langgraph_cli.md) and deploy your LangGraph Server from the [control plane UI](./langgraph_control_plane.md#control-plane-ui).

@@ -59,8 +59,8 @@ Yes! You can use LangGraph with any LLMs. The main reason we use LLMs that suppo

 Yes! LangGraph is totally ambivalent to what LLMs are used under the hood. The main reason we use closed LLMs in most of the tutorials is that they seamlessly support tool calling, while OSS LLMs often don't. But tool calling is not necessary (see [this section](#does-langgraph-work-with-llms-that-dont-support-tool-calling)) so you can totally use LangGraph with OSS LLMs.

-## Can I use LangGraph Studio without logging to LangSmith
+## Can I use LangGraph Studio without logging in to LangSmith

 Yes! You can use the [development version of LangGraph Server](../tutorials/langgraph-platform/local-server.md) to run the backend locally.
 This will connect to the studio frontend hosted as part of LangSmith.
-If you set an environment variable of `LANGSMITH_TRACING=false` then no traces will be sent to LangSmith.
+If you set an environment variable of `LANGSMITH_TRACING=false`, then no traces will be sent to LangSmith.
@@ -186,7 +186,7 @@ When declaring an `entrypoint`, you can request access to additional parameters

 | Parameter    | Description                                                                                                                                                        |
 |--------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| **previous** | Access the the state associated with the previous `checkpoint` for the given thread. See [short-term-memory](#short-term-memory).                                  |
+| **previous** | Access the state associated with the previous `checkpoint` for the given thread. See [short-term-memory](#short-term-memory).                                  |
 | **store**    | An instance of [BaseStore][langgraph.store.base.BaseStore]. Useful for [long-term memory](../how-tos/use-functional-api.md#long-term-memory).                      |
 | **writer**   | Use to access the StreamWriter when working with Async Python < 3.11. See [streaming with functional API for details](../how-tos/use-functional-api.md#streaming). |
 | **config**   | For accessing run time configuration. See [RunnableConfig](https://python.langchain.com/docs/concepts/runnables/#runnableconfig) for information.                  |
@@ -19,6 +19,7 @@ From the control plane UI, you can:
 - Update a deployment.
 - Update environment variables for a deployment.
 - View build and server logs of a deployment.
+- View deployment metrics like CPU and memory usage.
 - Delete a deployment.

 The Control Plane UI is embedded in [LangSmith](https://docs.smith.langchain.com/langgraph_cloud).
@@ -47,17 +48,22 @@ This section describes various features of the control plane.

 For simplicity, the control plane offers two deployment types with different resource allocations: `Development` and `Production`.

-| **Deployment Type** | **CPU** | **Memory** | **Scaling**         |
-|---------------------|---------|------------|---------------------|
-| Development         | 1 CPU   | 1 GB       | Up to 1 container   |
-| Production          | 2 CPU   | 2 GB       | Up to 10 containers |
+| **Deployment Type** | **CPU/Memory**  | **Scaling**         | **Database**                                                                     |
+|---------------------|-----------------|---------------------|----------------------------------------------------------------------------------|
+| Development         | 1 CPU, 1 GB RAM | Up to 1 container   | 10 GB disk, no backups                                                           |
+| Production          | 2 CPU, 2 GB RAM | Up to 10 containers | Autoscaling disk, automatic backups, highly available (multi-zone configuration) |

 CPU and memory resources are per container.

-!!! info "For [Cloud SaaS](../concepts/langgraph_cloud.md)"
+!!! warning "Immutable Deployment Type"
+
+    Once a deployment is created, the deployment type cannot be changed.
+
+!!! info "Resource Customization"
    For `Production` type deployments, resources can be manually increased on a case-by-case basis depending on use case and capacity constraints. Contact support@langchain.dev to request an increase in resources.

-!!! info 
+    For `Development` types deployments, database disk size can be manually increased on a case-by-case basis depending on use case and capacity constraints. For most use cases, [TTLs](../how-tos/ttl/configure_ttl.md) should be configured to manage disk usage. Contact support@langchain.dev to request an increase in resources.
+
    Resources for [Self-Hosted Data Plane](../concepts/langgraph_self_hosted_data_plane.md) and [Self-Hosted Control Plane](../concepts/langgraph_self_hosted_control_plane.md) deployments can be fully customized.

 ### Database Provisioning
@@ -83,6 +89,15 @@ Infrastructure for deployments and revisions are provisioned and deployed asynch

 The control plane and [LangGraph Data Plane](./langgraph_data_plane.md) "listener" application coordinate to achieve asynchronous deployments.

+### Monitoring
+
+After a deployment is ready, the control plane monitors the deployment and records various metrics, such as:
+
+- CPU and memory usage of the deployment.
+- Number of container restarts.
+
+These metrics are displayed as charts in the Control Plane UI.
+
 ### LangSmith Integration

 A [LangSmith](https://docs.smith.langchain.com/) tracing project is automatically created for each deployment. The tracing project has the same name as the deployment. When creating a deployment, the `LANGCHAIN_TRACING` and `LANGSMITH_API_KEY`/`LANGCHAIN_API_KEY` environment variables do not need to be specified; they are set automatically by the control plane.
@@ -9,7 +9,7 @@ The term "data plane" is used broadly to refer to [LangGraph Servers](./langgrap

 ## Server Infrastructure

-In addition to the [LangGraph Server](./langgraph_server.md) itself, the following infrastructure for each server are also included in the broad definition of "data plane":
+In addition to the [LangGraph Server](./langgraph_server.md) itself, the following infrastructure components for each server are also included in the broad definition of "data plane":

 - Postgres
 - Redis
@@ -44,7 +44,7 @@ All runs in a LangGraph Server are executed by a pool of background workers that

 ### Ephemeral metadata

-Runs in a LangGraph Server may be retried for specific failures (currently only for transient Postgres errors encountered during the run). In order to limit the number of retries (currently limited to 3 attempts per run) we record the attempt number in a Redis string when is picked up. This contains no run-specific info other than its ID, and expires after a short delay.
+Runs in a LangGraph Server may be retried for specific failures (currently only for transient Postgres errors encountered during the run). In order to limit the number of retries (currently limited to 3 attempts per run) we record the attempt number in a Redis string when it is picked up. This contains no run-specific info other than its ID, and expires after a short delay.

 ## Data Plane Features

@@ -62,7 +62,7 @@ For CPU utilization, the autoscaler targets 75% utilization. This means the auto

 For number of pending runs, the autoscaler targets 10 pending runs. For example, if the current number of containers is 1, but the number of pending runs in 20, the autoscaler will scale up the deployment to 2 containers (20 pending runs / 2 containers = 10 pending runs per container).

-Each metric is computed independently and the autoscaler will determine the scaling action based on the metric that results in the most number of containers.
+Each metric is computed independently and the autoscaler will determine the scaling action based on the metric that results in the largest number of containers.

 Scale down actions are delayed for 30 minutes before any action is taken. In other words, if the autoscaler decides to scale down a deployment, it will first wait for 30 minutes before scaling down. After 30 minutes, the metrics are recomputed and the deployment will scale down if the recomputed metrics result in a lower number of containers than the current number. Otherwise, the deployment remains scaled up. This "cool down" period ensures that deployments do not scale up and down too frequently.

@@ -5,18 +5,17 @@ search:

 # LangGraph Platform

-**LangGraph Platform** is a commercial solution for deploying agentic applications to production, built on the open-source [LangGraph framework](../index.md).
-
-<div align="center"><iframe width="560" height="315" src="https://www.youtube.com/embed/pfAQxBS5z88?si=XGS6Chydn6lhSO1S" title="What is LangGraph Platform?" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe></div>
+Develop, deploy, scale, and manage agents with **LangGraph Platform** — the purpose-built platform for long-running, agentic workflows.

 !!! tip "Get started with LangGraph Platform"

-    Check out the [LangGraph Platform quickstart](../cloud/quick_start.md) for instructions on how to set up and use LangGraph Platform to do a cloud deployment.
-
+    Check out the [LangGraph Platform quickstart](../tutorials/langgraph-platform/local-server.md) for instructions on how to use LangGraph Platform to run a LangGraph application locally.

 ## Why use LangGraph Platform?

-LangGraph Platform handles common issues that arise when deploying LLM applications to production, allowing you to focus on agent logic instead of managing server infrastructure.
+<div align="center"><iframe width="560" height="315" src="https://www.youtube.com/embed/pfAQxBS5z88?si=XGS6Chydn6lhSO1S" title="What is LangGraph Platform?" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe></div>
+
+LangGraph Platform makes it easy to get your agent running in production —  whether it’s built with LangGraph or another framework — so you can focus on your app logic, not infrastructure. Deploy with one click to get a live endpoint, and use our robust APIs and built-in task queues to handle production scale. 

 - **[Streaming Support](../cloud/concepts/streaming.md)**: As agents grow more sophisticated, they often benefit from streaming both token outputs and intermediate states back to the user. Without this, users are left waiting for potentially long operations with no feedback. LangGraph Server provides multiple streaming modes optimized for various application needs.

@@ -32,8 +31,6 @@ LangGraph Platform handles common issues that arise when deploying LLM applicati

 - **[Human-in-the-loop support](../cloud/how-tos/human_in_the_loop_breakpoint.md)**: In many applications, users require a way to intervene in agent processes. LangGraph Server provides specialized endpoints for human-in-the-loop scenarios, simplifying the integration of manual oversight into agent workflows.

-By using LangGraph Platform, you gain access to a robust, scalable deployment solution that mitigates these challenges, saving you the effort of implementing and maintaining them manually. This allows you to focus more on building effective agent behavior and less on solving deployment infrastructure issues.
+- **[LangGraph Studio](./langgraph_studio.md)**: Enables visualization, interaction, and debugging of agentic systems that implement the LangGraph Server API protocol. Studio also integrates with LangSmith to enable tracing, evaluation, and prompt engineering.

-## Deployment
-
-There are several ways to deploy on LangGraph Platform. For more information, see [Deployment options](./deployment_options.md).
+- **[Deployment](./deployment_options.md)**: There are four ways to deploy on LangGraph Platform: [Cloud SaaS](../concepts/langgraph_cloud.md), [Self-Hosted Data Plane](../concepts/langgraph_self_hosted_data_plane.md), [Self-Hosted Control Plane](../concepts/langgraph_self_hosted_control_plane.md), and [Standalone Container](../concepts/langgraph_standalone_container.md).
@@ -2,17 +2,19 @@

 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).

-!!! important "Beta"
-    The Self-Hosted Control Plane deployment option is currently in beta stage.
+!!! info "Important"
+    The Self-Hosted Control Plane deployment option is currently in beta stage and requires an [Enterprise](../../concepts/plans.md) plan.

 ## Requirements

 - You use `langgraph-cli` and/or [LangGraph Studio](./langgraph_studio.md) app to test graph locally.
 - You use `langgraph build` command to build image.
+- You have a Self-Hosted LangSmith instance deployed.
+- You are using Ingress for your LangSmith instance. All agents will be deployed as Kubernetes services behind this ingress.

 ## Self-Hosted Control Plane

-The [Self-Hosted Control Plane](./langgraph_self_hosted_control_plane.md) deployment option is a fully self-hosted model for deployment where you manage the [control plane](./langgraph_control_plane.md) and [data plane](./langgraph_data_plane.md) in your cloud. This option give you full control and responsibility of the control plane and data plane infrastructure.
+The [Self-Hosted Control Plane](./langgraph_self_hosted_control_plane.md) deployment option is a fully self-hosted model for deployment where you manage the [control plane](./langgraph_control_plane.md) and [data plane](./langgraph_data_plane.md) in your cloud. This option gives you full control and responsibility of the control plane and data plane infrastructure.

 |                   | [Control plane](../concepts/langgraph_control_plane.md) | [Data plane](../concepts/langgraph_data_plane.md) |
 |-------------------|-------------------|------------|
@@ -29,4 +31,4 @@ The [Self-Hosted Control Plane](./langgraph_self_hosted_control_plane.md) deploy
 - **Kubernetes**: The Self-Hosted Control Plane deployment option supports deploying control plane and data plane infrastructure to any Kubernetes cluster.

 !!! tip
-    If you would like to deploy to Kubernetes, you can use this [Helm chart](https://github.com/langchain-ai/helm/blob/main/charts/langgraph-cloud/README.md).
+    If you would like to enable this on your LangSmith instance, please follow the [Self-Hosted Control Plane deployment guide](../cloud/deployment/self_hosted_control_plane.md).
--- a/Show More
+++ b/Show More