x

- Make sure that we're calling `getType` instead of deprecated `_getType()`
- Make sure that we're referencing the proper camelCase symbols instead of snake_case symbols
- Make sure that we're using proper links to the API reference
- Make sure to chain calls of StateGraph methods
- Make sure to use Zod state in all snippets

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -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:

.github/ISSUE_TEMPLATE/config.yml

@@ -1,4 +1,4 @@
-blank_issues_enabled: false
+blank_issues_enabled: true
 version: 2.1
 contact_links:
   - name: 🤔 Question or Problem

.github/ISSUE_TEMPLATE/documentation.yml

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

.github/actions/poetry_setup/action.yml

@@ -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') }}

.github/dependabot.yml

@@ -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"

.github/workflows/_integration_test.yml

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

.github/workflows/_lint.yml

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

.github/workflows/_test.yml

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

.github/workflows/_test_langgraph.yml

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

.github/workflows/_test_release.yml

@@ -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:

.github/workflows/_test_scheduler_kafka.yml

@@ -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'

.github/workflows/baseline.yml

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

.github/workflows/bench.yml

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

.github/workflows/ci.yml

@@ -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,

.github/workflows/deploy_docs.yml

@@ -9,9 +9,6 @@ on:
       - main
   workflow_dispatch:
 
-env:
-  POETRY_VERSION: "2.1.2"
-
 permissions:
   contents: read
   pages: write
@@ -57,21 +54,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
@@ -103,7 +100,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 +125,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/.*" \
@@ -148,7 +145,7 @@ jobs:
 
       - name: Configure GitHub Pages
         if: github.ref == 'refs/heads/main'
-        uses: actions/configure-pages@v4
+        uses: actions/configure-pages@v5
 
       - name: Upload Pages Artifact
         # if: github.ref == 'refs/heads/main'

.github/workflows/link_check.yml

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

.github/workflows/release.yml

@@ -10,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:

.github/workflows/release_js.yml

@@ -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"

.github/workflows/run_notebooks.yml

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

.gitignore

@@ -181,3 +181,4 @@ Chinook.db
 .vercel
 .turbo
 .editorconfig
+.scratch

AGENTS.md

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

CONTRIBUTING.md

@@ -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
 ```

Makefile

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

README.md

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

docs/Makefile

@@ -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
 
 build-docs: build-typedoc build-prebuilt
-	poetry run python -m mkdocs build --clean -f mkdocs.yml --strict
+	TARGET_LANGUAGE=js 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 .

docs/README.md

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

docs/_scripts/add_translation.py

@@ -1,157 +0,0 @@
-"""Add typescript translation to a given markdown file."""
-
-import argparse
-import re
-
-import requests
-from langchain_anthropic import ChatAnthropic
-
-URL = "https://gist.githubusercontent.com/eyurtsev/e7486731415463a9bc5b4682358859c8/raw/b5a5fda9c7e3387cfcb781f25082814d43675d50/gistfile1.txt"
-response = requests.get(URL)
-response.raise_for_status()
-reference_snippets = response.text
-
-model = ChatAnthropic(model="claude-3-5-sonnet-latest")
-
-
-def _get_tqdm():
-    try:
-        from tqdm import tqdm
-    except ImportError:
-        # If not available return a simple identity function
-        def tqdm(iterable, *args, **kwargs):
-            return iterable
-
-    return tqdm
-
-
-_tqdm = _get_tqdm()
-
-opening_pattern = re.compile(r"^\s*```python(?:\s+.*)?\s*$")
-closing_pattern = re.compile(r"^\s*```\s*$")
-
-
-def extract_python_snippets(markdown: str) -> list[str]:
-    """
-    Extract all python code blocks (including their fence lines) from the markdown content.
-    A python block is defined as any block that starts with a line containing an opening fence
-    with '```python' (optionally with extra parameters) and ends with a closing fence '```'.
-    """
-    snippets = []
-    inside_block = False
-    current_snippet = []
-
-    for line in markdown.splitlines(keepends=True):
-        if not inside_block:
-            if opening_pattern.match(line):
-                inside_block = True
-                current_snippet = [line]
-        else:
-            current_snippet.append(line)
-            if closing_pattern.match(line):
-                inside_block = False
-                snippets.append("".join(current_snippet))
-                current_snippet = []
-    return snippets
-
-
-def translate_snippet(python_snippet: str) -> str:
-    """Translate a python code block into a TypeScript code block using Langchain.
-    The response is expected to be a properly fenced TypeScript code block (i.e.
-    starting with ```typescript and ending with ```).
-    """
-    ai_message = model.invoke(
-        [
-            {
-                "role": "system",
-                "content": (
-                    f"You have access to the following up-to-date example TypeScript code "
-                    f"snippets that show examples of building with langgraph "
-                    f"and langchain:\n\n{reference_snippets}\n\n"
-                    "Use this context to translate the following Python code to equivalent "
-                    "TypeScript. Ensure that your output is a valid fenced TypeScript "
-                    "code block (i.e. starts with ```typescript and ends with ```)."
-                ),
-            },
-            {
-                "role": "user",
-                "content": f"Translate this Python snippet to TypeScript:\n\n{python_snippet}",
-            },
-        ]
-    )
-
-    # Use a regular expression to search for a TypeScript code block in the response.
-    pattern = r"```typescript\s*(.*?)\s*```"
-    match = re.search(pattern, ai_message.content, re.DOTALL)
-    if match:
-        # Reconstruct the code block with proper fences.
-        typescript_code = match.group(1).strip()
-        return f"```typescript\n{typescript_code}\n```"
-    else:
-        raise ValueError("No TypeScript code block found in the model's response.")
-
-
-def insert_translations_into_markdown(
-    markdown: str, typescript_snippets: list[str]
-) -> str:
-    """Walks through the original markdown content and, after each
-    Python snippet block, inserts the corresponding translated TypeScript snippet.
-    It assumes that the ordering of the Python snippets
-    (from extract_python_snippets) matches the order they appear in the markdown.
-    """
-    output_lines = []
-    lines = markdown.splitlines(keepends=True)
-    inside_block = False
-    snippet_index = 0
-
-    for line in lines:
-        output_lines.append(line)
-        if not inside_block and opening_pattern.match(line):
-            # We've encountered the start of a python code block.
-            inside_block = True
-        elif inside_block:
-            if closing_pattern.match(line):
-                # End of a python snippet block.
-                inside_block = False
-                if snippet_index < len(typescript_snippets):
-                    # Insert an extra newline for clarity, then the translated TypeScript snippet.
-                    output_lines.append("\n")
-                    output_lines.append(typescript_snippets[snippet_index])
-                    output_lines.append("\n")
-                    snippet_index += 1
-    return "".join(output_lines)
-
-
-def main(file_path: str) -> None:
-    # Read the markdown file.
-    with open(file_path, "r") as f:
-        markdown_content = f.read()
-
-    # 1. Extract all Python snippets.
-    python_snippets = extract_python_snippets(markdown_content)[:1]
-
-    # 2. Translate each Python snippet to TypeScript.
-    typescript_snippets = []
-    # Replace with .batch() for faster translation
-    for python_snippet in _tqdm(python_snippets):
-        ts_snippet = translate_snippet(python_snippet)
-        typescript_snippets.append(ts_snippet)
-
-    # 3. Insert the TypeScript translations after their respective Python snippets.
-    updated_markdown = insert_translations_into_markdown(
-        markdown_content, typescript_snippets
-    )
-
-    # Overwrite the original markdown file with the updated content.
-    with open(file_path, "w") as f:
-        f.write(updated_markdown)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(
-        description="Translate Python snippets in a markdown file to TypeScript and insert them after each Python snippet."
-    )
-    parser.add_argument("file_path", type=str, help="Path to the markdown file.")
-    args = parser.parse_args()
-
-    main(args.file_path)

docs/_scripts/execute_notebooks.sh

@@ -8,7 +8,7 @@ execute_notebook() {
     file="$1"
     echo "Starting execution of $file"
     start_time=$(date +%s)
-    if ! output=$(time 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"

docs/_scripts/generate_llms_text.py

@@ -1,19 +1,72 @@
 """Experimental script to generate consolidated llms text from the docs."""
 
+import asyncio
 import glob
 import os
+import re
+from typing import TypedDict, List, Optional
 
+import yaml
+from langchain.chat_models import init_chat_model
+from langchain_core.rate_limiters import InMemoryRateLimiter
 from mkdocs.structure.files import File
 from mkdocs.structure.pages import Page
+from pydantic import BaseModel, Field
+from yaml import SafeLoader
 
-from _scripts.notebook_hooks import _on_page_markdown_with_config
+from _scripts.notebook_hooks import (
+    _on_page_markdown_with_config,
+    _apply_conditional_rendering,
+)
 
 HERE = os.path.dirname(os.path.abspath(__file__))
 # Get source directory (parent of HERE / docs)
 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 +74,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 +86,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 +104,170 @@ 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 +277,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)

docs/_scripts/js_translation/add_translation.py

@@ -0,0 +1,236 @@
+"""Translate Python markdown to TypeScript and/or consolidate Python-JS markdown into a single document."""
+
+import argparse
+
+import requests
+from langchain_anthropic import ChatAnthropic
+from textwrap import dedent
+
+
+# Load reference TypeScript snippets
+URL = "https://gist.githubusercontent.com/dqbd/b35d49e2ceec80e654fe1c5ab61ec477/raw/f4768aeedb67628190a4e06d063a938afc8e7672/snippets.md"
+response = requests.get(URL)
+response.raise_for_status()
+reference_snippets = response.text
+
+# Initialize model
+model = ChatAnthropic(model="claude-sonnet-4-0", max_tokens=64_000)
+
+
+FLUENT_INTERFACE_PROMPT = (
+    "CRITICAL: Always use method chaining (fluent interface) for StateGraph operations in TypeScript. "
+    "Never create separate variables for the graph builder or call methods individually. "
+    "The fluent interface provides better type safety and is the preferred pattern.\n\n"
+    "CORRECT examples with fluent interface:\n"
+    + dedent(
+        """
+        ```typescript
+        const graph = new StateGraph(MyState)
+          .addNode('node1', node1)
+          .addNode('node2', node2)
+          .addEdge(START, 'node1')
+          .addEdge('node1', 'node2')
+          .addEdge('node2', END)
+          .compile()
+        ```
+        
+        ```typescript
+        const graph = new StateGraph(MyState)
+          .addNode('chatbot', chatbot)
+          .addEdge(START, 'chatbot')
+          .addEdge('chatbot', END)
+          .compile()
+        ```
+        
+        ```typescript
+        const graph = new StateGraph(MyState)
+          .addNode('chatbot', chatbot)
+          .addEdge(START, 'chatbot')
+          .addEdge('chatbot', END)
+          .compile()
+        ```
+        """
+    )
+    + "\n"
+    + "INCORRECT examples to avoid:\n"
+    + dedent(
+        """
+        ```typescript
+        // WRONG: Creating separate builder variable
+        const graphBuilder = new StateGraph(MyState)
+        graphBuilder.addNode('node1', node1)
+        graphBuilder.addEdge(START, 'node1')
+        const graph = graphBuilder.compile()
+        ```
+        
+        ```typescript
+        // WRONG: Using Python-style method names
+        const workflow = new StateGraph(MyState)
+        workflow.add_node('node1', node1)
+        workflow.add_edge(START, 'node1')
+        const graph = workflow.compile()
+        ```
+        
+        ```typescript
+        // WRONG: Calling methods individually
+        const graphBuilder = new StateGraph(MyState)
+        graphBuilder.addNode('chatbot', chatbot)
+        graphBuilder.addEdge(START, 'chatbot')
+        graphBuilder.addEdge('chatbot', END)
+        const graph = graphBuilder.compile()
+        ```
+        """
+    )
+    + "\n"
+    + "Key rules:\n"
+    + "- Always chain methods directly on the StateGraph constructor\n"
+    + "- Use camelCase method names (addNode, addEdge, not add_node, add_edge)\n"
+    + "- Always end with .compile()\n"
+    + "- Never store the builder in a separate variable\n"
+)
+
+
+TRANSLATION_PROMPT = (
+    "You are a helpful assistant that translates Python-based technical "
+    "documentation written in Markdown to equivalent TypeScript-based documentation. "
+    "The input is a Markdown file written in mkdocs format. It contains "
+    "Python code snippets embedded in prose. "
+    "Your task is to rewrite the content by translating the Python code to "
+    "idiomatic TypeScript, using the provided TypeScript reference snippets "
+    "to ensure accurate and consistent usage (e.g., correct imports, function "
+    "names, and patterns). "
+    "Remove the original Python code and replace it with the corresponding "
+    "TypeScript version. "
+    "Do not alter the surrounding prose unless a change is necessary to "
+    "reflect differences between Python and TypeScript. "
+    "Preserve the structure and formatting of the original Markdown document. "
+    "Do not make stylistic or structural changes unless they directly support "
+    "the translation. "
+    "Use the reference TypeScript snippets as guidance whenever possible to "
+    "maintain alignment with existing conventions.\n\n"
+    "IMPORTANT REQUIREMENTS:\n"
+    "- Use Zod for state definition for StateGraph. Avoid using Annotation since it will be deprecated in the future.\n"
+    "- ALWAYS use fluent interface (method chaining) for StateGraph operations - this is CRITICAL\n"
+    "- Never create separate variables for graph builders\n"
+    "- Always chain methods directly on the StateGraph constructor and end with .compile()\n\n"
+    f"{FLUENT_INTERFACE_PROMPT}\n\n"
+    f"Here are the reference TypeScript snippets:\n\n{reference_snippets}\n\n"
+)
+
+CONSOLIDATION_PROMPT = (
+    "You are a helpful assistant that consolidates parallel Python and JavaScript (TypeScript) technical documentation "
+    "written in Markdown into a single unified Markdown document. "
+    "The input consists of two documents: the first is for Python users, and the second is for JavaScript/TypeScript users. "
+    "Your task is to merge these into one Markdown file using language-specific fenced blocks to separate the content where needed. "
+    "Use the following syntax to distinguish content for each language:\n\n"
+    ":::python\n"
+    "# Python-specific content\n"
+    ":::\n\n"
+    ":::js\n"
+    "# JavaScript/TypeScript-specific content\n"
+    ":::\n\n"
+    "Follow these consolidation rules:\n"
+    "- When content (prose or code) is the same or nearly identical in both versions, include it only once—outside of any fenced block.\n"
+    "- When content differs between the Python and JS versions, wrap each version in its corresponding fenced block.\n"
+    "- Prefer **paragraph-level separation** of language-specific content. Do not combine Python and JS snippets or terminology in the same sentence or paragraph using conditional phrases.\n"
+    "  For example, avoid inline constructs like:\n"
+    "  `The :::python add_messages ::: :::js reducer ::: function...`\n"
+    "  Instead, write two distinct paragraphs:\n\n"
+    "  :::python\n"
+    "  The `add_messages` function in our `State` will append the LLM's response messages to whatever messages are already in the state.\n"
+    "  ::: \n\n"
+    "  :::js\n"
+    "  The `reducer` function in our `StateAnnotation` will append the LLM's response messages to whatever messages are already in the state.\n"
+    "  :::\n\n"
+    "- Preserve the overall structure, ordering, and formatting of the original Markdown documents.\n"
+    "- Do not rephrase or unify content unless it is logically and semantically identical.\n"
+    "- Use the fenced blocks for both prose and code as needed, and ensure output is clean, readable Markdown suitable for tools that parse these directives.\n"
+    "Your goal is to produce a cleanly merged documentation file that serves both Python and JavaScript users without redundancy, while maximizing clarity and separation of language-specific details."
+)
+
+
+def translate_python_to_ts(markdown_content: str) -> str:
+    response = model.invoke(
+        [
+            {
+                "role": "system",
+                "content": TRANSLATION_PROMPT,
+                "cache_control": {"type": "ephemeral"},
+            },
+            {"role": "user", "content": markdown_content},
+        ]
+    )
+    return response.content
+
+
+def consolidate_python_and_ts(combined_content: str) -> str:
+    response = model.invoke(
+        [
+            {
+                "role": "system",
+                "content": CONSOLIDATION_PROMPT,
+                "cache_control": {"type": "ephemeral"},
+            },
+            {"role": "user", "content": combined_content},
+        ]
+    )
+    return response.content
+
+
+def main(file_path: str, translate_only: bool, consolidate_only: bool) -> None:
+    with open(file_path, "r", encoding="utf-8") as f:
+        markdown_content = f.read()
+
+    if translate_only:
+        translated = translate_python_to_ts(markdown_content)
+        output_path = file_path.replace(".md", ".translated.md")
+        with open(output_path, "w", encoding="utf-8") as f:
+            f.write(translated)
+        print(f"Translated JS/TS version written to: {output_path}")
+
+    elif consolidate_only:
+        consolidated = consolidate_python_and_ts(markdown_content)
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(consolidated)
+        print(f"Consolidated content written to: {file_path}")
+
+    else:
+        # Default behavior: translate first, then consolidate both
+        translated = translate_python_to_ts(markdown_content)
+        combined = f"{markdown_content.strip()}\n\n\n{translated.strip()}"
+        consolidated = consolidate_python_and_ts(combined)
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(consolidated)
+        print(f"Translated and consolidated content written to: {file_path}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description=(
+            "Translate Python markdown to TypeScript and/or consolidate "
+            "Python-JS markdown into one file."
+        )
+    )
+    parser.add_argument("file_path", type=str, help="Path to the markdown file.")
+    parser.add_argument(
+        "--translate-only",
+        action="store_true",
+        help="Only generate the JS translation.",
+    )
+    parser.add_argument(
+        "--consolidate-only",
+        action="store_true",
+        help="Only consolidate pre-paired Python and JS content.",
+    )
+    args = parser.parse_args()
+
+    if args.translate_only and args.consolidate_only:
+        raise ValueError(
+            "Cannot use both --translate-only and --consolidate-only at the same time."
+        )
+
+    main(
+        args.file_path,
+        translate_only=args.translate_only,
+        consolidate_only=args.consolidate_only,
+    )

docs/_scripts/js_translation/codeblocks/.gitkeep

@@ -0,0 +1,6 @@
+.prettierrc
+.eslint.config.mjs
+package.json
+README.md
+tsconfig.json
+yarn.lock

docs/_scripts/js_translation/codeblocks/.prettierrc

@@ -0,0 +1,19 @@
+{
+  "$schema": "https://json.schemastore.org/prettierrc",
+  "printWidth": 80,
+  "tabWidth": 2,
+  "useTabs": false,
+  "semi": true,
+  "singleQuote": false,
+  "quoteProps": "as-needed",
+  "jsxSingleQuote": false,
+  "trailingComma": "es5",
+  "bracketSpacing": true,
+  "arrowParens": "always",
+  "requirePragma": false,
+  "insertPragma": false,
+  "proseWrap": "preserve",
+  "htmlWhitespaceSensitivity": "css",
+  "vueIndentScriptAndStyle": false,
+  "endOfLine": "lf"
+}

docs/_scripts/js_translation/codeblocks/README.md

@@ -0,0 +1 @@
+# \_codeblocks

docs/_scripts/js_translation/codeblocks/eslint.config.mjs

@@ -0,0 +1,14 @@
+import js from "@eslint/js";
+import globals from "globals";
+import tseslint from "typescript-eslint";
+import { defineConfig } from "eslint/config";
+
+export default defineConfig([
+  {
+    files: ["**/*.{js,mjs,cjs,ts,mts,cts}"],
+    plugins: { js },
+    extends: ["js/recommended"],
+    languageOptions: { globals: globals.browser },
+  },
+  tseslint.configs.recommended,
+]);

docs/_scripts/js_translation/codeblocks/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "_codeblocks",
+  "packageManager": "yarn@4.6.0",
+  "scripts": {
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write .",
+    "format:fix": "prettier --write . --fix"
+  },
+  "dependencies": {
+    "@langchain/anthropic": "^0.3.24",
+    "@langchain/core": "^0.3.66",
+    "@langchain/langgraph": "^0.3.11",
+    "@langchain/langgraph-api": "^0.0.52",
+    "@langchain/langgraph-sdk": "^0.0.102",
+    "@langchain/openai": "^0.6.3",
+    "zod": "^4.0.10"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.32.0",
+    "eslint": "^9.32.0",
+    "globals": "^16.3.0",
+    "jiti": "^2.5.1",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.38.0"
+  }
+}

docs/_scripts/js_translation/codeblocks/tsconfig.json

@@ -0,0 +1,114 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "esnext",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "libReplacement": true,                           /* Enable lib replacement. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+
+    /* Modules */
+    "module": "nodenext",                                /* Specify what module code is generated. */
+    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
+    "moduleResolution": "nodenext",                     /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    // "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
+    // "rewriteRelativeImportExtensions": true,          /* Rewrite '.ts', '.tsx', '.mts', and '.cts' file extensions in relative import paths to their JavaScript equivalent in output files. */
+    // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
+    // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
+    // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
+    // "noUncheckedSideEffectImports": true,             /* Check side effect imports. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
+    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+
+    /* Emit */
+    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+    // "outDir": "./",                                   /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
+    // "isolatedDeclarations": true,                     /* Require sufficient annotation on exports so other tools can trivially generate declaration files. */
+    // "erasableSyntaxOnly": true,                       /* Do not allow runtime constructs that are not part of ECMAScript. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+
+    /* Type Checking */
+    "strict": false,                                      /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "strictBuiltinIteratorReturn": true,              /* Built-in iterators are instantiated with a 'TReturn' type of 'undefined' instead of 'any'. */
+    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+    ""
+  }
+}

docs/_scripts/js_translation/extract_codeblocks.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python
+"""Extracts typescript code blocks from a markdown file."""
+
+import argparse
+import json
+import re
+import os
+from typing import List, TypedDict, Literal
+
+
+class CodeBlock(TypedDict):
+    """A code block extracted from a markdown file."""
+    starting_line: int
+    """The line number where the code block starts in the source file"""
+    ending_line: int
+    """The line number where the code block ends in the source file"""
+    indentation: int
+    """Number of spaces/tabs used for indentation of the code block"""
+    source_file: str
+    """Path to the markdown file containing this code block"""
+    frontmatter: str
+    """Any metadata or frontmatter specified after the opening code fence"""
+    code: str
+    """The actual code content within the code block"""
+    language: str
+    """The language of the code block (e.g. typescript, javascript)"""
+
+
+def extract_code_blocks(markdown_content: str, source_file: str) -> List[CodeBlock]:
+    """Extracts code blocks from a markdown file.
+
+    Args:
+        markdown_content: The content of the markdown file.
+        source_file: The path to the markdown file.
+
+    Returns:
+        A list of TypedDicts, where each dict represents a code block.
+    """
+    # Regex to find code blocks with specified languages, capturing indentation
+    # and frontmatter.
+    pattern = re.compile(
+        r"^(?P<indentation>\s*)```(?P<language>typescript|javascript|ts|js)(?P<frontmatter>[^\n]*)\n(?P<code>.*?)\n^(?P=indentation)```\s*$",
+        re.DOTALL | re.MULTILINE,
+    )
+
+    code_blocks: List[CodeBlock] = []
+    for match in pattern.finditer(markdown_content):
+        start_pos = match.start()
+
+        # Calculate line numbers
+        starting_line = markdown_content.count("\n", 0, start_pos) + 1
+        ending_line = starting_line + match.group(0).count("\n")
+
+        indentation_str = match.group("indentation")
+
+        code_block: CodeBlock = {
+            "starting_line": starting_line,
+            "ending_line": ending_line,
+            "indentation": len(indentation_str),
+            "source_file": source_file,
+            "frontmatter": match.group("frontmatter").strip(),
+            "code": match.group("code"),
+            "language": match.group("language"),
+        }
+        code_blocks.append(code_block)
+
+    return code_blocks
+
+def dump_code_blocks(input_file: str, output_file: str, format: Literal["json", "inline"]) -> None:
+    """Function to extract and save code blocks from a markdown file.
+
+    Args:
+        input_file: Path to the input markdown file.
+        output_file: Path to the output JSON file for the extracted code blocks.
+        format: Output format - either "json" or "inline"
+    """
+    with open(input_file, "r", encoding="utf-8") as f:
+        markdown_content = f.read()
+
+    extracted_code = extract_code_blocks(markdown_content, input_file)
+
+    if len(extracted_code) == 0:
+        print(f"No code blocks found in {input_file}")
+        return
+    
+    if format == "json":
+        with open(output_file, "w", encoding="utf-8") as f:
+            json.dump(extracted_code, f, indent=2)
+    elif format == "inline":
+        with open(output_file, "w", encoding="utf-8") as f:
+            for code_block in extracted_code:
+                f.write(f"// {json.dumps({k:v for k,v in code_block.items() if k != 'code'})}\n")
+                f.write("\n")
+                f.write(code_block["code"])
+                f.write("\n")
+    print(f"Extracted {len(extracted_code)} code blocks from {input_file} to {output_file}")
+
+def main(input_path: str, output_path: str, format: Literal["json", "inline"]) -> None:
+    """Main function to extract code blocks from a markdown file.
+
+    Args:
+        input_file: Path to the input markdown file.
+        output_file: Path to the output JSON file for the extracted code blocks.
+        format: Output format - either "json" or "inline"
+    """
+    # Check if input path is a directory
+    if os.path.isdir(input_path):
+        if os.path.isfile(output_path):
+            raise ValueError("If input_path is a directory, output_path must also be a directory")
+        if not os.path.isdir(output_path):
+            os.makedirs(output_path, exist_ok=True)
+        
+        # Process each markdown file in the directory recursively
+        for root, _, files in os.walk(input_path):
+            for filename in files:
+                if filename.endswith(".md"):
+                    # Get relative path to maintain directory structure
+                    rel_path = os.path.relpath(root, input_path)
+                    input_file = os.path.join(root, filename)
+                    # Create output directory if it doesn't exist
+                    output_dir = os.path.join(output_path, rel_path)
+                    os.makedirs(output_dir, exist_ok=True)
+                    output_file = os.path.join(output_dir, filename.replace(".md", ".ts"))
+                    dump_code_blocks(input_file, output_file, format)
+    else:
+        # Process single file
+        dump_code_blocks(input_path, output_path, format)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Extract typescript code blocks from a markdown file."
+    )
+    parser.add_argument(
+        "input_file",
+        help="Path to the input markdown file.",
+    )
+    parser.add_argument(
+        "output_file",
+        help="Path to the output JSON file for the extracted code blocks.",
+    )
+    parser.add_argument(
+        "--format",
+        choices=["json", "inline"],
+        default="json",
+        help="Output format - either 'json' or 'inline'",
+    )
+    args = parser.parse_args()
+
+    main(args.input_file, args.output_file, args.format)

docs/_scripts/link_map.py

@@ -0,0 +1,5 @@
+JS_LINK_MAP = {
+    "langgraph.types.interrupt": "https://langchain-ai.github.io/langgraphjs/reference/functions/langgraph.interrupt-2.html",
+    "create_react_agent": "https://langchain-ai.github.io/langgraphjs/reference/functions/langgraph_prebuilt.createReactAgent.html",
+    "langgraph.types.Command": "https://langchain-ai.github.io/langgraphjs/reference/classes/langgraph.Command.html",
+}

docs/_scripts/notebook_hooks.py

@@ -1,13 +1,21 @@
+"""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
 
 from _scripts.generate_api_reference_links import update_markdown_with_imports
+from _scripts.link_map import JS_LINK_MAP
 from _scripts.notebook_convert import convert_notebook
 
 logger = logging.getLogger(__name__)
@@ -39,19 +47,26 @@ 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",
-    "how-tos/memory/add-summary-conversation-history.ipynb": "how-tos/memory.ipynb#summarize-messages",
+    "how-tos/memory/manage-conversation-history.ipynb": "how-tos/memory/add-memory.md",
+    "how-tos/memory/delete-messages.ipynb": "how-tos/memory/add-memory.md#delete-messages",
+    "how-tos/memory/add-summary-conversation-history.ipynb": "how-tos/memory/add-memory.md#summarize-messages",
+    "how-tos/memory.ipynb": "how-tos/memory/add-memory.md",
+    "agents/memory.ipynb": "how-tos/memory/add-memory.md",
     # subgraph how-tos
     "how-tos/subgraph-transform-state.ipynb": "how-tos/subgraph.ipynb#different-state-schemas",
     "how-tos/subgraphs-manage-state.ipynb": "how-tos/subgraph.ipynb#add-persistence",
     # persistence how-tos
-    "how-tos/persistence_postgres.ipynb": "how-tos/persistence.ipynb#use-in-production",
-    "how-tos/persistence_mongodb.ipynb": "how-tos/persistence.ipynb#use-in-production",
-    "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",
+    "how-tos/persistence_postgres.ipynb": "how-tos/memory/add-memory.md#use-in-production",
+    "how-tos/persistence_mongodb.ipynb": "how-tos/memory/add-memory.md#use-in-production",
+    "how-tos/persistence_redis.ipynb": "how-tos/memory/add-memory.md#use-in-production",
+    "how-tos/subgraph-persistence.ipynb": "how-tos/memory/add-memory.md#use-with-subgraphs",
+    "how-tos/cross-thread-persistence.ipynb": "how-tos/memory/add-memory.md#add-long-term-memory",
+    "cloud/how-tos/copy_threads": "cloud/how-tos/use_threads",
+    "cloud/how-tos/check-thread-status": "cloud/how-tos/use_threads",
+    "cloud/concepts/threads.md": "concepts/persistence.md#threads",
+    "how-tos/persistence.ipynb": "how-tos/memory/add-memory.md",
     # 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 +84,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",
@@ -76,16 +92,17 @@ REDIRECT_MAP = {
     "cloud/how-tos/stream_events.md": "cloud/how-tos/streaming.md#stream-events",
     "cloud/how-tos/stream_debug.md": "cloud/how-tos/streaming.md#debug",
     "cloud/how-tos/stream_multiple.md": "cloud/how-tos/streaming.md#stream-multiple-modes",
-    # prebuit redirects
+    "cloud/concepts/streaming.md": "concepts/streaming.md",
+    "agents/streaming.md": "how-tos/streaming.md",
+    # prebuilt redirects
     "how-tos/create-react-agent.ipynb": "agents/agents.md#basic-configuration",
     "how-tos/create-react-agent-memory.ipynb": "agents/memory.md",
     "how-tos/create-react-agent-system-prompt.ipynb": "agents/context.md#prompts",
-    "how-tos/create-react-agent-hitl.ipynb": "agents/human-in-the-loop.md",
     "how-tos/create-react-agent-structured-output.ipynb": "agents/agents.md#structured-output",
     # Time-travel
-    "how-tos/human_in_the_loop/edit-graph-state.ipynb": "how-tos/human_in_the_loop/time-travel.ipynb",
+    "how-tos/human_in_the_loop/edit-graph-state.ipynb": "how-tos/human_in_the_loop/time-travel.md",
     # breakpoints
-    "how-tos/human_in_the_loop/dynamic_breakpoints.ipynb": "how-tos/human_in_the_loop/breakpoints.ipynb",
+    "how-tos/human_in_the_loop/dynamic_breakpoints.ipynb": "how-tos/human_in_the_loop/breakpoints.md",
     # misc
     "prebuilt.md": "agents/prebuilt.md",
     "reference/prebuilt.md": "reference/agents.md",
@@ -97,9 +114,15 @@ REDIRECT_MAP = {
     # deployment redirects
     "how-tos/deploy-self-hosted.md": "cloud/deployment/self_hosted_data_plane.md",
     "concepts/self_hosted.md": "concepts/langgraph_self_hosted_data_plane.md",
+    "tutorials/deployment.md": "concepts/deployment_options.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",
+    "cloud/concepts/runs.md": "concepts/assistants.md#execution",
+    # hitl redirects
+    "how-tos/wait-user-input-functional.ipynb": "how-tos/use-functional-api.md",
+    "how-tos/review-tool-calls-functional.ipynb": "how-tos/use-functional-api.md",
+    "how-tos/create-react-agent-hitl.ipynb": "how-tos/human_in_the_loop/add-human-in-the-loop.md",
+    "agents/human-in-the-loop.md": "how-tos/human_in_the_loop/add-human-in-the-loop.md",
 }
 
 
@@ -149,6 +172,62 @@ def _add_path_to_code_blocks(markdown: str, page: Page) -> str:
     return code_block_pattern.sub(replace_code_block_header, markdown)
 
 
+def _resolve_cross_references(md_text: str, link_map: dict[str, str]) -> str:
+    """Replace [title][identifier] with [title](url) using language-specific link_map.
+
+    Args:
+        md_text: The markdown text to process.
+        link_map: mapping of identifier to URL.
+
+    Returns:
+        The processed markdown text with cross-references resolved.
+    """
+    # Pattern to match [title][identifier]
+    pattern = re.compile(r"\[([^\]]+)\]\[([^\]]+)\]")
+
+    def replace_reference(match: re.Match) -> str:
+        """Replace the matched reference with the corresponding URL."""
+        title, identifier = match.group(1), match.group(2)
+        url = link_map.get(identifier)
+
+        if url:
+            return f"[{title}]({url})"
+        else:
+            # Leave it unchanged if not found
+            return match.group(0)
+
+    return pattern.sub(replace_reference, md_text)
+
+
+def _apply_conditional_rendering(md_text: str, target_language: str) -> str:
+    if target_language not in {"python", "js"}:
+        raise ValueError("target_language must be 'python' or 'js'")
+
+    pattern = re.compile(
+        r"(?P<indent>[ \t]*):::(?P<language>\w+)\s*\n"
+        r"(?P<content>((?:.*\n)*?))"  # Capture the content inside the block
+        r"(?P=indent):::"  # Match closing with the same indentation
+    )
+
+    def replace_conditional_blocks(match: re.Match) -> str:
+        """Keep active conditionals."""
+        language = match.group("language")
+        content = match.group("content")
+
+        if language not in {"python", "js"}:
+            # If the language is not supported, return the original block
+            return match.group(0)
+
+        if language == target_language:
+            return content
+
+        # If the language does not match, return an empty string
+        return ""
+
+    processed = pattern.sub(replace_conditional_blocks, md_text)
+    return processed
+
+
 def _highlight_code_blocks(markdown: str) -> str:
     """Find code blocks with highlight comments and add hl_lines attribute.
 
@@ -227,6 +306,12 @@ def _highlight_code_blocks(markdown: str) -> str:
     return markdown
 
 
+TARGET_LANGUAGE = os.environ.get("TARGET_LANGUAGE", "python")
+
+if TARGET_LANGUAGE not in {"python", "js"}:
+    raise ValueError(f"TARGET_LANGUAGE must be 'python' or 'js', got {TARGET_LANGUAGE}")
+
+
 def _on_page_markdown_with_config(
     markdown: str,
     page: Page,
@@ -248,6 +333,19 @@ def _on_page_markdown_with_config(
     # Apply highlight comments to code blocks
     markdown = _highlight_code_blocks(markdown)
 
+    # Apply conditional rendering for code blocks
+    markdown = _apply_conditional_rendering(markdown, TARGET_LANGUAGE)
+    if TARGET_LANGUAGE == "js":
+        markdown = _resolve_cross_references(markdown, JS_LINK_MAP)
+    elif TARGET_LANGUAGE == "python":
+        # Via a dedicated plugin
+        pass
+    else:
+        raise ValueError(
+            f"Unsupported target language: {TARGET_LANGUAGE}. "
+            "Supported languages are 'python' and 'js'."
+        )
+
     # Add file path as an attribute to code blocks that are executable.
     # This file path is used to associate fixtures with the executable code
     # which can be used in CI to test the docs without making network requests.
@@ -289,7 +387,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 +403,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 +465,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)

docs/_scripts/third_party_page/create_third_party_page.py

@@ -15,9 +15,10 @@ If you’re looking for other prebuilt libraries, explore the community-built op
 below. These libraries can extend LangGraph's functionality in various ways.
 
 ## 📚 Available Libraries
-
 [//]: # (This file is automatically generated using a script in docs/_scripts. Do not edit this file directly!)
-{library_list}
+
+:::python
+{python_library_list}
 
 ## ✨ Contributing Your Library
 
@@ -28,16 +29,39 @@ To share your project, simply open a Pull Request adding an entry for your packa
 
 **Guidelines**
 
-- Your repo must be distributed as an installable package (e.g., PyPI for Python, npm 
-  for JavaScript/TypeScript, etc.) 📦
+- Your repo must be distributed as an installable package on PyPI 📦
 - The repo should either use the Graph API (exposing a `StateGraph` instance) or 
   the Functional API (exposing an `entrypoint`).
 - The package must include documentation (e.g., a `README.md` or docs site) 
   explaining how to use it.
-  
+
 We'll review your contribution and merge it in!
 
 Thanks for contributing! 🚀
+:::
+
+:::js
+{js_library_list}
+
+## ✨ Contributing Your Library
+
+Have you built an awesome open-source library using LangGraph? We'd love to feature 
+your project on the official LangGraph documentation pages! 🏆
+
+To share your project, simply open a Pull Request adding an entry for your package in our [packages.yml]({langgraph_url}) file.
+
+**Guidelines**
+
+- Your repo must be distributed as an installable package on npm 📦
+- The repo should either use the Graph API (exposing a `StateGraph` instance) or 
+  the Functional API (exposing an `entrypoint`).
+- The package must include documentation (e.g., a `README.md` or docs site) 
+  explaining how to use it.
+
+We'll review your contribution and merge it in!
+
+Thanks for contributing! 🚀
+:::
 """
 
 
@@ -46,36 +70,18 @@ class ResolvedPackage(TypedDict):
     """The name of the package."""
     repo: str
     """Repository ID within github. Format is: [orgname]/[repo_name]."""
+    monorepo_path: str | None
+    """Optional: The path to the package in the monorepo. Must be relative to the root of the monorepo."""
+    language: str
+    """The language of the package. (either 'python' or 'js')"""
     weekly_downloads: int | None
     """The weekly download count of the package."""
     description: str
     """A brief description of what the package does."""
 
-
-def generate_markdown(resolved_packages: List[ResolvedPackage], language: str) -> str:
-    """Generate the markdown content for the third party page.
-
-    Args:
-        resolved_packages: A list of resolved package information.
-        language: str
-
-    Returns:
-        The markdown content as a string.
+def generate_package_table(resolved_packages: List[ResolvedPackage]) -> str:
+    """Generate the package table for the third party page.
     """
-    # Update the URL to the actual file once the initial version is merged
-    if language == "python":
-        langgraph_url = (
-            "https://github.com/langchain-ai/langgraph/blob/main/docs"
-            "/_scripts/third_party_page/packages.yml"
-        )
-    elif language == "js":
-        langgraph_url = (
-            "https://github.com/langchain-ai/langgraphjs/blob/main/docs"
-            "/_scripts/third_party/packages.yml"
-        )
-    else:
-        raise ValueError(f"Invalid language '{language}'. Expected 'python' or 'js'.")
-
     sorted_packages = sorted(
         resolved_packages, key=lambda p: p["weekly_downloads"] or 0, reverse=True
     )
@@ -85,7 +91,15 @@ def generate_markdown(resolved_packages: List[ResolvedPackage], language: str) -
     ]
     for package in sorted_packages:
         name = f"**{package['name']}**"
-        repo_url = f"[{package['repo']}](https://github.com/{package['repo']})"
+        
+        monorepo_path = package.get("monorepo_path", "")
+        if monorepo_path:
+            monorepo_path = monorepo_path[1:] if monorepo_path.startswith('/') else monorepo_path
+            repo_url_suffix = f"/tree/main/{monorepo_path}"
+        else:
+            repo_url_suffix = ""
+        repo_url = f"https://github.com/{package['repo']}{repo_url_suffix}"
+
         stars_badge = (
             f"https://img.shields.io/github/stars/{package['repo']}?style=social"
         )
@@ -93,13 +107,39 @@ def generate_markdown(resolved_packages: List[ResolvedPackage], language: str) -
         downloads = package["weekly_downloads"] or "-"
         row = f"| {name} | {repo_url} | {package['description']} | {downloads} | {stars}"
         rows.append(row)
+    return "\n".join(rows)
+
+def generate_markdown(resolved_packages: List[ResolvedPackage]) -> str:
+    """Generate the markdown content for the third party page.
+
+    Args:
+        resolved_packages: A list of resolved package information.
+
+    Returns:
+        The markdown content as a string.
+    """
+    # Update the URL to the actual file once the initial version is merged
+    langgraph_url = (
+        "https://github.com/langchain-ai/langgraph/blob/main/docs"
+        "/_scripts/third_party_page/packages.yml"
+    )
+
+    python_library_list = generate_package_table(
+        [p for p in resolved_packages if p["language"] == "python"]
+    )
+    js_library_list = generate_package_table(
+        [p for p in resolved_packages if p["language"] == "js"]
+    )
+    
     markdown_content = MARKDOWN.format(
-        library_list="\n".join(rows), langgraph_url=langgraph_url
+        python_library_list=python_library_list,
+        js_library_list=js_library_list,
+        langgraph_url=langgraph_url,
     )
     return markdown_content
 
 
-def main(input_file: str, output_file: str, language: str) -> None:
+def main(input_file: str, output_file: str) -> None:
     """Main function to create the third party page.
 
     Args:
@@ -111,7 +151,7 @@ def main(input_file: str, output_file: str, language: str) -> None:
     with open(input_file, "r") as f:
         resolved_packages: List[ResolvedPackage] = yaml.safe_load(f)
 
-    markdown_content = generate_markdown(resolved_packages, language)
+    markdown_content = generate_markdown(resolved_packages)
 
     # Write the markdown content to the output file
     with open(output_file, "w", encoding="utf-8") as f:
@@ -127,12 +167,6 @@ if __name__ == "__main__":
     parser.add_argument(
         "output_file", help="Path to the output file for the third party page."
     )
-    parser.add_argument(
-        "--language",
-        choices=["python", "js"],
-        default="python",
-        help="The language for which to generate the third party page. Defaults to 'python'.",
-    )
     args = parser.parse_args()
 
-    main(args.input_file, args.output_file, args.language)
+    main(args.input_file, args.output_file)

docs/_scripts/third_party_page/get_download_stats.py

@@ -11,101 +11,146 @@ import yaml
 
 
 class Package(TypedDict):
-    """A TypedDict representing a package"""
-
     name: str
     """The name of the package."""
     repo: str
     """Repository ID within github. Format is: [orgname]/[repo_name]."""
+    monorepo_path: str | None
+    """The path to the package in the monorepo. Only used for JS packages."""
     description: str
     """A brief description of what the package does."""
 
-
 class ResolvedPackage(Package):
     weekly_downloads: int | None
-
+    """The weekly download count of the package."""
+    language: str
+    """The language of the package. (either 'python' or 'js')"""
 
 HERE = pathlib.Path(__file__).parent
 PACKAGES_FILE = HERE / "packages.yml"
-PACKAGES = yaml.safe_load(PACKAGES_FILE.read_text())['packages']
+PACKAGES = yaml.safe_load(PACKAGES_FILE.read_text())["packages"]
 
+def _get_pypi_downloads(package: Package) -> int:
+    """Retrieve the weekly download count for a package from PyPIStats."""
 
-def _get_weekly_downloads(packages: list[Package], fake: bool) -> list[ResolvedPackage]:
-    """Retrieve the monthly download count for a list of packages from PyPIStats."""
+    # First check if package exists on PyPI
+    pypi_url = f"https://pypi.org/pypi/{package['name']}/json"
+    try:
+        pypi_response = requests.get(pypi_url)
+        pypi_response.raise_for_status()
+    except requests.exceptions.HTTPError:
+        raise AssertionError(f"Package {package['name']} does not exist on PyPI")
+
+    # Get first release date
+    pypi_data = pypi_response.json()
+    releases = pypi_data["releases"]
+    first_release_date = None
+    for version_releases in releases.values():
+        if version_releases:  # Some versions may be empty lists
+            upload_time = datetime.fromisoformat(version_releases[0]["upload_time"])
+            if first_release_date is None or upload_time < first_release_date:
+                first_release_date = upload_time
+
+    if first_release_date is None:
+        raise AssertionError(f"Package {package['name']} has no releases yet")
+
+    # If package was published in last 48 hours, skip download stats
+    if (datetime.now() - first_release_date).total_seconds() >= 48 * 3600:
+        url = f"https://pypistats.org/api/packages/{package['name']}/overall"
+
+        response = requests.get(url)
+        response.raise_for_status()
+        data = response.json()
+
+        sorted_data = sorted(
+            data["data"],
+            key=lambda x: datetime.strptime(x["date"], "%Y-%m-%d"),
+            reverse=True,
+        )
+
+        # Sum the last 7 days of downloads
+        return sum(entry["downloads"] for entry in sorted_data[:7])
+    else:
+        return None
+    
+def _get_npm_downloads(package: Package) -> int:
+    """Retrieve the weekly download count for a package on the npm registry."""
+
+    # Check if package exists on the npm registry
+    npm_url = f"https://registry.npmjs.org/{package['name']}"
+    try:
+        npm_response = requests.get(npm_url)
+        npm_response.raise_for_status()
+    except requests.exceptions.HTTPError:
+        raise AssertionError(f"Package {package['name']} does not exist on npm registry")
+
+    npm_data = npm_response.json()
+
+    # Retrieve the first publish date using the 'created' timestamp from the 'time' field.
+    created_str = npm_data.get("time", {}).get("created")
+    if created_str is None:
+        raise AssertionError(f"Package {package['name']} has no creation time in registry data")
+    # Remove the trailing 'Z' if present and parse the ISO format timestamp
+    first_publish_date = datetime.fromisoformat(created_str.rstrip("Z"))
+
+    # If package was published more than 48 hours ago, fetch download stats.
+    if (datetime.now() - first_publish_date).total_seconds() >= 48 * 3600:
+        stats_url = f"https://api.npmjs.org/downloads/point/last-week/{package['name']}"
+        stats_response = requests.get(stats_url)
+        stats_response.raise_for_status()
+        stats_data = stats_response.json()
+        return stats_data.get("downloads", None)
+    else:
+        return None
+
+def _get_weekly_downloads(packages: dict[str, list[Package]], fake: bool) -> list[ResolvedPackage]:
+    """Retrieve the weekly download count for a dictionary of python or js packages."""
     resolved_packages: list[ResolvedPackage] = []
 
     if fake:
         # To avoid making network requests during testing, return fake download counts
-        for package in packages:
+        for language, package_list in packages.items():
+            for package in package_list:
+                resolved_packages.append(
+                    {
+                        "name": package["name"],
+                        "repo": package["repo"],
+                        "monorepo_path": package.get("monorepo_path", None),
+                        "language": language,
+                        "description": package["description"],
+                        "weekly_downloads": -12345,
+                    }
+                )
+        return resolved_packages
+
+    for language, package_list in packages.items():
+        for package in package_list:
+            if language == "python":
+                num_downloads = _get_pypi_downloads(package)
+            elif language == "js":
+                num_downloads = _get_npm_downloads(package)
+            else:
+                num_downloads = None
+            
             resolved_packages.append(
                 {
                     "name": package["name"],
                     "repo": package["repo"],
-                    "weekly_downloads": -12345,
+                    "monorepo_path": package.get("monorepo_path", None),
+                    "language": language,
                     "description": package["description"],
+                    "weekly_downloads": num_downloads,
                 }
             )
-        return resolved_packages
-
-    for package in packages:
-        # First check if package exists on PyPI
-        pypi_url = f"https://pypi.org/pypi/{package['name']}/json"
-        try:
-            pypi_response = requests.get(pypi_url)
-            pypi_response.raise_for_status()
-        except requests.exceptions.HTTPError:
-            raise AssertionError(f"Package {package['name']} does not exist on PyPI")
-
-        # Get first release date
-        pypi_data = pypi_response.json()
-        releases = pypi_data["releases"]
-        first_release_date = None
-        for version_releases in releases.values():
-            if version_releases:  # Some versions may be empty lists
-                upload_time = datetime.fromisoformat(version_releases[0]["upload_time"])
-                if first_release_date is None or upload_time < first_release_date:
-                    first_release_date = upload_time
-
-        if first_release_date is None:
-            raise AssertionError(f"Package {package['name']} has no releases yet")
-
-        # If package was published in last 48 hours, skip download stats
-        if (datetime.now() - first_release_date).total_seconds() >= 48 * 3600:
-            url = f"https://pypistats.org/api/packages/{package['name']}/overall"
-
-            response = requests.get(url)
-            response.raise_for_status()
-            data = response.json()
-
-            sorted_data = sorted(
-                data["data"],
-                key=lambda x: datetime.strptime(x["date"], "%Y-%m-%d"),
-                reverse=True,
-            )
-
-            # Sum the last 7 days of downloads
-            num_downloads = sum(entry["downloads"] for entry in sorted_data[:7])
-        else:
-            num_downloads = None
-
-        resolved_packages.append(
-            {
-                "name": package["name"],
-                "repo": package["repo"],
-                "weekly_downloads": num_downloads,
-                "description": package["description"],
-            }
-        )
 
     return resolved_packages
 
-
-
 def main(output_file: str, fake: bool) -> None:
     """Main function to generate package download information.
 
     Args:
         output_file: Path to the output YAML file.
+        fake: If True, use fake download counts for testing purposes.
     """
     resolved_packages: list[ResolvedPackage] = _get_weekly_downloads(PACKAGES, fake)
 

docs/_scripts/third_party_page/packages.yml

@@ -1,41 +1,58 @@
 #A list of third-party packages to surface on the third-party page.
 packages:
-  - name: "trustcall"
-    repo: "hinthornw/trustcall"
-    description: "Tenacious tool calling built on LangGraph."
-  - name: "breeze-agent"
-    repo: "andrestorres123/breeze-agent"
-    description: "A streamlined research system built inspired on STORM and built on LangGraph."
-  - name: "langgraph-supervisor"
-    repo: "langchain-ai/langgraph-supervisor-py"
-    description: "Build supervisor multi-agent systems with LangGraph."
-  - name: "langmem"
-    repo: "langchain-ai/langmem"
-    description: "Build agents that learn and adapt from interactions over time."
-  - name: "langchain-mcp-adapters"
-    repo: "langchain-ai/langchain-mcp-adapters"
-    description: "Make Anthropic Model Context Protocol (MCP) tools compatible with LangGraph agents."
-  - name: "open-deep-research"
-    repo: "langchain-ai/open_deep_research"
-    description: "Open source assistant for iterative web research and report writing."
-  - name: "langgraph-swarm"
-    repo: "langchain-ai/langgraph-swarm-py"
-    description: "Build swarm-style multi-agent systems using LangGraph."
-  - name: "delve-taxonomy-generator"
-    repo: "andrestorres123/delve"
-    description: "A taxonomy generator for unstructured data"
-  - name: "nodeology"
-    repo: "xyin-anl/Nodeology"
-    description: "Enable researcher to build scientific workflows easily with simplified interface."
-  - name: "langgraph-bigtool"
-    repo: "langchain-ai/langgraph-bigtool"
-    description: "Build LangGraph agents with large numbers of tools."
-  - name: "ai-data-science-team"
-    repo: "business-science/ai-data-science-team"
-    description: "An AI-powered data science team of agents to help you perform common data science tasks 10X faster."
-  - name: "langgraph-reflection"
-    repo: "langchain-ai/langgraph-reflection"
-    description: "LangGraph agent that runs a reflection step."
-  - name: "langgraph-codeact"
-    repo: "langchain-ai/langgraph-codeact"
-    description: "LangGraph implementation of CodeAct agent that generates and executes code instead of tool calling."
+  python:
+    - name: "trustcall"
+      repo: "hinthornw/trustcall"
+      description: "Tenacious tool calling built on LangGraph."
+    - name: "breeze-agent"
+      repo: "andrestorres123/breeze-agent"
+      description: "A streamlined research system built inspired on STORM and built on LangGraph."
+    - name: "langgraph-supervisor"
+      repo: "langchain-ai/langgraph-supervisor-py"
+      description: "Build supervisor multi-agent systems with LangGraph."
+    - name: "langmem"
+      repo: "langchain-ai/langmem"
+      description: "Build agents that learn and adapt from interactions over time."
+    - name: "langchain-mcp-adapters"
+      repo: "langchain-ai/langchain-mcp-adapters"
+      description: "Make Anthropic Model Context Protocol (MCP) tools compatible with LangGraph agents."
+    - name: "open-deep-research"
+      repo: "langchain-ai/open_deep_research"
+      description: "Open source assistant for iterative web research and report writing."
+    - name: "langgraph-swarm"
+      repo: "langchain-ai/langgraph-swarm-py"
+      description: "Build swarm-style multi-agent systems using LangGraph."
+    - name: "delve-taxonomy-generator"
+      repo: "andrestorres123/delve"
+      description: "A taxonomy generator for unstructured data"
+    - name: "nodeology"
+      repo: "xyin-anl/Nodeology"
+      description: "Enable researcher to build scientific workflows easily with simplified interface."
+    - name: "langgraph-bigtool"
+      repo: "langchain-ai/langgraph-bigtool"
+      description: "Build LangGraph agents with large numbers of tools."
+    - name: "ai-data-science-team"
+      repo: "business-science/ai-data-science-team"
+      description: "An AI-powered data science team of agents to help you perform common data science tasks 10X faster."
+    - name: "langgraph-reflection"
+      repo: "langchain-ai/langgraph-reflection"
+      description: "LangGraph agent that runs a reflection step."
+    - name: "langgraph-codeact"
+      repo: "langchain-ai/langgraph-codeact"
+      description: "LangGraph implementation of CodeAct agent that generates and executes code instead of tool calling."
+  js:
+    - name: "@langchain/mcp-adapters"
+      repo: "langchain-ai/langchainjs"
+      description: "Make Anthropic Model Context Protocol (MCP) tools compatible with LangGraph agents."
+    - name: "@langchain/langgraph-supervisor"
+      repo: "langchain-ai/langgraphjs"
+      monorepo_path: "libs/langgraph-supervisor"
+      description: "Build supervisor multi-agent systems with LangGraph"
+    - name: "@langchain/langgraph-swarm"
+      repo: "langchain-ai/langgraphjs"
+      monorepo_path: "libs/langgraph-swarm"
+      description: "Build multi-agent swarms with LangGraph"
+    - name: "@langchain/langgraph-cua"
+      repo: "langchain-ai/langgraphjs"
+      monorepo_path: "libs/langgraph-cua"
+      description: "Build computer use agents with LangGraph"

docs/cross-refs.txt

@@ -0,0 +1,101 @@
+[`add_conditional_edges`][langgraph.graph.StateGraph.add_conditional_edges]
+[add_conditional_edges][langgraph.graph.StateGraph.add_conditional_edges]
+[`add_edge`][langgraph.graph.StateGraph.add_edge]
+[add_edge][langgraph.graph.StateGraph.add_edge]
+[`add_messages`][langgraph.graph.message.add_messages]
+[add_node][langgraph.graph.StateGraph.add_node]
+[API reference][langgraph.prebuilt.tool_node.ToolNode]
+[API reference][toolnode]
+[`astream()`][langgraph.graph.state.CompiledStateGraph.astream]
+[`.astream()`][langgraph.pregel.Pregel.astream]
+[AsyncPostgresSaver][langgraph.checkpoint.postgres.aio.AsyncPostgresSaver]
+[AsyncSqliteSaver][langgraph.checkpoint.sqlite.aio.AsyncSqliteSaver]
+[BaseCheckpointSaver][<insert-ref>]
+[BaseCheckpointSaver][langgraph.checkpoint.base.BaseCheckpointSaver]
+[BaseStore][langgraph.store.base.BaseStore]
+[BaseStore.put][<insert-ref>]
+[BaseStore.put][langgraph.store.base.BaseStore.put]
+[BinaryOperatorAggregate][<insert-ref>]
+[BinaryOperatorAggregate][langgraph.channels.BinaryOperatorAggregate]
+[`CipherProtocol`][langgraph.checkpoint.serde.base.CipherProtocol]
+[`client.runs.stream`][langgraph_sdk.client.RunsClient.stream]
+[`client.runs.wait`][langgraph_sdk.client.RunsClient.wait]
+[`client.threads.get_history`][langgraph_sdk.client.ThreadsClient.get_history]
+[`client.threads.update_state`][langgraph_sdk.client.ThreadsClient.update_state]
+[`Command`][<insert-ref>]
+[`Command`][langgraph.types.Command]
+[Command][langgraph.types.Command]
+[CompiledStateGraph][langgraph.graph.state.CompiledStateGraph]
+[`createReactAgent`][<insert-ref>]
+[`create_react_agent`][langgraph.prebuilt.chat_agent_executor.create_react_agent]
+[create_react_agent][langgraph.prebuilt.chat_agent_executor.create_react_agent]
+[`create_supervisor`][langgraph_supervisor.supervisor.create_supervisor]
+[`EncryptedSerializer`][langgraph.checkpoint.serde.encrypted.EncryptedSerializer]
+[`entrypoint.final`][langgraph.func.entrypoint.final]
+[`entrypoint`][<insert-ref>]
+[entrypoint][<insert-ref>]
+[`@entrypoint`][langgraph.func.entrypoint]
+[`entrypoint`][langgraph.func.entrypoint]
+[entrypoint()][langgraph.func.entrypoint]
+[entrypoint][langgraph.func.entrypoint]
+[finalResult['values']['messages']
+[`from_pycryptodome_aes`][langgraph.checkpoint.serde.encrypted.EncryptedSerializer.from_pycryptodome_aes]
+[`getContextVariable`][<insert-ref>]
+[`getStateHistory()`][<insert-ref>]
+[`get_state_history()`][langgraph.graph.state.CompiledStateGraph.get_state_history]
+[get_stream_writer][langgraph.config.get_stream_writer]
+[`HumanInterrupt`][langgraph.prebuilt.interrupt.HumanInterrupt]
+[`HumanInterrupt` schema][langgraph.prebuilt.interrupt.HumanInterrupt]
+[HumanMessage(content=state[\"messages\"][-2]
+[`InjectedState`][langgraph.prebuilt.InjectedState]
+[InjectedState][langgraph.prebuilt.InjectedState]
+[InMemorySaver][langgraph.checkpoint.memory.InMemorySaver]
+[`interrupt` function][<insert-ref>]
+[`interrupt` function][langgraph.types.interrupt]
+[`interrupt()`][langgraph.types.interrupt]
+[`interrupt`][langgraph.types.interrupt]
+[interrupt][langgraph.types.interrupt]
+[`invoke`][<insert-ref>]
+[`invoke`][langgraph.graph.state.CompiledStateGraph.invoke]
+[`JsonPlusSerializer`][langgraph.checkpoint.serde.jsonplus.JsonPlusSerializer]
+[JsonPlusSerializer][langgraph.checkpoint.serde.jsonplus.JsonPlusSerializer]
+[langgraph.json CLI reference][configuration-file]
+[LastValue][<insert-ref>]
+[LastValue][langgraph.channels.LastValue]
+[MemorySaver][<insert-ref>]
+[`messagesStateReducer`][<insert-ref>]
+[PostgresSaver][<insert-ref>]
+[PostgresSaver][langgraph.checkpoint.postgres.PostgresSaver]
+[Pregel][<insert-ref>]
+[Pregel][langgraph.pregel.Pregel]
+[`Pregel`][langgraph.pregel.Pregel.stream]
+[`pre_model_hook`][langgraph.prebuilt.chat_agent_executor.create_react_agent]
+[protocol][langgraph.checkpoint.serde.base.SerializerProtocol]
+[`Send()`][langgraph.types.Send]
+[`Send`][langgraph.types.Send]
+[SerializerProtocol][<insert-ref>]
+[SerializerProtocol][langgraph.checkpoint.serde.base.SerializerProtocol]
+[SqliteSaver][<insert-ref>]
+[SqliteSaver][langgraph.checkpoint.sqlite.SqliteSaver]
+[`START`][langgraph.constants.START]
+[StateGraph (Graph API)][<insert-ref>]
+[StateGraph (Graph API)][langgraph.graph.StateGraph]
+[StateGraph (Graph API)][langgraph.graph.state.StateGraph]
+[StateGraph][<insert-ref>]
+[StateGraph][langgraph.graph.StateGraph]
+[`.stream()`][<insert-ref>]
+[`stream()`][<insert-ref>]
+[`stream`][<insert-ref>]
+[`stream()`][langgraph.graph.state.CompiledStateGraph.stream]
+[`stream`][langgraph.graph.state.CompiledStateGraph.stream]
+[`.stream()`][langgraph.pregel.Pregel.stream]
+[tasks][<insert-ref>]
+[tasks][langgraph.func.task]
+[`ToolNode`][<insert-ref>]
+[`ToolNode`][langgraph.prebuilt.tool_node.ToolNode]
+[ToolNode][langgraph.prebuilt.tool_node.ToolNode]
+[Topic][<insert-ref>]
+[Topic][langgraph.channels.Topic]
+[`updateState`][<insert-ref>]
+[`update_state`][langgraph.graph.state.CompiledStateGraph.update_state]
+['values']['messages']

docs/docs/agents/agents.md

@@ -15,22 +15,39 @@ 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
 
 If you haven't already, install LangGraph and LangChain:
 
+:::python
+
 ```
 pip install -U langgraph "langchain[anthropic]"
 ```
 
-!!! info 
+!!! info
 
     LangChain is installed so the agent can call the [model](https://python.langchain.com/docs/integrations/chat/).
 
+:::
+
+:::js
+
+```bash
+npm install @langchain/langgraph @langchain/core @langchain/anthropic
+```
+
+!!! info
+
+    LangChain is installed so the agent can call the [model](https://js.langchain.com/docs/integrations/chat/).
+
+:::
+
 ## 2. Create an agent
 
+:::python
 To create an agent, use [`create_react_agent`][langgraph.prebuilt.chat_agent_executor.create_react_agent]:
 
 ```python
@@ -56,9 +73,52 @@ agent.invoke(
 2. Provide a language model for the agent to use. To learn more about configuring language models for the agents, check the [models](./models.md) page.
 3. Provide a list of tools for the model to use.
 4. Provide a system prompt (instructions) to the language model used by the agent.
+   :::
+
+:::js
+To create an agent, use [`createReactAgent`](https://langchain-ai.github.io/langgraphjs/reference/functions/langgraph_prebuilt.createReactAgent.html):
+
+```typescript
+import { ChatAnthropic } from "@langchain/anthropic";
+import { createReactAgent } from "@langchain/langgraph/prebuilt";
+import { tool } from "@langchain/core/tools";
+import { z } from "zod";
+
+const getWeather = tool(
+  // (1)!
+  async ({ city }) => {
+    return `It's always sunny in ${city}!`;
+  },
+  {
+    name: "get_weather",
+    description: "Get weather for a given city.",
+    schema: z.object({
+      city: z.string().describe("The city to get weather for"),
+    }),
+  }
+);
+
+const agent = createReactAgent({
+  llm: new ChatAnthropic({ model: "anthropic:claude-3-5-sonnet-latest" }), // (2)!
+  tools: [getWeather], // (3)!
+  stateModifier: "You are a helpful assistant", // (4)!
+});
+
+// Run the agent
+await agent.invoke({
+  messages: [{ role: "user", content: "what is the weather in sf" }],
+});
+```
+
+1. Define a tool for the agent to use. Tools can be defined using the `tool` function. For more advanced tool usage and customization, check the [tools](./tools.md) page.
+2. Provide a language model for the agent to use. To learn more about configuring language models for the agents, check the [models](./models.md) page.
+3. Provide a list of tools for the model to use.
+4. Provide a system prompt (instructions) to the language model used by the agent.
+   :::
 
 ## 3. Configure an LLM
 
+:::python
 To configure an LLM with specific parameters, such as temperature, use [init_chat_model](https://python.langchain.com/api_reference/langchain/chat_models/langchain.chat_models.base.init_chat_model.html):
 
 ```python
@@ -79,19 +139,45 @@ agent = create_react_agent(
 )
 ```
 
+:::
+
+:::js
+To configure an LLM with specific parameters, such as temperature, use a model instance:
+
+```typescript
+import { ChatAnthropic } from "@langchain/anthropic";
+import { createReactAgent } from "@langchain/langgraph/prebuilt";
+
+// highlight-next-line
+const model = new ChatAnthropic({
+  model: "claude-3-5-sonnet-latest",
+  // highlight-next-line
+  temperature: 0,
+});
+
+const agent = createReactAgent({
+  // highlight-next-line
+  llm: model,
+  tools: [getWeather],
+});
+```
+
+:::
+
 For more information on how to configure LLMs, see [Models](./models.md).
 
 ## 4. Add a custom prompt
 
 Prompts instruct the LLM how to behave. Add one of the following types of prompts:
 
-* **Static**: A string is interpreted as a **system message**.
-* **Dynamic**: A list of messages generated at **runtime**, based on input or configuration.
+- **Static**: A string is interpreted as a **system message**.
+- **Dynamic**: A list of messages generated at **runtime**, based on input or configuration.
 
 === "Static prompt"
 
     Define a fixed prompt string or list of messages:
 
+    :::python
     ```python
     from langgraph.prebuilt import create_react_agent
 
@@ -107,9 +193,30 @@ Prompts instruct the LLM how to behave. Add one of the following types of prompt
         {"messages": [{"role": "user", "content": "what is the weather in sf"}]}
     )
     ```
+    :::
+
+    :::js
+    ```typescript
+    import { createReactAgent } from "@langchain/langgraph/prebuilt";
+    import { ChatAnthropic } from "@langchain/anthropic";
+
+    const agent = createReactAgent({
+      llm: new ChatAnthropic({ model: "anthropic:claude-3-5-sonnet-latest" }),
+      tools: [getWeather],
+      // A static prompt that never changes
+      // highlight-next-line
+      stateModifier: "Never answer questions about the weather."
+    });
+
+    await agent.invoke({
+      messages: [{ role: "user", content: "what is the weather in sf" }]
+    });
+    ```
+    :::
 
 === "Dynamic prompt"
 
+    :::python
     Define a function that returns a message list based on the agent's state and configuration:
 
     ```python
@@ -144,12 +251,52 @@ Prompts instruct the LLM how to behave. Add one of the following types of prompt
         - Internal agent state updated during a multi-step reasoning process (using `state`).
 
         Dynamic prompts can be defined as functions that take `state` and `config` and return a list of messages to send to the LLM.
+    :::
+
+    :::js
+    Define a function that returns messages based on the agent's state and configuration:
+
+    ```typescript
+    import { type BaseMessageLike } from "@langchain/core/messages";
+    import { type RunnableConfig } from "@langchain/core/runnables";
+    import { createReactAgent } from "@langchain/langgraph/prebuilt";
+
+    // highlight-next-line
+    const dynamicPrompt = (state: { messages: BaseMessageLike[] }, config: RunnableConfig): BaseMessageLike[] => {  // (1)!
+      const userName = config.configurable?.user_name;
+      const systemMsg = `You are a helpful assistant. Address the user as ${userName}.`;
+      return [{ role: "system", content: systemMsg }, ...state.messages];
+    };
+
+    const agent = createReactAgent({
+      llm: "anthropic:claude-3-5-sonnet-latest",
+      tools: [getWeather],
+      // highlight-next-line
+      stateModifier: dynamicPrompt
+    });
+
+    await agent.invoke(
+      { messages: [{ role: "user", content: "what is the weather in sf" }] },
+      // highlight-next-line
+      { configurable: { user_name: "John Smith" } }
+    );
+    ```
+
+    1. Dynamic prompts allow including non-message [context](./context.md) when constructing an input to the LLM, such as:
+
+        - Information passed at runtime, like a `user_id` or API credentials (using `config`).
+        - Internal agent state updated during a multi-step reasoning process (using `state`).
+
+        Dynamic prompts can be defined as functions that take `state` and `config` and return a list of messages to send to the LLM.
+    :::
 
 For more information, see [Context](./context.md).
 
 ## 5. Add memory
 
-To allow multi-turn conversations with an agent, you need to enable [persistence](../concepts/persistence.md) by providing a `checkpointer` when creating an agent. At runtime, you need to provide a config containing `thread_id` — a unique identifier for the conversation (session):
+To allow multi-turn conversations with an agent, you need to enable [persistence](../concepts/persistence.md) by providing a checkpointer when creating an agent. At runtime, you need to provide a config containing `thread_id` — a unique identifier for the conversation (session):
+
+:::python
 
 ```python
 from langgraph.prebuilt import create_react_agent
@@ -180,17 +327,60 @@ ny_response = agent.invoke(
 )
 ```
 
-1. `checkpointer` allows the agent to store its state at every step in the tool calling loop. This enables [short-term memory](./memory.md#short-term-memory) and [human-in-the-loop](./human-in-the-loop.md) capabilities.
+1. `checkpointer` allows the agent to store its state at every step in the tool calling loop. This enables [short-term memory](../how-tos/memory/add-memory.md#add-short-term-memory) and [human-in-the-loop](../concepts/human_in_the_loop.md) capabilities.
 2. Pass configuration with `thread_id` to be able to resume the same conversation on future agent invocations.
+   :::
 
+:::js
+
+```typescript
+import { createReactAgent } from "@langchain/langgraph/prebuilt";
+import { MemorySaver } from "@langchain/langgraph";
+
+// highlight-next-line
+const checkpointer = new MemorySaver();
+
+const agent = createReactAgent({
+  llm: "anthropic:claude-3-5-sonnet-latest",
+  tools: [getWeather],
+  // highlight-next-line
+  checkpointSaver: checkpointer, // (1)!
+});
+
+// Run the agent
+// highlight-next-line
+const config = { configurable: { thread_id: "1" } };
+const sfResponse = await agent.invoke(
+  { messages: [{ role: "user", content: "what is the weather in sf" }] },
+  // highlight-next-line
+  config // (2)!
+);
+const nyResponse = await agent.invoke(
+  { messages: [{ role: "user", content: "what about new york?" }] },
+  // highlight-next-line
+  config
+);
+```
+
+1. `checkpointSaver` allows the agent to store its state at every step in the tool calling loop. This enables [short-term memory](../how-tos/memory/add-memory.md#add-short-term-memory) and [human-in-the-loop](../concepts/human_in_the_loop.md) capabilities.
+2. Pass configuration with `thread_id` to be able to resume the same conversation on future agent invocations.
+   :::
+
+:::python
 When you enable the checkpointer, it stores agent state at every step in the provided checkpointer database (or in memory, if using `InMemorySaver`).
+:::
+
+:::js
+When you enable the checkpointer, it stores agent state at every step in the provided checkpointer database (or in memory, if using `MemorySaver`).
+:::
 
 Note that in the above example, when the agent is invoked the second time with the same `thread_id`, the original message history from the first conversation is automatically included, together with the new user input.
 
-For more information, see [Memory](./memory.md).
+For more information, see [Memory](../how-tos/memory/add-memory.md).
 
 ## 6. Configure structured output
 
+:::python
 To produce structured responses conforming to a schema, use the `response_format` parameter. The schema can be defined with a `Pydantic` model or `TypedDict`. The result will be accessible via the `structured_response` field.
 
 ```python
@@ -215,9 +405,43 @@ response = agent.invoke(
 response["structured_response"]
 ```
 
-1. When `response_format` is provided, a separate step is added at the end of the agent loop: agent message history is passed to an LLM with structured output to generate a structured response.
+1.  When `response_format` is provided, a separate step is added at the end of the agent loop: agent message history is passed to an LLM with structured output to generate a structured response.
 
-    To provide a system prompt to this LLM, use a tuple `(prompt, schema)`, e.g., `response_format=(prompt, WeatherResponse)`.
+        To provide a system prompt to this LLM, use a tuple `(prompt, schema)`, e.g., `response_format=(prompt, WeatherResponse)`.
+
+    :::
+
+:::js
+To produce structured responses conforming to a schema, use the `responseFormat` parameter. The schema can be defined with a `Zod` schema. The result will be accessible via the `structuredResponse` field.
+
+```typescript
+import { z } from "zod";
+import { createReactAgent } from "@langchain/langgraph/prebuilt";
+
+const WeatherResponse = z.object({
+  conditions: z.string(),
+});
+
+const agent = createReactAgent({
+  llm: "anthropic:claude-3-5-sonnet-latest",
+  tools: [getWeather],
+  // highlight-next-line
+  responseFormat: WeatherResponse, // (1)!
+});
+
+const response = await agent.invoke({
+  messages: [{ role: "user", content: "what is the weather in sf" }],
+});
+
+// highlight-next-line
+response.structuredResponse;
+```
+
+1.  When `responseFormat` is provided, a separate step is added at the end of the agent loop: agent message history is passed to an LLM with structured output to generate a structured response.
+
+        To provide a system prompt to this LLM, use an object `{ prompt, schema }`, e.g., `responseFormat: { prompt, schema: WeatherResponse }`.
+
+    :::
 
 !!! Note "LLM post-processing"
 

docs/docs/agents/context.md

@@ -1,17 +1,8 @@
----
-search:
-  boost: 2
-tags:
-  - agent
-hide:
-  - tags
----
-
 # Context
 
-Agents often require more than a list of messages to function effectively. They need **context**.
+**Context engineering** is the practice of building dynamic systems that provide the right information and tools, in the right format, so that a language model can plausibly accomplish a task.
 
-Context includes *any* data outside the message list that can shape agent behavior or tool execution. This can be:
+Context includes _any_ data outside the message list that can shape behavior. This can be:
 
 - Information passed at runtime, like a `user_id` or API credentials.
 - Internal state updated during a multi-step reasoning process.
@@ -20,20 +11,12 @@ Context includes *any* data outside the message list that can shape agent behavi
 LangGraph provides **three** primary ways to supply context:
 
 | Type                                                                         | Description                                   | Mutable? | Lifetime                |
-|------------------------------------------------------------------------------|-----------------------------------------------|----------|-------------------------|
-| [**Config**](#config-static-context)                                         | data passed at the start of a run             | ❌        | per run                 |
-| [**State**](#state-mutable-context)                                          | dynamic data that can change during execution | ✅        | per run or conversation |
-| [**Long-term Memory (Store)**](#long-term-memory-cross-conversation-context) | data that can be shared between conversations | ✅        | across conversations    |
+| ---------------------------------------------------------------------------- | --------------------------------------------- | -------- | ----------------------- |
+| [**Config**](#config-static-context)                                         | data passed at the start of a run             | ❌       | per run                 |
+| [**Short-term memory (State)**](#short-term-memory-mutable-context)          | dynamic data that can change during execution | ✅       | per run or conversation |
+| [**Long-term memory (Store)**](#long-term-memory-cross-conversation-context) | data that can be shared between conversations | ✅       | across conversations    |
 
-You can use context to:
-
-- Adjust the system prompt the model sees
-- Feed tools with necessary inputs
-- Track facts during an ongoing conversation
-
-## Providing Runtime Context
-
-Use this when you need to inject data into an agent at runtime.
+## Provide runtime context
 
 ### Config (static context)
 
@@ -43,105 +26,183 @@ when you have values that don't change mid-run.
 Specify configuration using a key called **"configurable"** which is reserved
 for this purpose:
 
+:::python
+
 ```python
-agent.invoke(
-    {"messages": [{"role": "user", "content": "hi!"}]},
+graph.invoke( # (1)!
+    {"messages": [{"role": "user", "content": "hi!"}]}, # (2)!
     # highlight-next-line
-    config={"configurable": {"user_id": "user_123"}}
+    config={"configurable": {"user_id": "user_123"}} # (3)!
 )
 ```
 
-### State (mutable context)
+:::
 
-State acts as short-term memory during a run. It holds dynamic data that can evolve during execution, such as values derived from tools or LLM outputs.
+:::js
 
-```python
-class CustomState(AgentState):
-    # highlight-next-line
-    user_name: str
-
-agent = create_react_agent(
-    # Other agent parameters...
-    # highlight-next-line
-    state_schema=CustomState,
-)
-
-agent.invoke({
-    "messages": "hi!",
-    "user_name": "Jane"
-})
+```typescript
+await graph.invoke(
+  // (1)!
+  { messages: [{ role: "user", content: "hi!" }] }, // (2)!
+  // highlight-next-line
+  { configurable: { user_id: "user_123" } } // (3)!
+);
 ```
 
-!!! tip "Turning on memory"
+:::
 
-    Please see the [memory guide](./memory.md) for more details on how to enable memory. This is a powerful feature that allows you to persist the agent's state across multiple invocations.
-    Otherwise, the state is scoped only to a single agent run.
+1. This is the invocation of the agent or graph. The `invoke` method runs the underlying graph with the provided input.
+2. This example uses messages as an input, which is common, but your application may use different input structures.
+3. This is where you pass the configuration data. The `config` parameter allows you to provide additional context that the agent can use during its execution.
 
+=== "Agent prompt"
 
-
-### Long-Term Memory (cross-conversation context)
-
-For context that spans *across* conversations or sessions, LangGraph allows access to **long-term memory** via a `store`. This can be used to read or update persistent facts (e.g., user profiles, preferences, prior interactions). For more, see the [Memory guide](./memory.md).
-
-## Customizing Prompts with Context { #prompts }
-
-Prompts define how the agent behaves. To incorporate runtime context, you can dynamically generate prompts based on the agent's state or config.
-
-Common use cases:
-
-- Personalization
-- Role or goal customization
-- Conditional behavior (e.g., user is admin)
-
-=== "Using config"
-
+    :::python
     ```python
     from langchain_core.messages import AnyMessage
     from langchain_core.runnables import RunnableConfig
-    from langgraph.prebuilt import create_react_agent
     from langgraph.prebuilt.chat_agent_executor import AgentState
+    from langgraph.prebuilt import create_react_agent
 
-    def prompt(
-        state: AgentState,
-        # highlight-next-line
-        config: RunnableConfig,
-    ) -> list[AnyMessage]:
-        # highlight-next-line
+    # highlight-next-line
+    def prompt(state: AgentState, config: RunnableConfig) -> list[AnyMessage]:
         user_name = config["configurable"].get("user_name")
-        system_msg = f"You are a helpful assistant. User's name is {user_name}"
+        system_msg = f"You are a helpful assistant. Address the user as {user_name}."
         return [{"role": "system", "content": system_msg}] + state["messages"]
 
     agent = create_react_agent(
         model="anthropic:claude-3-7-sonnet-latest",
         tools=[get_weather],
-        # highlight-next-line
         prompt=prompt
     )
 
     agent.invoke(
-        ...,
+        {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
         # highlight-next-line
         config={"configurable": {"user_name": "John Smith"}}
     )
     ```
+    :::
 
-=== "Using state"
+    :::js
+    ```typescript
+    import type { BaseMessage } from "@langchain/core/messages";
+    import type { RunnableConfig } from "@langchain/core/runnables";
+    import type { AgentState } from "@langchain/langgraph/prebuilt";
+    import { createReactAgent } from "@langchain/langgraph/prebuilt";
 
+    // highlight-next-line
+    const prompt = (state: AgentState, config: RunnableConfig): BaseMessage[] => {
+      const userName = config.configurable?.user_name;
+      const systemMsg = `You are a helpful assistant. Address the user as ${userName}.`;
+      return [{ role: "system", content: systemMsg }, ...state.messages];
+    };
+
+    const agent = createReactAgent({
+      llm: model,
+      tools: [getWeather],
+      prompt,
+    });
+
+    await agent.invoke(
+      { messages: [{ role: "user", content: "what is the weather in sf" }] },
+      // highlight-next-line
+      { configurable: { user_name: "John Smith" } }
+    );
+    ```
+    :::
+
+    * See [Agents](../agents/agents.md) for details.
+
+=== "Workflow node"
+
+    :::python
+    ```python
+    from langchain_core.runnables import RunnableConfig
+
+    # highlight-next-line
+    def node(state: State, config: RunnableConfig):
+        user_name = config["configurable"].get("user_name")
+        ...
+    ```
+    :::
+
+    :::js
+    ```typescript
+    import type { RunnableConfig } from "@langchain/core/runnables";
+
+    // highlight-next-line
+    const node = (state: State, config?: RunnableConfig) => {
+      const userName = config?.configurable?.user_name;
+      // ...
+    };
+    ```
+    :::
+
+    * See [the Graph API](https://langchain-ai.github.io/langgraph/how-tos/graph-api/#add-runtime-configuration) for details.
+
+=== "In a tool"
+
+    :::python
+    ```python
+    from langchain_core.runnables import RunnableConfig
+
+    @tool
+    # highlight-next-line
+    def get_user_info(config: RunnableConfig) -> str:
+        """Retrieve user information based on user ID."""
+        user_id = config["configurable"].get("user_id")
+        return "User is John Smith" if user_id == "user_123" else "Unknown user"
+    ```
+    :::
+
+    :::js
+    ```typescript
+    import type { RunnableConfig } from "@langchain/core/runnables";
+    import { tool } from "@langchain/core/tools";
+    import { z } from "zod";
+
+    // highlight-next-line
+    const getUserInfo = tool(
+      async (_, config: RunnableConfig): Promise<string> => {
+        const userId = config.configurable?.user_id;
+        return userId === "user_123" ? "User is John Smith" : "Unknown user";
+      },
+      {
+        name: "get_user_info",
+        description: "Retrieve user information based on user ID."
+      }
+    );
+    ```
+    :::
+
+    See the [tool calling guide](../how-tos/tool-calling.md#configuration) for details.
+
+### Short-term memory (mutable context)
+
+State acts as [short-term memory](../concepts/memory.md) during a run. It holds dynamic data that can evolve during execution, such as values derived from tools or LLM outputs.
+
+=== "In an agent"
+
+    Example shows how to incorporate state into an agent **prompt**.
+
+    State can also be accessed by the agent's **tools**, which can read or update the state as needed. See [tool calling guide](../how-tos/tool-calling.md#short-term-memory) for details.
+
+    :::python
     ```python
     from langchain_core.messages import AnyMessage
     from langchain_core.runnables import RunnableConfig
     from langgraph.prebuilt import create_react_agent
     from langgraph.prebuilt.chat_agent_executor import AgentState
 
-    class CustomState(AgentState):
-        # highlight-next-line
+    # highlight-next-line
+    class CustomState(AgentState): # (1)!
         user_name: str
 
     def prompt(
         # highlight-next-line
         state: CustomState
     ) -> list[AnyMessage]:
-        # highlight-next-line
         user_name = state["user_name"]
         system_msg = f"You are a helpful assistant. User's name is {user_name}"
         return [{"role": "system", "content": system_msg}] + state["messages"]
@@ -150,87 +211,130 @@ Common use cases:
         model="anthropic:claude-3-7-sonnet-latest",
         tools=[...],
         # highlight-next-line
-        state_schema=CustomState,
-        # highlight-next-line
+        state_schema=CustomState, # (2)!
         prompt=prompt
     )
 
     agent.invoke({
         "messages": "hi!",
-        # highlight-next-line
         "user_name": "John Smith"
     })
     ```
 
-## Accessing Context in Tools { #tools }
+    1. Define a custom state schema that extends `AgentState` or `MessagesState`.
+    2. Pass the custom state schema to the agent. This allows the agent to access and modify the state during execution.
+    :::
 
-Tools can access context through special parameter **annotations**.
+    :::js
+    ```typescript
+    import type { BaseMessage } from "@langchain/core/messages";
+    import { createReactAgent } from "@langchain/langgraph/prebuilt";
+    import { MessagesZodState } from "@langchain/langgraph";
+    import { z } from "zod";
 
-* Use `RunnableConfig` for config access
-* Use `Annotated[StateSchema, InjectedState]` for agent state
+    // highlight-next-line
+    const CustomState = z.object({ // (1)!
+      messages: MessagesZodState.shape.messages,
+      userName: z.string(),
+    });
 
+    const prompt = (
+      // highlight-next-line
+      state: z.infer<typeof CustomState>
+    ): BaseMessage[] => {
+      const userName = state.userName;
+      const systemMsg = `You are a helpful assistant. User's name is ${userName}`;
+      return [{ role: "system", content: systemMsg }, ...state.messages];
+    };
 
-!!! tip 
+    const agent = createReactAgent({
+      llm: model,
+      tools: [...],
+      // highlight-next-line
+      stateSchema: CustomState, // (2)!
+      stateModifier: prompt,
+    });
 
-    These annotations prevent LLMs from attempting to fill in the values. These parameters will be **hidden** from the LLM.
-
-=== "Using config"
-
-    ```python
-    def get_user_info(
-        # highlight-next-line
-        config: RunnableConfig,
-    ) -> str:
-        """Look up user info."""
-        # highlight-next-line
-        user_id = config["configurable"].get("user_id")
-        return "User is John Smith" if user_id == "user_123" else "Unknown user"
-
-    agent = create_react_agent(
-        model="anthropic:claude-3-7-sonnet-latest",
-        tools=[get_user_info],
-    )
-
-    agent.invoke(
-        {"messages": [{"role": "user", "content": "look up user information"}]},
-        # highlight-next-line
-        config={"configurable": {"user_id": "user_123"}}
-    )
+    await agent.invoke({
+      messages: [{ role: "user", content: "hi!" }],
+      userName: "John Smith",
+    });
     ```
 
-=== "Using State"
+    1. Define a custom state schema that extends `MessagesZodState` or creates a new schema.
+    2. Pass the custom state schema to the agent. This allows the agent to access and modify the state during execution.
+    :::
 
+=== "In a workflow"
+
+    :::python
     ```python
-    from typing import Annotated
-    from langgraph.prebuilt import InjectedState
+    from typing_extensions import TypedDict
+    from langchain_core.messages import AnyMessage
+    from langgraph.graph import StateGraph
 
-    class CustomState(AgentState):
-        # highlight-next-line
-        user_id: str
+    # highlight-next-line
+    class CustomState(TypedDict): # (1)!
+        messages: list[AnyMessage]
+        extra_field: int
 
-    def get_user_info(
-        # highlight-next-line
-        state: Annotated[CustomState, InjectedState]
-    ) -> str:
-        """Look up user info."""
-        # highlight-next-line
-        user_id = state["user_id"]
-        return "User is John Smith" if user_id == "user_123" else "Unknown user"
+    # highlight-next-line
+    def node(state: CustomState): # (2)!
+        messages = state["messages"]
+        ...
+        return { # (3)!
+            # highlight-next-line
+            "extra_field": state["extra_field"] + 1
+        }
 
-    agent = create_react_agent(
-        model="anthropic:claude-3-7-sonnet-latest",
-        tools=[get_user_info],
-        # highlight-next-line
-        state_schema=CustomState,
-    )
-
-    agent.invoke({
-        "messages": "look up user information",
-        # highlight-next-line
-        "user_id": "user_123"
-    })
+    builder = StateGraph(State)
+    builder.add_node(node)
+    builder.set_entry_point("node")
+    graph = builder.compile()
     ```
 
-### Update Context from Tools
+    1. Define a custom state
+    2. Access the state in any node or tool
+    3. The Graph API is designed to work as easily as possible with state. The return value of a node represents a requested update to the state.
+    :::
 
-Tools can update agent's context (state and long-term memory) during execution. This is useful for persisting intermediate results or making information accessible to subsequent tools or prompts. See [Memory](./memory.md#read-short-term) guide for more information.
+    :::js
+    ```typescript
+    import type { BaseMessage } from "@langchain/core/messages";
+    import { StateGraph, MessagesZodState, START } from "@langchain/langgraph";
+    import { z } from "zod";
+
+    // highlight-next-line
+    const CustomState = z.object({ // (1)!
+      messages: MessagesZodState.shape.messages,
+      extraField: z.number(),
+    });
+
+    const builder = new StateGraph(CustomState)
+      .addNode("node", async (state) => { // (2)!
+        const messages = state.messages;
+        // ...
+        return { // (3)!
+          // highlight-next-line
+          extraField: state.extraField + 1,
+        };
+      })
+      .addEdge(START, "node");
+
+    const graph = builder.compile();
+    ```
+
+    1. Define a custom state
+    2. Access the state in any node or tool
+    3. The Graph API is designed to work as easily as possible with state. The return value of a node represents a requested update to the state.
+    :::
+
+!!! tip "Turning on memory"
+
+    Please see the [memory guide](../how-tos/memory/add-memory.md) for more details on how to enable memory. This is a powerful feature that allows you to persist the agent's state across multiple invocations. Otherwise, the state is scoped only to a single run.
+
+### Long-term memory (cross-conversation context)
+
+For context that spans _across_ conversations or sessions, LangGraph allows access to **long-term memory** via a `store`. This can be used to read or update persistent facts (e.g., user profiles, preferences, prior interactions).
+
+For more information, see the [Memory guide](../how-tos/memory/add-memory.md).

docs/docs/agents/deployment.md

@@ -11,19 +11,21 @@ hide:
 
 To deploy your LangGraph agent, create and configure a LangGraph app. This setup supports both local development and production deployments.
 
-Features: 
+Features:
 
-* 🖥️ Local server for development
-* 🧩 Studio Web UI for visual debugging
-* ☁️ Cloud and 🔧 self-hosted deployment options
-* 📊 LangSmith integration for tracing and observability
+- 🖥️ Local server for development
+- 🧩 Studio Web UI for visual debugging
+- ☁️ Cloud and 🔧 self-hosted deployment options
+- 📊 LangSmith integration for tracing and observability
 
-!!! info "Requirements" 
+!!! info "Requirements"
 
     - ✅ You **must** have a [LangSmith account](https://www.langchain.com/langsmith). You can sign up for **free** and get started with the free tier.
 
 ## Create a LangGraph app
 
+:::python
+
 ```bash
 pip install -U "langgraph-cli[inmem]"
 langgraph new path/to/your/app --template new-langgraph-project-python
@@ -45,6 +47,46 @@ graph = create_react_agent(
 )
 ```
 
+:::
+
+:::js
+
+```bash
+npm install -g @langchain/langgraph-cli
+langgraph new path/to/your/app --template new-langgraph-project-js
+```
+
+This will create an empty LangGraph project. You can modify it by replacing the code in `src/agent/graph.ts` with your agent code. For example:
+
+```typescript
+import { createReactAgent } from "@langchain/langgraph/prebuilt";
+import { tool } from "@langchain/core/tools";
+import { z } from "zod";
+
+const getWeather = tool(
+  (input) => {
+    return `It's always sunny in ${input.city}!`;
+  },
+  {
+    name: "get_weather",
+    description: "Get weather for a given city.",
+    schema: z.object({
+      city: z.string().describe("The city to get weather for"),
+    }),
+  }
+);
+
+export const graph = createReactAgent({
+  llm: "anthropic:claude-3-5-sonnet-latest",
+  tools: [getWeather],
+  stateModifier: "You are a helpful assistant",
+});
+```
+
+:::
+
+:::python
+
 ### Install dependencies
 
 In the root of your new LangGraph app, install the dependencies in `edit` mode so your local changes are used by the server:
@@ -53,6 +95,8 @@ In the root of your new LangGraph app, install the dependencies in `edit` mode s
 pip install -e .
 ```
 
+:::
+
 ### Create an `.env` file
 
 You will find a `.env.example` in the root of your new LangGraph app. Create
@@ -71,13 +115,13 @@ langgraph dev
 
 This will start up the LangGraph API server locally. If this runs successfully, you should see something like:
 
->    Ready!
-> 
->    - API: [http://localhost:2024](http://localhost:2024/)
->     
->    - Docs: http://localhost:2024/docs
->     
->    - LangGraph Studio Web UI: https://smith.langchain.com/studio/?baseUrl=http://127.0.0.1:2024
+> Ready!
+>
+> - API: [http://localhost:2024](http://localhost:2024/)
+>
+> - Docs: http://localhost:2024/docs
+>
+> - LangGraph Studio Web UI: https://smith.langchain.com/studio/?baseUrl=http://127.0.0.1:2024
 
 See this [tutorial](https://langchain-ai.github.io/langgraph/tutorials/langgraph-platform/local-server/) to learn more about running LangGraph app locally.
 
@@ -85,8 +129,8 @@ See this [tutorial](https://langchain-ai.github.io/langgraph/tutorials/langgraph
 
 LangGraph Studio Web is a specialized UI that you can connect to LangGraph API server to enable visualization, interaction, and debugging of your application locally. Test your graph in the LangGraph Studio Web UI by visiting the URL provided in the output of the `langgraph dev` command.
 
->    - LangGraph Studio Web UI: https://smith.langchain.com/studio/?baseUrl=http://127.0.0.1:2024
+> - LangGraph Studio Web UI: https://smith.langchain.com/studio/?baseUrl=http://127.0.0.1:2024
 
 ## Deployment
 
-Once your LangGraph app is running locally, you can deploy it using LangGraph Platform. Refer to the [deployment options guide](../tutorials/deployment.md) for detailed instructions on all supported deployment models.
+Once your LangGraph app is running locally, you can deploy it using LangGraph Platform. Refer to the [deployment options guide](../concepts/deployment_options.md) for detailed instructions on all supported deployment models.

docs/docs/agents/evals.md

@@ -11,6 +11,8 @@ hide:
 
 To evaluate your agent's performance you can use `LangSmith` [evaluations](https://docs.smith.langchain.com/evaluation). You would need to first define an evaluator function to judge the results from an agent, such as final outputs or trajectory. Depending on your evaluation technique, this may or may not involve a reference output:
 
+:::python
+
 ```python
 def evaluator(*, outputs: dict, reference_outputs: dict):
     # compare agent outputs against reference outputs
@@ -20,16 +22,51 @@ def evaluator(*, outputs: dict, reference_outputs: dict):
     return {"key": "evaluator_score", "score": score}
 ```
 
+:::
+
+:::js
+
+```typescript
+type EvaluatorParams = {
+  outputs: Record<string, any>;
+  referenceOutputs: Record<string, any>;
+};
+
+function evaluator({ outputs, referenceOutputs }: EvaluatorParams) {
+  // compare agent outputs against reference outputs
+  const outputMessages = outputs.messages;
+  const referenceMessages = referenceOutputs.messages;
+  const score = compareMessages(outputMessages, referenceMessages);
+  return { key: "evaluator_score", score: score };
+}
+```
+
+:::
+
 To get started, you can use prebuilt evaluators from `AgentEvals` package:
 
+:::python
+
 ```bash
 pip install -U agentevals
 ```
 
+:::
+
+:::js
+
+```bash
+npm install agentevals
+```
+
+:::
+
 ## Create evaluator
 
 A common way to evaluate agent performance is by comparing its trajectory (the order in which it calls its tools) against a reference trajectory:
 
+:::python
+
 ```python
 import json
 # highlight-next-line
@@ -80,8 +117,63 @@ result = evaluator(
 )
 ```
 
-1. Specify how the trajectories will be compared. `superset` will accept output trajectory as valid if it's a superset of the reference one. Other options include: [strict](https://github.com/langchain-ai/agentevals?tab=readme-ov-file#strict-match), [unordered](https://github.com/langchain-ai/agentevals?tab=readme-ov-file#unordered-match) and [subset](https://github.com/langchain-ai/agentevals?tab=readme-ov-file#subset-and-superset-match)
+:::
 
+:::js
+
+```typescript
+import { createTrajectoryMatchEvaluator } from "agentevals/trajectory/match";
+
+const outputs = [
+  {
+    role: "assistant",
+    tool_calls: [
+      {
+        function: {
+          name: "get_weather",
+          arguments: JSON.stringify({ city: "san francisco" }),
+        },
+      },
+      {
+        function: {
+          name: "get_directions",
+          arguments: JSON.stringify({ destination: "presidio" }),
+        },
+      },
+    ],
+  },
+];
+
+const referenceOutputs = [
+  {
+    role: "assistant",
+    tool_calls: [
+      {
+        function: {
+          name: "get_weather",
+          arguments: JSON.stringify({ city: "san francisco" }),
+        },
+      },
+    ],
+  },
+];
+
+// Create the evaluator
+const evaluator = createTrajectoryMatchEvaluator({
+  // Specify how the trajectories will be compared. `superset` will accept output trajectory as valid if it's a superset of the reference one. Other options include: strict, unordered and subset
+  trajectoryMatchMode: "superset", // (1)!
+});
+
+// Run the evaluator
+const result = evaluator({
+  outputs: outputs,
+  referenceOutputs: referenceOutputs,
+});
+```
+
+:::
+
+1. Specify how the trajectories will be compared. `superset` will accept output trajectory as valid if it's a superset of the reference one. Other options include: [strict](https://github.com/langchain-ai/agentevals?tab=readme-ov-file#strict-match), [unordered](https://github.com/langchain-ai/agentevals?tab=readme-ov-file#unordered-match) and [subset](https://github.com/langchain-ai/agentevals?tab=readme-ov-file#subset-and-superset-match)
 
 As a next step, learn more about how to [customize trajectory match evaluator](https://github.com/langchain-ai/agentevals?tab=readme-ov-file#agent-trajectory-match).
 
@@ -89,6 +181,8 @@ As a next step, learn more about how to [customize trajectory match evaluator](h
 
 You can use LLM-as-a-judge evaluator that uses an LLM to compare the trajectory against the reference outputs and output a score:
 
+:::python
+
 ```python
 import json
 from agentevals.trajectory.llm import (
@@ -103,6 +197,24 @@ evaluator = create_trajectory_llm_as_judge(
 )
 ```
 
+:::
+
+:::js
+
+```typescript
+import {
+  createTrajectoryLlmAsJudge,
+  TRAJECTORY_ACCURACY_PROMPT_WITH_REFERENCE,
+} from "agentevals/trajectory/llm";
+
+const evaluator = createTrajectoryLlmAsJudge({
+  prompt: TRAJECTORY_ACCURACY_PROMPT_WITH_REFERENCE,
+  model: "openai:o3-mini",
+});
+```
+
+:::
+
 ## Run evaluator
 
 To run an evaluator, you will first need to create a [LangSmith dataset](https://docs.smith.langchain.com/evaluation/concepts#datasets). To use the prebuilt AgentEvals evaluators, you will need a dataset with the following schema:
@@ -110,6 +222,8 @@ To run an evaluator, you will first need to create a [LangSmith dataset](https:/
 - **input**: `{"messages": [...]}` input messages to call the agent with.
 - **output**: `{"messages": [...]}` expected message history in the agent output. For trajectory evaluation, you can choose to keep only assistant messages.
 
+:::python
+
 ```python
 from langsmith import Client
 from langgraph.prebuilt import create_react_agent
@@ -125,4 +239,27 @@ experiment_results = client.evaluate(
     data="<Name of your dataset>",
     evaluators=[evaluator]
 )
-```
+```
+
+:::
+
+:::js
+
+```typescript
+import { Client } from "langsmith";
+import { createReactAgent } from "@langchain/langgraph/prebuilt";
+import { createTrajectoryMatchEvaluator } from "agentevals/trajectory/match";
+
+const client = new Client();
+const agent = createReactAgent({...});
+const evaluator = createTrajectoryMatchEvaluator({...});
+
+const experimentResults = await client.evaluate(
+    (inputs) => agent.invoke(inputs),
+    // replace with your dataset name
+    { data: "<Name of your dataset>" },
+    { evaluators: [evaluator] }
+);
+```
+
+:::

docs/docs/agents/human-in-the-loop.md

@@ -1,238 +0,0 @@
----
-search:
-  boost: 2
-tags:
-  - human-in-the-loop
-  - hil
-  - agent
-hide:
-  - tags
----
-
-# Human-in-the-loop
-
-To review, edit and approve tool calls in an agent you can use LangGraph's built-in [Human-In-the-Loop (HIL)](../concepts/human_in_the_loop.md) features, specifically the [`interrupt()`][langgraph.types.interrupt] primitive.
-
-LangGraph allows you to pause execution **indefinitely** — for minutes, hours, or even days—until human input is received.
-
-This is possible because the agent state is **checkpointed into a database**, which allows the system to persist execution context and later resume the workflow, continuing from where it left off.
-
-For a deeper dive into the **human-in-the-loop** concept, see the [concept guide](../concepts/human_in_the_loop.md).
-
-<figure markdown="1">
-![image](../concepts/img/human_in_the_loop/tool-call-review.png){: style="max-height:400px"}
-<figcaption>
-A human can review and edit the output from the agent before proceeding. This is particularly critical in applications where the tool calls requested may be sensitive or require human oversight.
-</figcaption>
-</figure>
-
-
-## Review tool calls
-
-To add a human approval step to a tool:
-
-1. Use `interrupt()` in the tool to pause execution.
-2. Resume with a `Command(resume=...)` to continue based on human input.
-
-```python
-from langgraph.checkpoint.memory import InMemorySaver
-from langgraph.types import interrupt
-from langgraph.prebuilt import create_react_agent
-
-# An example of a sensitive tool that requires human review / approval
-def book_hotel(hotel_name: str):
-    """Book a hotel"""
-    # highlight-next-line
-    response = interrupt(  # (1)!
-        f"Trying to call `book_hotel` with args {{'hotel_name': {hotel_name}}}. "
-        "Please approve or suggest edits."
-    )
-    if response["type"] == "accept":
-        pass
-    elif response["type"] == "edit":
-        hotel_name = response["args"]["hotel_name"]
-    else:
-        raise ValueError(f"Unknown response type: {response['type']}")
-    return f"Successfully booked a stay at {hotel_name}."
-
-# highlight-next-line
-checkpointer = InMemorySaver() # (2)!
-
-agent = create_react_agent(
-    model="anthropic:claude-3-5-sonnet-latest",
-    tools=[book_hotel],
-    # highlight-next-line
-    checkpointer=checkpointer, # (3)!
-)
-```
-
-1. The [`interrupt` function][langgraph.types.interrupt] pauses the agent graph at a specific node. In this case, we call `interrupt()` at the beginning of the tool function, which pauses the graph at the node that executes the tool. The information inside `interrupt()` (e.g., tool calls) can be presented to a human, and the graph can be resumed with the user input (tool call approval, edit or feedback).
-2. The `InMemorySaver` is used to store the agent state at every step in the tool calling loop. This enables [short-term memory](./memory.md#short-term-memory) and [human-in-the-loop](./human-in-the-loop.md) capabilities. In this example, we use `InMemorySaver` to store the agent state in memory. In a production application, the agent state will be stored in a database.
-3. Initialize the agent with the `checkpointer`.
-
-Run the agent with the `stream()` method, passing the `config` object to specify the thread ID. This allows the agent to resume the same conversation on future invocations.
-
-```python
-config = {
-   "configurable": {
-      # highlight-next-line
-      "thread_id": "1"
-   }
-}
-
-for chunk in agent.stream(
-    {"messages": [{"role": "user", "content": "book a stay at McKittrick hotel"}]},
-    # highlight-next-line
-    config
-):
-    print(chunk)
-    print("\n")
-```
-
-> You should see that the agent runs until it reaches the `interrupt()` call, at which point it pauses and waits for human input.
-
-Resume the agent with a `Command(resume=...)` to continue based on human input.
-
-```python
-from langgraph.types import Command
-
-for chunk in agent.stream(
-    # highlight-next-line
-    Command(resume={"type": "accept"}),  # (1)!
-    # Command(resume={"type": "edit", "args": {"hotel_name": "McKittrick Hotel"}}),
-    config
-):
-    print(chunk)
-    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.
-
-## Using with Agent Inbox
-
-You can create a wrapper to add interrupts to *any* tool. 
-
-The example below provides a reference implementation compatible with [Agent Inbox UI](https://github.com/langchain-ai/agent-inbox) and [Agent Chat UI](https://github.com/langchain-ai/agent-chat-ui).
-
-```python title="Wrapper that adds human-in-the-loop to any tool"
-from typing import Callable
-from langchain_core.tools import BaseTool, tool as create_tool
-from langchain_core.runnables import RunnableConfig
-from langgraph.types import interrupt 
-from langgraph.prebuilt.interrupt import HumanInterruptConfig, HumanInterrupt
-
-def add_human_in_the_loop(
-    tool: Callable | BaseTool,
-    *,
-    interrupt_config: HumanInterruptConfig = None,
-) -> BaseTool:
-    """Wrap a tool to support human-in-the-loop review.""" 
-    if not isinstance(tool, BaseTool):
-        tool = create_tool(tool)
-
-    if interrupt_config is None:
-        interrupt_config = {
-            "allow_accept": True,
-            "allow_edit": True,
-            "allow_respond": True,
-        }
-
-    @create_tool(  # (1)!
-        tool.name,
-        description=tool.description,
-        args_schema=tool.args_schema
-    )
-    def call_tool_with_interrupt(config: RunnableConfig, **tool_input):
-        request: HumanInterrupt = {
-            "action_request": {
-                "action": tool.name,
-                "args": tool_input
-            },
-            "config": interrupt_config,
-            "description": "Please review the tool call"
-        }
-        # highlight-next-line
-        response = interrupt([request])[0]  # (2)!
-        # approve the tool call
-        if response["type"] == "accept":
-            tool_response = tool.invoke(tool_input, config)
-        # update tool call args
-        elif response["type"] == "edit":
-            tool_input = response["args"]["args"]
-            tool_response = tool.invoke(tool_input, config)
-        # respond to the LLM with user feedback
-        elif response["type"] == "response":
-            user_feedback = response["args"]
-            tool_response = user_feedback
-        else:
-            raise ValueError(f"Unsupported interrupt response type: {response['type']}")
-
-        return tool_response
-
-    return call_tool_with_interrupt
-```
-
-1. This wrapper creates a new tool that calls `interrupt()` **before** executing the wrapped tool.
-2. `interrupt()` is using special input and output format that's expected by [Agent Inbox UI](https://github.com/langchain-ai/agent-inbox):
-    - a list of [`HumanInterrupt`][langgraph.prebuilt.interrupt.HumanInterrupt] objects is sent to `AgentInbox` render interrupt information to the end user
-    - resume value is provided by `AgentInbox` as a list (i.e., `Command(resume=[...])`)
-
-You can use the `add_human_in_the_loop` wrapper to add `interrupt()` to any tool without having to add it *inside* the tool:
-
-```python
-from langgraph.checkpoint.memory import InMemorySaver
-from langgraph.prebuilt import create_react_agent
-
-# highlight-next-line
-checkpointer = InMemorySaver()
-
-def book_hotel(hotel_name: str):
-   """Book a hotel"""
-   return f"Successfully booked a stay at {hotel_name}."
-
-
-agent = create_react_agent(
-    model="anthropic:claude-3-5-sonnet-latest",
-    tools=[
-        # highlight-next-line
-        add_human_in_the_loop(book_hotel), # (1)!
-    ],
-    # highlight-next-line
-    checkpointer=checkpointer,
-)
-
-config = {"configurable": {"thread_id": "1"}}
-
-# Run the agent
-for chunk in agent.stream(
-    {"messages": [{"role": "user", "content": "book a stay at McKittrick hotel"}]},
-    # highlight-next-line
-    config
-):
-    print(chunk)
-    print("\n")
-```
-
-1. The `add_human_in_the_loop` wrapper is used to add `interrupt()` to the tool. This allows the agent to pause execution and wait for human input before proceeding with the tool call.
-
-> You should see that the agent runs until it reaches the `interrupt()` call, 
->  at which point it pauses and waits for human input.
-
-Resume the agent with a `Command(resume=...)`  to continue based on human input.
-
-```python
-from langgraph.types import Command 
-
-for chunk in agent.stream(
-    # highlight-next-line
-    Command(resume=[{"type": "accept"}]),
-    # Command(resume=[{"type": "edit", "args": {"args": {"hotel_name": "McKittrick Hotel"}}}]),
-    config
-):
-    print(chunk)
-    print("\n")
-```
-
-## Additional resources
-
-* [Human-in-the-loop in LangGraph](../concepts/human_in_the_loop.md)

docs/docs/agents/mcp.md

@@ -7,47 +7,64 @@ hide:
   - tags
 ---
 
-# MCP Integration
+# Use MCP
 
 [Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction) is an open protocol that standardizes how applications provide tools and context to language models. LangGraph agents can use tools defined on MCP servers through the `langchain-mcp-adapters` library.
 
 ![MCP](./assets/mcp.png)
 
+:::python
 Install the `langchain-mcp-adapters` library to use MCP tools in LangGraph:
 
 ```bash
 pip install langchain-mcp-adapters
 ```
 
+:::
+
+:::js
+Install the `@langchain/mcp-adapters` library to use MCP tools in LangGraph:
+
+```bash
+npm install langchain-mcp-adapters
+```
+
+:::
+
 ## Use MCP tools
 
+:::python
 The `langchain-mcp-adapters` package enables agents to use tools defined across one or more MCP servers.
 
-```python title="Agent using tools defined on MCP servers"
-# highlight-next-line
-from langchain_mcp_adapters.client import MultiServerMCPClient
-from langgraph.prebuilt import create_react_agent
+=== "In an agent"
 
-# highlight-next-line
-async with MultiServerMCPClient(
-    {
-        "math": {
-            "command": "python",
-            # Replace with absolute path to your math_server.py file
-            "args": ["/path/to/math_server.py"],
-            "transport": "stdio",
-        },
-        "weather": {
-            # Ensure your start your weather server on port 8000
-            "url": "http://localhost:8000/sse",
-            "transport": "sse",
+    ```python title="Agent using tools defined on MCP servers"
+    # highlight-next-line
+    from langchain_mcp_adapters.client import MultiServerMCPClient
+    from langgraph.prebuilt import create_react_agent
+
+    # highlight-next-line
+    client = MultiServerMCPClient(
+        {
+            "math": {
+                "command": "python",
+                # Replace with absolute path to your math_server.py file
+                "args": ["/path/to/math_server.py"],
+                "transport": "stdio",
+            },
+            "weather": {
+                # Ensure you start your weather server on port 8000
+                "url": "http://localhost:8000/mcp",
+                "transport": "streamable_http",
+            }
         }
-    }
-) as client:
+    )
+    # highlight-next-line
+    tools = await client.get_tools()
     agent = create_react_agent(
         "anthropic:claude-3-7-sonnet-latest",
         # highlight-next-line
-        client.get_tools()
+        tools
     )
     math_response = await agent.ainvoke(
         {"messages": [{"role": "user", "content": "what's (3 + 5) x 12?"}]}
@@ -55,10 +72,158 @@ async with MultiServerMCPClient(
     weather_response = await agent.ainvoke(
         {"messages": [{"role": "user", "content": "what is the weather in nyc?"}]}
     )
-```
+    ```
+
+=== "In a workflow"
+
+    ```python
+    from langchain_mcp_adapters.client import MultiServerMCPClient
+    from langgraph.graph import StateGraph, MessagesState, START
+    from langgraph.prebuilt import ToolNode, tools_condition
+
+    from langchain.chat_models import init_chat_model
+    model = init_chat_model("openai:gpt-4.1")
+
+    client = MultiServerMCPClient(
+        {
+            "math": {
+                "command": "python",
+                # Make sure to update to the full absolute path to your math_server.py file
+                "args": ["./examples/math_server.py"],
+                "transport": "stdio",
+            },
+            "weather": {
+                # make sure you start your weather server on port 8000
+                "url": "http://localhost:8000/mcp/",
+                "transport": "streamable_http",
+            }
+        }
+    )
+    tools = await client.get_tools()
+
+    def call_model(state: MessagesState):
+        response = model.bind_tools(tools).invoke(state["messages"])
+        return {"messages": response}
+
+    builder = StateGraph(MessagesState)
+    builder.add_node(call_model)
+    builder.add_node(ToolNode(tools))
+    builder.add_edge(START, "call_model")
+    builder.add_conditional_edges(
+        "call_model",
+        tools_condition,
+    )
+    builder.add_edge("tools", "call_model")
+    graph = builder.compile()
+    math_response = await graph.ainvoke({"messages": "what's (3 + 5) x 12?"})
+    weather_response = await graph.ainvoke({"messages": "what is the weather in nyc?"})
+    ```
+
+:::
+
+:::js
+The `@langchain/mcp-adapters` package enables agents to use tools defined across one or more MCP servers.
+
+=== "In an agent"
+
+    ```typescript title="Agent using tools defined on MCP servers"
+    // highlight-next-line
+    import { MultiServerMCPClient } from "langchain-mcp-adapters/client";
+    import { ChatAnthropic } from "@langchain/langgraph/prebuilt";
+    import { createReactAgent } from "@langchain/langgraph/prebuilt";
+
+    // highlight-next-line
+    const client = new MultiServerMCPClient({
+      math: {
+        command: "node",
+        // Replace with absolute path to your math_server.js file
+        args: ["/path/to/math_server.js"],
+        transport: "stdio",
+      },
+      weather: {
+        // Ensure you start your weather server on port 8000
+        url: "http://localhost:8000/mcp",
+        transport: "streamable_http",
+      },
+    });
+
+    // highlight-next-line
+    const tools = await client.getTools();
+    const agent = createReactAgent({
+      llm: new ChatAnthropic({ model: "claude-3-7-sonnet-latest" }),
+      // highlight-next-line
+      tools,
+    });
+
+    const mathResponse = await agent.invoke({
+      messages: [{ role: "user", content: "what's (3 + 5) x 12?" }],
+    });
+
+    const weatherResponse = await agent.invoke({
+      messages: [{ role: "user", content: "what is the weather in nyc?" }],
+    });
+    ```
+
+=== "In a workflow"
+
+    ```typescript
+    import { MultiServerMCPClient } from "langchain-mcp-adapters/client";
+    import { StateGraph, MessagesZodState, START } from "@langchain/langgraph";
+    import { ToolNode } from "@langchain/langgraph/prebuilt";
+    import { ChatOpenAI } from "@langchain/openai";
+    import { AIMessage } from "@langchain/core/messages";
+    import { z } from "zod";
+
+    const model = new ChatOpenAI({ model: "gpt-4" });
+
+    const client = new MultiServerMCPClient({
+      math: {
+        command: "node",
+        // Make sure to update to the full absolute path to your math_server.js file
+        args: ["./examples/math_server.js"],
+        transport: "stdio",
+      },
+      weather: {
+        // make sure you start your weather server on port 8000
+        url: "http://localhost:8000/mcp/",
+        transport: "streamable_http",
+      },
+    });
+
+    const tools = await client.getTools();
+
+    const builder = new StateGraph(MessagesZodState)
+      .addNode("callModel", async (state) => {
+        const response = await model.bindTools(tools).invoke(state.messages);
+        return { messages: [response] };
+      })
+      .addNode("tools", new ToolNode(tools))
+      .addEdge(START, "callModel")
+      .addConditionalEdges("callModel", (state) => {
+        const lastMessage = state.messages.at(-1) as AIMessage | undefined;
+        if (!lastMessage?.tool_calls?.length) {
+          return "__end__";
+        }
+        return "tools";
+      })
+      .addEdge("tools", "callModel");
+
+    const graph = builder.compile();
+
+    const mathResponse = await graph.invoke({
+      messages: [{ role: "user", content: "what's (3 + 5) x 12?" }],
+    });
+
+    const weatherResponse = await graph.invoke({
+      messages: [{ role: "user", content: "what is the weather in nyc?" }],
+    });
+    ```
+
+:::
 
 ## Custom MCP servers
 
+:::python
 To create your own MCP servers, you can use the `mcp` library. This library provides a simple way to define tools and run them as servers.
 
 Install the MCP library:
@@ -66,8 +231,24 @@ Install the MCP library:
 ```bash
 pip install mcp
 ```
+
+:::
+
+:::js
+To create your own MCP servers, you can use the `@modelcontextprotocol/sdk` library. This library provides a simple way to define tools and run them as servers.
+
+Install the MCP SDK:
+
+```bash
+npm install @modelcontextprotocol/sdk
+```
+
+:::
+
 Use the following reference implementations to test your agent with MCP tool servers.
 
+:::python
+
 ```python title="Example Math Server (stdio transport)"
 from mcp.server.fastmcp import FastMCP
 
@@ -87,7 +268,116 @@ if __name__ == "__main__":
     mcp.run(transport="stdio")
 ```
 
-```python title="Example Weather Server (SSE transport)"
+:::
+
+:::js
+
+```typescript title="Example Math Server (stdio transport)"
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+
+const server = new Server(
+  {
+    name: "math-server",
+    version: "0.1.0",
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: "add",
+        description: "Add two numbers",
+        inputSchema: {
+          type: "object",
+          properties: {
+            a: {
+              type: "number",
+              description: "First number",
+            },
+            b: {
+              type: "number",
+              description: "Second number",
+            },
+          },
+          required: ["a", "b"],
+        },
+      },
+      {
+        name: "multiply",
+        description: "Multiply two numbers",
+        inputSchema: {
+          type: "object",
+          properties: {
+            a: {
+              type: "number",
+              description: "First number",
+            },
+            b: {
+              type: "number",
+              description: "Second number",
+            },
+          },
+          required: ["a", "b"],
+        },
+      },
+    ],
+  };
+});
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  switch (request.params.name) {
+    case "add": {
+      const { a, b } = request.params.arguments as { a: number; b: number };
+      return {
+        content: [
+          {
+            type: "text",
+            text: String(a + b),
+          },
+        ],
+      };
+    }
+    case "multiply": {
+      const { a, b } = request.params.arguments as { a: number; b: number };
+      return {
+        content: [
+          {
+            type: "text",
+            text: String(a * b),
+          },
+        ],
+      };
+    }
+    default:
+      throw new Error(`Unknown tool: ${request.params.name}`);
+  }
+});
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Math MCP server running on stdio");
+}
+
+main();
+```
+
+:::
+
+:::python
+
+```python title="Example Weather Server (Streamable HTTP transport)"
 from mcp.server.fastmcp import FastMCP
 
 mcp = FastMCP("Weather")
@@ -98,10 +388,103 @@ 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")
 ```
 
+:::
+
+:::js
+
+```typescript title="Example Weather Server (HTTP transport)"
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import express from "express";
+
+const app = express();
+app.use(express.json());
+
+const server = new Server(
+  {
+    name: "weather-server",
+    version: "0.1.0",
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: "get_weather",
+        description: "Get weather for location",
+        inputSchema: {
+          type: "object",
+          properties: {
+            location: {
+              type: "string",
+              description: "Location to get weather for",
+            },
+          },
+          required: ["location"],
+        },
+      },
+    ],
+  };
+});
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  switch (request.params.name) {
+    case "get_weather": {
+      const { location } = request.params.arguments as { location: string };
+      return {
+        content: [
+          {
+            type: "text",
+            text: `It's always sunny in ${location}`,
+          },
+        ],
+      };
+    }
+    default:
+      throw new Error(`Unknown tool: ${request.params.name}`);
+  }
+});
+
+app.post("/mcp", async (req, res) => {
+  const transport = new SSEServerTransport("/mcp", res);
+  await server.connect(transport);
+});
+
+const PORT = process.env.PORT || 8000;
+app.listen(PORT, () => {
+  console.log(`Weather MCP server running on port ${PORT}`);
+});
+```
+
+:::
+
+:::python
+
 ## Additional resources
 
 - [MCP documentation](https://modelcontextprotocol.io/introduction)
-- [MCP Transport documentation](https://modelcontextprotocol.io/docs/concepts/transports)
+- [MCP Transport documentation](https://modelcontextprotocol.io/docs/concepts/transports)
+- [langchain_mcp_adapters](https://github.com/langchain-ai/langchain-mcp-adapters)
+  :::
+
+:::js
+
+## Additional resources
+
+- [MCP documentation](https://modelcontextprotocol.io/introduction)
+- [MCP Transport documentation](https://modelcontextprotocol.io/docs/concepts/transports)
+- [`@langchain/mcp-adapters`](https://npmjs.com/package/@langchain/mcp-adapters)
+  :::

docs/docs/agents/memory.md

@@ -1,423 +0,0 @@
----
-search:
-  boost: 2
-tags:
-  - agent
-hide:
-  - tags
----
-
-# Memory
-
-LangGraph supports two types of memory essential for building conversational agents:
-
-- **[Short-term memory](#short-term-memory)**: Tracks the ongoing conversation by maintaining message history within a session.
-- **[Long-term memory](#long-term-memory)**: Stores user-specific or application-level data across sessions.
-
-This guide demonstrates how to use both memory types with agents in LangGraph. For a deeper
-understanding of memory concepts, refer to the [LangGraph memory documentation](../concepts/memory.md).
-
-<figure markdown="1">
-![image](./assets/memory.png){: style="max-height:400px"}
-<figcaption>Both <strong>short-term</strong> and <strong>long-term</strong> memory require persistent storage to maintain continuity across LLM interactions. In production environments, this data is typically stored in a database.</figcaption>
-</figure>
-
-!!! note "Terminology"
-
-    In LangGraph:
-
-    - *Short-term memory* is also referred to as **thread-level memory**.
-    - *Long-term memory* is also called **cross-thread memory**.
-
-    A [thread](../concepts/persistence.md#threads) represents a sequence of related runs
-    grouped by the same `thread_id`.
-
-## Short-term memory
-
-Short-term memory enables agents to track multi-turn conversations. To use it, you must:
-
-1. Provide a `checkpointer` when creating the agent. The `checkpointer` enables [persistence](../concepts/persistence.md) of the agent's state.
-2. Supply a `thread_id` in the config when running the agent. The `thread_id` is a unique identifier for the conversation session.
-
-```python
-from langgraph.prebuilt import create_react_agent
-from langgraph.checkpoint.memory import InMemorySaver
-
-# highlight-next-line
-checkpointer = InMemorySaver() # (1)!
-
-
-def get_weather(city: str) -> str:
-    """Get weather for a given city."""
-    return f"It's always sunny in {city}!"
-
-
-agent = create_react_agent(
-    model="anthropic:claude-3-7-sonnet-latest",
-    tools=[get_weather],
-    # highlight-next-line
-    checkpointer=checkpointer # (2)!
-)
-
-# Run the agent
-config = {
-    "configurable": {
-        # highlight-next-line
-        "thread_id": "1"  # (3)!
-    }
-}
-
-sf_response = agent.invoke(
-    {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
-    # highlight-next-line
-    config
-)
-
-# Continue the conversation using the same thread_id
-ny_response = agent.invoke(
-    {"messages": [{"role": "user", "content": "what about new york?"}]},
-    # highlight-next-line
-    config # (4)!
-)
-```
-
-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 
-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"
-
-    If you're using [LangGraph Platform](./deployment.md), during deployment your checkpointer will be automatically configured to use a production-ready database.
-
-### Manage message history
-
-Long conversations can exceed the LLM's context window. Common solutions are:
-
-* [Summarization](#summarize-message-history): Maintain a running summary of the conversation
-* [Trimming](#trim-message-history): Remove first or last N messages in the history
-
-This allows the agent to keep track of the conversation without exceeding the LLM's context window.
-
-To manage message history, specify `pre_model_hook` — a function ([node](../concepts/low_level.md#nodes)) that will always run before calling the language model.
-
-#### Summarize message history
-
-<figure markdown="1">
-![image](./assets/summary.png){: style="max-height:400px"}
-<figcaption>Long conversations can exceed the LLM's context window. A common solution is to maintain a running summary of the conversation. This allows the agent to keep track of the conversation without exceeding the LLM's context window.
-</figcaption>
-</figure>
-
-To summarize message history, you can use [`pre_model_hook`][langgraph.prebuilt.chat_agent_executor.create_react_agent] with a prebuilt [`SummarizationNode`](https://langchain-ai.github.io/langmem/reference/short_term/#langmem.short_term.SummarizationNode):
-
-```python
-from langchain_anthropic import ChatAnthropic
-from langmem.short_term import SummarizationNode
-from langchain_core.messages.utils import count_tokens_approximately
-from langgraph.prebuilt import create_react_agent
-from langgraph.prebuilt.chat_agent_executor import AgentState
-from langgraph.checkpoint.memory import InMemorySaver
-from typing import Any
-
-model = ChatAnthropic(model="claude-3-7-sonnet-latest")
-
-summarization_node = SummarizationNode( # (1)!
-    token_counter=count_tokens_approximately,
-    model=model,
-    max_tokens=384,
-    max_summary_tokens=128,
-    output_messages_key="llm_input_messages",
-)
-
-class State(AgentState):
-    # NOTE: we're adding this key to keep track of previous summary information
-    # to make sure we're not summarizing on every LLM call
-    # highlight-next-line
-    context: dict[str, Any]  # (2)!
-
-
-checkpointer = InMemorySaver() # (3)!
-
-agent = create_react_agent(
-    model=model,
-    tools=tools,
-    # highlight-next-line
-    pre_model_hook=summarization_node, # (4)!
-    # highlight-next-line
-    state_schema=State, # (5)!
-    checkpointer=checkpointer,
-)
-```
-
-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 `context` key is added to the agent's state. The key contains book-keeping information for the summarization node. It is used to keep track of the last summary information and ensure that the agent doesn't summarize on every LLM call, which can be inefficient.
-3. The `checkpointer` is passed to the agent. This enables the agent to persist its state across invocations.
-4. The `pre_model_hook` is set to the `SummarizationNode`. This node will summarize the message history before sending it to the LLM. The summarization node will automatically handle the summarization process and update the agent's state with the new summary. You can replace this with a custom implementation if you prefer. Please see the [create_react_agent][langgraph.prebuilt.chat_agent_executor.create_react_agent] API reference for more details.
-5. The `state_schema` is set to the `State` class, which is the custom state that contains an extra `context` key.
-
-#### Trim message history
-
-To trim message history, you can use [`pre_model_hook`][langgraph.prebuilt.chat_agent_executor.create_react_agent] with [`trim_messages`](https://python.langchain.com/api_reference/core/messages/langchain_core.messages.utils.trim_messages.html) function:
-
-```python
-# highlight-next-line
-from langchain_core.messages.utils import (
-    # highlight-next-line
-    trim_messages,
-    # highlight-next-line
-    count_tokens_approximately
-# highlight-next-line
-)
-from langgraph.prebuilt import create_react_agent
-
-# This function will be called every time before the node that calls LLM
-def pre_model_hook(state):
-    trimmed_messages = trim_messages(
-        state["messages"],
-        strategy="last",
-        token_counter=count_tokens_approximately,
-        max_tokens=384,
-        start_on="human",
-        end_on=("human", "tool"),
-    )
-    # highlight-next-line
-    return {"llm_input_messages": trimmed_messages}
-
-checkpointer = InMemorySaver()
-agent = create_react_agent(
-    model,
-    tools,
-    # highlight-next-line
-    pre_model_hook=pre_model_hook,
-    checkpointer=checkpointer,
-)
-```
-
-To learn more about using `pre_model_hook` for managing message history, see this [how-to guide](../how-tos/create-react-agent-manage-message-history.ipynb)
-
-### Read in tools { #read-short-term }
-
-LangGraph allows agent to access its short-term memory (state) inside the tools.
-
-```python
-from typing import Annotated
-from langgraph.prebuilt import InjectedState, create_react_agent
-
-class CustomState(AgentState):
-    # highlight-next-line
-    user_id: str
-
-def get_user_info(
-    # highlight-next-line
-    state: Annotated[CustomState, InjectedState]
-) -> str:
-    """Look up user info."""
-    # highlight-next-line
-    user_id = state["user_id"]
-    return "User is John Smith" if user_id == "user_123" else "Unknown user"
-
-agent = create_react_agent(
-    model="anthropic:claude-3-7-sonnet-latest",
-    tools=[get_user_info],
-    # highlight-next-line
-    state_schema=CustomState,
-)
-
-agent.invoke({
-    "messages": "look up user information",
-    # highlight-next-line
-    "user_id": "user_123"
-})
-```
-
-See the [Context](./context.md#__tabbed_2_2) guide for more information.
-
-### Write from tools { #write-short-term }
-
-To modify the agent's short-term memory (state) during execution, you can return state updates directly from the tools. This is useful for persisting intermediate results or making information accessible to subsequent tools or prompts.
-
-```python
-from typing import Annotated
-from langchain_core.tools import InjectedToolCallId
-from langchain_core.runnables import RunnableConfig
-from langchain_core.messages import ToolMessage
-from langgraph.prebuilt import InjectedState, create_react_agent
-from langgraph.prebuilt.chat_agent_executor import AgentState
-from langgraph.types import Command
-
-class CustomState(AgentState):
-    # highlight-next-line
-    user_name: str
-
-def update_user_info(
-    tool_call_id: Annotated[str, InjectedToolCallId],
-    config: RunnableConfig
-) -> Command:
-    """Look up and update user info."""
-    user_id = config["configurable"].get("user_id")
-    name = "John Smith" if user_id == "user_123" else "Unknown user"
-    # highlight-next-line
-    return Command(update={
-        # highlight-next-line
-        "user_name": name,
-        # update the message history
-        "messages": [
-            ToolMessage(
-                "Successfully looked up user information",
-                tool_call_id=tool_call_id
-            )
-        ]
-    })
-
-def greet(
-    # highlight-next-line
-    state: Annotated[CustomState, InjectedState]
-) -> str:
-    """Use this to greet the user once you found their info."""
-    user_name = state["user_name"]
-    return f"Hello {user_name}!"
-
-agent = create_react_agent(
-    model="anthropic:claude-3-7-sonnet-latest",
-    tools=[update_user_info, greet],
-    # highlight-next-line
-    state_schema=CustomState
-)
-
-agent.invoke(
-    {"messages": [{"role": "user", "content": "greet the user"}]},
-    # highlight-next-line
-    config={"configurable": {"user_id": "user_123"}}
-)
-```
-
-For more details, see [how to update state from tools](../how-tos/update-state-from-tools.ipynb).
-
-## Long-term memory
-
-Use long-term memory to store user-specific or application-specific data across conversations. This is useful for applications like chatbots, where you want to remember user preferences or other information.
-
-To use long-term memory, you need to:
-
-1. [Configure a store](../how-tos/cross-thread-persistence.ipynb) 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 }
-
-```python title="A tool the agent can use to look up user information"
-from langchain_core.runnables import RunnableConfig
-from langgraph.config import get_store
-from langgraph.prebuilt import create_react_agent
-from langgraph.store.memory import InMemoryStore
-
-# highlight-next-line
-store = InMemoryStore() # (1)!
-
-# highlight-next-line
-store.put(  # (2)!
-    ("users",),  # (3)!
-    "user_123",  # (4)!
-    {
-        "name": "John Smith",
-        "language": "English",
-    } # (5)!
-)
-
-def get_user_info(config: RunnableConfig) -> str:
-    """Look up user info."""
-    # Same as that provided to `create_react_agent`
-    # highlight-next-line
-    store = get_store() # (6)!
-    user_id = config["configurable"].get("user_id")
-    # highlight-next-line
-    user_info = store.get(("users",), user_id) # (7)!
-    return str(user_info.value) if user_info else "Unknown user"
-
-agent = create_react_agent(
-    model="anthropic:claude-3-7-sonnet-latest",
-    tools=[get_user_info],
-    # highlight-next-line
-    store=store # (8)!
-)
-
-# Run the agent
-agent.invoke(
-    {"messages": [{"role": "user", "content": "look up user information"}]},
-    # highlight-next-line
-    config={"configurable": {"user_id": "user_123"}}
-)
-```
-
-1. The `InMemoryStore` is a store that stores data in memory. In a production setting, you would typically use a database or other persistent storage. Please review the [store documentation](../reference/store.md) for more options. If you're deploying with **LangGraph Platform**, the platform will provide a production-ready store for you.
-2. For this example, we write some sample data to the store using the `put` method. Please see the [BaseStore.put][langgraph.store.base.BaseStore.put] API reference for more details.
-3. The first argument is the namespace. This is used to group related data together. In this case, we are using the `users` namespace to group user data.
-4. A key within the namespace. This example uses a user ID for the key.
-5. The data that we want to store for the given user.
-6. The `get_store` function is used to access the store. You can call it from anywhere in your code, including tools and prompts. This function returns the store that was passed to the agent when it was created.
-7. The `get` method is used to retrieve data from the store. The first argument is the namespace, and the second argument is the key. This will return a `StoreValue` object, which contains the value and metadata about the value.
-8. The `store` is passed to the agent. This enables the agent to access the store when running tools. You can also use the `get_store` function to access the store from anywhere in your code.
-
-### Write { #write-long-term }
-
-```python title="Example of a tool that updates user information"
-from typing_extensions import TypedDict
-
-from langgraph.config import get_store
-from langgraph.prebuilt import create_react_agent
-from langgraph.store.memory import InMemoryStore
-
-store = InMemoryStore() # (1)!
-
-class UserInfo(TypedDict): # (2)!
-    name: str
-
-def save_user_info(user_info: UserInfo, config: RunnableConfig) -> str: # (3)!
-    """Save user info."""
-    # Same as that provided to `create_react_agent`
-    # highlight-next-line
-    store = get_store() # (4)!
-    user_id = config["configurable"].get("user_id")
-    # highlight-next-line
-    store.put(("users",), user_id, user_info) # (5)!
-    return "Successfully saved user info."
-
-agent = create_react_agent(
-    model="anthropic:claude-3-7-sonnet-latest",
-    tools=[save_user_info],
-    # highlight-next-line
-    store=store
-)
-
-# Run the agent
-agent.invoke(
-    {"messages": [{"role": "user", "content": "My name is John Smith"}]},
-    # highlight-next-line
-    config={"configurable": {"user_id": "user_123"}} # (6)!
-)
-
-# You can access the store directly to get the value
-store.get(("users",), "user_123").value
-```
-
-1. The `InMemoryStore` is a store that stores data in memory. In a production setting, you would typically use a database or other persistent storage. Please review the [store documentation](../reference/store.md) for more options. If you're deploying with **LangGraph Platform**, the platform will provide a production-ready store for you.
-2. The `UserInfo` class is a `TypedDict` that defines the structure of the user information. The LLM will use this to format the response according to the schema.
-3. The `save_user_info` function is a tool that allows an agent to update user information. This could be useful for a chat application where the user wants to update their profile information.
-4. The `get_store` function is used to access the store. You can call it from anywhere in your code, including tools and prompts. This function returns the store that was passed to the agent when it was created.
-5. The `put` method is used to store data in the store. The first argument is the namespace, and the second argument is the key. This will store the user information in the store.
-6. The `user_id` is passed in the config. This is used to identify the user whose information is being updated.
-
-### Semantic search
-
-LangGraph also allows you to [search](https://langchain-ai.github.io/langgraph/how-tos/memory/semantic-search/#using-in-create-react-agent) for items in long-term memory by semantic similarity.
-
-### Prebuilt memory tools
-
-**LangMem** is a LangChain-maintained library that offers tools for managing long-term memories in your agent. See the [LangMem documentation](https://langchain-ai.github.io/langmem/) for usage examples.
-
-
-## Additional resources
-
-* [Memory in LangGraph](../concepts/memory.md)

docs/docs/agents/models.md

@@ -1,81 +1,155 @@
----
-search:
-  boost: 2
-tags:
-  - anthropic
-  - openai
-  - agent
-hide:
-  - tags
----
-
 # Models
 
-This page describes how to configure the chat model used by an agent.
+LangGraph provides built-in support for [LLMs (language models)](https://python.langchain.com/docs/concepts/chat_models/) via the LangChain library. This makes it easy to integrate various LLMs into your agents and workflows.
 
-## Tool calling support
+## Initialize a model
 
-To enable tool-calling agents, the underlying LLM must support [tool calling](https://python.langchain.com/docs/concepts/tool_calling/).
+:::python
+Use [`init_chat_model`](https://python.langchain.com/docs/how_to/chat_models_universal_init/) to initialize models:
 
-Compatible models can be found in the [LangChain integrations directory](https://python.langchain.com/docs/integrations/chat/).
+{!snippets/chat_model_tabs.md!}
+:::
 
-## Specifying a model by name
+:::js
+Use model provider classes to initialize models:
 
-You can configure an agent with a model name string:
+=== "OpenAI"
 
-```python
-from langgraph.prebuilt import create_react_agent
+    ```typescript
+    import { ChatOpenAI } from "@langchain/openai";
 
-agent = create_react_agent(
-    # highlight-next-line
-    model="anthropic:claude-3-7-sonnet-latest",
-    # other parameters
-)
-```
+    const model = new ChatOpenAI({
+      model: "gpt-4o",
+      temperature: 0,
+    });
+    ```
 
-## Using `init_chat_model`
+=== "Anthropic"
 
-The [`init_chat_model`](https://python.langchain.com/docs/how_to/chat_models_universal_init/) utility simplifies model initialization with configurable parameters:
+    ```typescript
+    import { ChatAnthropic } from "@langchain/anthropic";
 
-```python
-from langchain.chat_models import init_chat_model
+    const model = new ChatAnthropic({
+      model: "claude-3-5-sonnet-20240620",
+      temperature: 0,
+      maxTokens: 2048,
+    });
+    ```
 
-model = init_chat_model(
-    "anthropic:claude-3-7-sonnet-latest",
-    temperature=0,
-    max_tokens=2048
-)
-```
+=== "Google"
 
-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.
+    ```typescript
+    import { ChatGoogleGenerativeAI } from "@langchain/google-genai";
 
-## Using provider-specific LLMs 
+    const model = new ChatGoogleGenerativeAI({
+      model: "gemini-1.5-pro",
+      temperature: 0,
+    });
+    ```
+
+=== "Groq"
+
+    ```typescript
+    import { ChatGroq } from "@langchain/groq";
+
+    const model = new ChatGroq({
+      model: "llama-3.1-70b-versatile",
+      temperature: 0,
+    });
+    ```
+
+:::
+
+:::python
+
+### Instantiate a model directly
 
 If a model provider is not available via `init_chat_model`, you can instantiate the provider's model class directly. The model must implement the [BaseChatModel interface](https://python.langchain.com/api_reference/core/language_models/langchain_core.language_models.chat_models.BaseChatModel.html) and support tool calling:
 
 ```python
+# Anthropic is already supported by `init_chat_model`,
+# but you can also instantiate it directly.
 from langchain_anthropic import ChatAnthropic
-from langgraph.prebuilt import create_react_agent
 
 model = ChatAnthropic(
-    model="claude-3-7-sonnet-latest",
-    temperature=0,
-    max_tokens=2048
-)
-
-agent = create_react_agent(
-    # highlight-next-line
-    model=model,
-    # other parameters
+  model="claude-3-7-sonnet-latest",
+  temperature=0,
+  max_tokens=2048
 )
 ```
 
-!!! note "Illustrative example" 
+:::
 
-    The example above uses `ChatAnthropic`, which is already supported by `init_chat_model`. This pattern is shown to illustrate how to manually instantiate a model not available through init_chat_model.
+!!! important "Tool calling support"
 
-## Disable streaming
+    If you are building an agent or workflow that requires the model to call external tools, ensure that the underlying
+    language model supports [tool calling](../concepts/tools.md). Compatible models can be found in the [LangChain integrations directory](https://python.langchain.com/docs/integrations/chat/).
 
+## Use in an agent
+
+:::python
+When using `create_react_agent` you can specify the model by its name string, which is a shorthand for initializing the model using `init_chat_model`. This allows you to use the model without needing to import or instantiate it directly.
+
+=== "model name"
+
+      ```python
+      from langgraph.prebuilt import create_react_agent
+
+      create_react_agent(
+         # highlight-next-line
+         model="anthropic:claude-3-7-sonnet-latest",
+         # other parameters
+      )
+      ```
+
+=== "model instance"
+
+      ```python
+      from langchain_anthropic import ChatAnthropic
+      from langgraph.prebuilt import create_react_agent
+
+      model = ChatAnthropic(
+          model="claude-3-7-sonnet-latest",
+          temperature=0,
+          max_tokens=2048
+      )
+      # Alternatively
+      # model = init_chat_model("anthropic:claude-3-7-sonnet-latest")
+
+      agent = create_react_agent(
+        # highlight-next-line
+        model=model,
+        # other parameters
+      )
+      ```
+
+:::
+
+:::js
+When using `createReactAgent` you can pass the model instance directly:
+
+```typescript
+import { ChatOpenAI } from "@langchain/openai";
+import { createReactAgent } from "@langchain/langgraph/prebuilt";
+
+const model = new ChatOpenAI({
+  model: "gpt-4o",
+  temperature: 0,
+});
+
+const agent = createReactAgent({
+  llm: model,
+  tools: tools,
+});
+```
+
+:::
+
+## Advanced model configuration
+
+### Disable streaming
+
+:::python
 To disable streaming of the individual LLM tokens, set `disable_streaming=True` when initializing the model:
 
 === "`init_chat_model`"
@@ -103,9 +177,25 @@ To disable streaming of the individual LLM tokens, set `disable_streaming=True`
     ```
 
 Refer to the [API reference](https://python.langchain.com/api_reference/core/language_models/langchain_core.language_models.chat_models.BaseChatModel.html#langchain_core.language_models.chat_models.BaseChatModel.disable_streaming) for more information on `disable_streaming`
+:::
 
-## Adding model fallbacks
+:::js
+To disable streaming of the individual LLM tokens, set `streaming: false` when initializing the model:
 
+```typescript
+import { ChatOpenAI } from "@langchain/openai";
+
+const model = new ChatOpenAI({
+  model: "gpt-4o",
+  streaming: false,
+});
+```
+
+:::
+
+### Add model fallbacks
+
+:::python
 You can add a fallback to a different model or a different LLM provider using `model.with_fallbacks([...])`:
 
 === "`init_chat_model`"
@@ -138,8 +228,87 @@ You can add a fallback to a different model or a different LLM provider using `m
     ```
 
 See this [guide](https://python.langchain.com/docs/how_to/fallbacks/#fallback-to-better-model) for more information on model fallbacks.
+:::
+
+:::js
+You can add a fallback to a different model or a different LLM provider using `model.withFallbacks([...])`:
+
+```typescript
+import { ChatOpenAI } from "@langchain/openai";
+import { ChatAnthropic } from "@langchain/anthropic";
+
+const modelWithFallbacks = new ChatOpenAI({
+  model: "gpt-4o",
+}).withFallbacks([
+  new ChatAnthropic({
+    model: "claude-3-5-sonnet-20240620",
+  }),
+]);
+```
+
+See this [guide](https://js.langchain.com/docs/how_to/fallbacks/#fallback-to-better-model) for more information on model fallbacks.
+:::
+
+:::python
+
+### Use the built-in rate limiter
+
+Langchain includes a built-in in-memory rate limiter. This rate limiter is thread safe and can be shared by multiple threads in the same process.
+
+```python
+from langchain_core.rate_limiters import InMemoryRateLimiter
+from langchain_anthropic import ChatAnthropic
+
+rate_limiter = InMemoryRateLimiter(
+    requests_per_second=0.1,  # <-- Super slow! We can only make a request once every 10 seconds!!
+    check_every_n_seconds=0.1,  # Wake up every 100 ms to check whether allowed to make a request,
+    max_bucket_size=10,  # Controls the maximum burst size.
+)
+
+model = ChatAnthropic(
+   model_name="claude-3-opus-20240229",
+   rate_limiter=rate_limiter
+)
+```
+
+See the LangChain docs for more information on how to [handle rate limiting](https://python.langchain.com/docs/how_to/chat_model_rate_limiting/).
+:::
+
+## Bring your own model
+
+If your desired LLM isn't officially supported by LangChain, consider these options:
+
+:::python
+
+1. **Implement a custom LangChain chat model**: Create a model conforming to the [LangChain chat model interface](https://python.langchain.com/docs/how_to/custom_chat_model/). This enables full compatibility with LangGraph's agents and workflows but requires understanding of the LangChain framework.
+   :::
+
+:::js
+
+1. **Implement a custom LangChain chat model**: Create a model conforming to the [LangChain chat model interface](https://js.langchain.com/docs/how_to/custom_chat/). This enables full compatibility with LangGraph's agents and workflows but requires understanding of the LangChain framework.
+   :::
+
+2. **Direct invocation with custom streaming**: Use your model directly by [adding custom streaming logic](../how-tos/streaming.md#use-with-any-llm) with `StreamWriter`.
+   Refer to the [custom streaming documentation](../how-tos/streaming.md#use-with-any-llm) for guidance. This approach suits custom workflows where prebuilt agent integration is not necessary.
 
 ## Additional resources
 
+:::python
+
+- [Multimodal inputs](https://python.langchain.com/docs/how_to/multimodal_inputs/)
+- [Structured outputs](https://python.langchain.com/docs/how_to/structured_output/)
 - [Model integration directory](https://python.langchain.com/docs/integrations/chat/)
-- [Universal initialization with `init_chat_model`](https://python.langchain.com/docs/how_to/chat_models_universal_init/)
+- [Force model to call a specific tool](https://python.langchain.com/docs/how_to/tool_choice/)
+- [All chat model how-to guides](https://python.langchain.com/docs/how_to/#chat-models)
+- [Chat model integrations](https://python.langchain.com/docs/integrations/chat/)
+  :::
+
+:::js
+
+- [Multimodal inputs](https://js.langchain.com/docs/how_to/multimodal_inputs/)
+- [Structured outputs](https://js.langchain.com/docs/how_to/structured_output/)
+- [Model integration directory](https://js.langchain.com/docs/integrations/chat/)
+- [Force model to call a specific tool](https://js.langchain.com/docs/how_to/tool_choice/)
+- [All chat model how-to guides](https://js.langchain.com/docs/how_to/#chat-models)
+- [Chat model integrations](https://js.langchain.com/docs/integrations/chat/)
+  :::

docs/docs/agents/multi-agent.md

@@ -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.
 
@@ -22,6 +22,7 @@ Two of the most popular multi-agent architectures are:
 
 ![Supervisor](./assets/supervisor.png)
 
+:::python
 Use [`langgraph-supervisor`](https://github.com/langchain-ai/langgraph-supervisor-py) library to create a supervisor multi-agent system:
 
 ```bash
@@ -82,10 +83,76 @@ for chunk in supervisor.stream(
     print("\n")
 ```
 
+:::
+
+:::js
+Use [`@langchain/langgraph-supervisor`](https://github.com/langchain-ai/langgraphjs/tree/main/libs/langgraph-supervisor) library to create a supervisor multi-agent system:
+
+```bash
+npm install @langchain/langgraph-supervisor
+```
+
+```typescript
+import { ChatOpenAI } from "@langchain/openai";
+import { createReactAgent } from "@langchain/langgraph/prebuilt";
+// highlight-next-line
+import { createSupervisor } from "langgraph-supervisor";
+
+function bookHotel(hotelName: string) {
+  /**Book a hotel*/
+  return `Successfully booked a stay at ${hotelName}.`;
+}
+
+function bookFlight(fromAirport: string, toAirport: string) {
+  /**Book a flight*/
+  return `Successfully booked a flight from ${fromAirport} to ${toAirport}.`;
+}
+
+const flightAssistant = createReactAgent({
+  llm: "openai:gpt-4o",
+  tools: [bookFlight],
+  stateModifier: "You are a flight booking assistant",
+  // highlight-next-line
+  name: "flight_assistant",
+});
+
+const hotelAssistant = createReactAgent({
+  llm: "openai:gpt-4o",
+  tools: [bookHotel],
+  stateModifier: "You are a hotel booking assistant",
+  // highlight-next-line
+  name: "hotel_assistant",
+});
+
+// highlight-next-line
+const supervisor = createSupervisor({
+  agents: [flightAssistant, hotelAssistant],
+  llm: new ChatOpenAI({ model: "gpt-4o" }),
+  systemPrompt:
+    "You manage a hotel booking assistant and a " +
+    "flight booking assistant. Assign work to them.",
+});
+
+for await (const chunk of supervisor.stream({
+  messages: [
+    {
+      role: "user",
+      content: "book a flight from BOS to JFK and a stay at McKittrick Hotel",
+    },
+  ],
+})) {
+  console.log(chunk);
+  console.log("\n");
+}
+```
+
+:::
+
 ## Swarm
 
 ![Swarm](./assets/swarm.png)
 
+:::python
 Use [`langgraph-swarm`](https://github.com/langchain-ai/langgraph-swarm-py) library to create a swarm multi-agent system:
 
 ```bash
@@ -143,18 +210,82 @@ for chunk in swarm.stream(
     print("\n")
 ```
 
+:::
+
+:::js
+Use [`@langchain/langgraph-swarm`](https://github.com/langchain-ai/langgraphjs/tree/main/libs/langgraph-swarm) library to create a swarm multi-agent system:
+
+```bash
+npm install @langchain/langgraph-swarm
+```
+
+```typescript
+import { createReactAgent } from "@langchain/langgraph/prebuilt";
+// highlight-next-line
+import { createSwarm, createHandoffTool } from "@langchain/langgraph-swarm";
+
+const transferToHotelAssistant = createHandoffTool({
+  agentName: "hotel_assistant",
+  description: "Transfer user to the hotel-booking assistant.",
+});
+
+const transferToFlightAssistant = createHandoffTool({
+  agentName: "flight_assistant",
+  description: "Transfer user to the flight-booking assistant.",
+});
+
+const flightAssistant = createReactAgent({
+  llm: "anthropic:claude-3-5-sonnet-latest",
+  // highlight-next-line
+  tools: [bookFlight, transferToHotelAssistant],
+  stateModifier: "You are a flight booking assistant",
+  // highlight-next-line
+  name: "flight_assistant",
+});
+
+const hotelAssistant = createReactAgent({
+  llm: "anthropic:claude-3-5-sonnet-latest",
+  // highlight-next-line
+  tools: [bookHotel, transferToFlightAssistant],
+  stateModifier: "You are a hotel booking assistant",
+  // highlight-next-line
+  name: "hotel_assistant",
+});
+
+// highlight-next-line
+const swarm = createSwarm({
+  agents: [flightAssistant, hotelAssistant],
+  defaultActiveAgent: "flight_assistant",
+});
+
+for await (const chunk of swarm.stream({
+  messages: [
+    {
+      role: "user",
+      content: "book a flight from BOS to JFK and a stay at McKittrick Hotel",
+    },
+  ],
+})) {
+  console.log(chunk);
+  console.log("\n");
+}
+```
+
+:::
+
 ## Handoffs
 
-A common pattern in multi-agent interactions is **handoffs**, where one agent *hands off* control to another. Handoffs allow you to specify:
+A common pattern in multi-agent interactions is **handoffs**, where one agent _hands off_ control to another. Handoffs allow you to specify:
 
 - **destination**: target agent to navigate to
 - **payload**: information to pass to that agent
 
+:::python
 This is used both by `langgraph-supervisor` (supervisor hands off to individual agents) and `langgraph-swarm` (an individual agent can hand off to other agents).
 
 To implement handoffs with `create_react_agent`, you need to:
 
-1. Create a special tool that can transfer control to a different agent
+1.  Create a special tool that can transfer control to a different agent
 
     ```python
     def transfer_to_bob():
@@ -173,7 +304,7 @@ To implement handoffs with `create_react_agent`, you need to:
         )
     ```
 
-1. Create individual agents that have access to handoff tools:
+2.  Create individual agents that have access to handoff tools:
 
     ```python
     flight_assistant = create_react_agent(
@@ -184,20 +315,72 @@ To implement handoffs with `create_react_agent`, you need to:
     )
     ```
 
-1. Define a parent graph that contains individual agents as nodes:
+3.  Define a parent graph that contains individual agents as nodes:
 
-    ```python
-    from langgraph.graph import StateGraph, MessagesState
-    multi_agent_graph = (
-        StateGraph(MessagesState)
-        .add_node(flight_assistant)
-        .add_node(hotel_assistant)
-        ...
-    )
+        ```python
+        from langgraph.graph import StateGraph, MessagesState
+        multi_agent_graph = (
+            StateGraph(MessagesState)
+            .add_node(flight_assistant)
+            .add_node(hotel_assistant)
+            ...
+        )
+        ```
+
+    :::
+
+:::js
+This is used both by `@langchain/langgraph-supervisor` (supervisor hands off to individual agents) and `@langchain/langgraph-swarm` (an individual agent can hand off to other agents).
+
+To implement handoffs with `createReactAgent`, you need to:
+
+1.  Create a special tool that can transfer control to a different agent
+
+    ```typescript
+    function transferToBob() {
+      /**Transfer to bob.*/
+      return new Command({
+        // name of the agent (node) to go to
+        // highlight-next-line
+        goto: "bob",
+        // data to send to the agent
+        // highlight-next-line
+        update: { messages: [...] },
+        // indicate to LangGraph that we need to navigate to
+        // agent node in a parent graph
+        // highlight-next-line
+        graph: Command.PARENT,
+      });
+    }
     ```
 
+2.  Create individual agents that have access to handoff tools:
+
+    ```typescript
+    const flightAssistant = createReactAgent({
+      ..., tools: [bookFlight, transferToHotelAssistant]
+    });
+    const hotelAssistant = createReactAgent({
+      ..., tools: [bookHotel, transferToFlightAssistant]
+    });
+    ```
+
+3.  Define a parent graph that contains individual agents as nodes:
+
+        ```typescript
+        import { StateGraph, MessagesZodState } from "@langchain/langgraph";
+        const multiAgentGraph = new StateGraph(MessagesZodState)
+          .addNode("flight_assistant", flightAssistant)
+          .addNode("hotel_assistant", hotelAssistant)
+          // ...
+        ```
+
+    :::
+
 Putting this together, here is how you can implement a simple multi-agent system with two agents — a flight booking assistant and a hotel booking assistant:
 
+:::python
+
 ```python
 from typing import Annotated
 from langchain_core.tools import tool, InjectedToolCallId
@@ -298,11 +481,156 @@ for chunk in multi_agent_graph.stream(
 3. Name of the agent or node to hand off to.
 4. Take the agent's messages and **add** them to the parent's **state** as part of the handoff. The next agent will see the parent state.
 5. Indicate to LangGraph that we need to navigate to agent node in a **parent** multi-agent graph.
+   :::
+
+:::js
+
+```typescript
+import { tool } from "@langchain/core/tools";
+import { ChatAnthropic } from "@langchain/anthropic";
+import { createReactAgent } from "@langchain/langgraph/prebuilt";
+import {
+  StateGraph,
+  START,
+  MessagesZodState,
+  Command,
+} from "@langchain/langgraph";
+import { z } from "zod";
+
+function createHandoffTool({
+  agentName,
+  description,
+}: {
+  agentName: string;
+  description?: string;
+}) {
+  const name = `transfer_to_${agentName}`;
+  const toolDescription = description || `Transfer to ${agentName}`;
+
+  return tool(
+    async (_, config) => {
+      const toolMessage = {
+        role: "tool" as const,
+        content: `Successfully transferred to ${agentName}`,
+        name: name,
+        tool_call_id: config.toolCall?.id!,
+      };
+      return new Command({
+        // (2)!
+        // highlight-next-line
+        goto: agentName, // (3)!
+        // highlight-next-line
+        update: { messages: [toolMessage] }, // (4)!
+        // highlight-next-line
+        graph: Command.PARENT, // (5)!
+      });
+    },
+    {
+      name,
+      description: toolDescription,
+      schema: z.object({}),
+    }
+  );
+}
+
+// Handoffs
+const transferToHotelAssistant = createHandoffTool({
+  agentName: "hotel_assistant",
+  description: "Transfer user to the hotel-booking assistant.",
+});
+
+const transferToFlightAssistant = createHandoffTool({
+  agentName: "flight_assistant",
+  description: "Transfer user to the flight-booking assistant.",
+});
+
+// Simple agent tools
+const bookHotel = tool(
+  async ({ hotelName }) => {
+    /**Book a hotel*/
+    return `Successfully booked a stay at ${hotelName}.`;
+  },
+  {
+    name: "book_hotel",
+    description: "Book a hotel",
+    schema: z.object({
+      hotelName: z.string().describe("Name of the hotel to book"),
+    }),
+  }
+);
+
+const bookFlight = tool(
+  async ({ fromAirport, toAirport }) => {
+    /**Book a flight*/
+    return `Successfully booked a flight from ${fromAirport} to ${toAirport}.`;
+  },
+  {
+    name: "book_flight",
+    description: "Book a flight",
+    schema: z.object({
+      fromAirport: z.string().describe("Departure airport code"),
+      toAirport: z.string().describe("Arrival airport code"),
+    }),
+  }
+);
+
+// Define agents
+const flightAssistant = createReactAgent({
+  llm: new ChatAnthropic({ model: "anthropic:claude-3-5-sonnet-latest" }),
+  // highlight-next-line
+  tools: [bookFlight, transferToHotelAssistant],
+  stateModifier: "You are a flight booking assistant",
+  // highlight-next-line
+  name: "flight_assistant",
+});
+
+const hotelAssistant = createReactAgent({
+  llm: new ChatAnthropic({ model: "anthropic:claude-3-5-sonnet-latest" }),
+  // highlight-next-line
+  tools: [bookHotel, transferToFlightAssistant],
+  stateModifier: "You are a hotel booking assistant",
+  // highlight-next-line
+  name: "hotel_assistant",
+});
+
+// Define multi-agent graph
+const multiAgentGraph = new StateGraph(MessagesZodState)
+  .addNode("flight_assistant", flightAssistant)
+  .addNode("hotel_assistant", hotelAssistant)
+  .addEdge(START, "flight_assistant")
+  .compile();
+
+// Run the multi-agent graph
+for await (const chunk of multiAgentGraph.stream({
+  messages: [
+    {
+      role: "user",
+      content: "book a flight from BOS to JFK and a stay at McKittrick Hotel",
+    },
+  ],
+})) {
+  console.log(chunk);
+  console.log("\n");
+}
+```
+
+1. Access agent's state
+2. The `Command` primitive allows specifying a state update and a node transition as a single operation, making it useful for implementing handoffs.
+3. Name of the agent or node to hand off to.
+4. Take the agent's messages and **add** them to the parent's **state** as part of the handoff. The next agent will see the parent state.
+5. Indicate to LangGraph that we need to navigate to agent node in a **parent** multi-agent graph.
+   :::
 
 !!! Note
-    This handoff implementation assumes that:
+This handoff implementation assumes that:
 
     - each agent receives overall message history (across all agents) in the multi-agent system as its input
     - each agent outputs its internal messages history to the overall message history of the multi-agent system
 
-    Check out LangGraph [supervisor](https://github.com/langchain-ai/langgraph-supervisor-py#customizing-handoff-tools) and [swarm](https://github.com/langchain-ai/langgraph-swarm-py#customizing-handoff-tools) documentation to learn how to customize handoffs.
+:::python
+Check out LangGraph [supervisor](https://github.com/langchain-ai/langgraph-supervisor-py#customizing-handoff-tools) and [swarm](https://github.com/langchain-ai/langgraph-swarm-py#customizing-handoff-tools) documentation to learn how to customize handoffs.
+:::
+
+:::js
+Check out LangGraph [supervisor](https://github.com/langchain-ai/langgraphjs/tree/main/libs/langgraph-supervisor#customizing-handoff-tools) and [swarm](https://github.com/langchain-ai/langgraphjs/tree/main/libs/langgraph-swarm#customizing-handoff-tools) documentation to learn how to customize handoffs.
+:::

docs/docs/agents/overview.md

@@ -14,7 +14,7 @@ hide:
 
 ## What is an agent?
 
-An *agent* consists of three components: a **large language model (LLM)**, a set of **tools** it can use, and a **prompt** that provides instructions.
+An _agent_ consists of three components: a **large language model (LLM)**, a set of **tools** it can use, and a **prompt** that provides instructions.
 
 The LLM operates in a loop. In each iteration, it selects a tool to invoke, provides input, receives the result (an observation), and uses that observation to inform the next action. The loop continues until a stopping condition is met — typically when the agent has gathered enough information to respond to the user.
 
@@ -27,12 +27,12 @@ The LLM operates in a loop. In each iteration, it selects a tool to invoke, prov
 
 LangGraph includes several capabilities essential for building robust, production-ready agentic systems:
 
-- [**Memory integration**](./memory.md): Native support for *short-term* (session-based) and *long-term* (persistent across sessions) memory, enabling stateful behaviors in chatbots and assistants.
-- [**Human-in-the-loop control**](./human-in-the-loop.md): Execution can pause *indefinitely* to await human feedback—unlike websocket-based solutions limited to real-time interaction. This enables asynchronous approval, correction, or intervention at any point in the workflow.
-- [**Streaming support**](./streaming.md): Real-time streaming of agent state, model tokens, tool outputs, or combined streams.
+- [**Memory integration**](../how-tos/memory/add-memory.md): Native support for _short-term_ (session-based) and _long-term_ (persistent across sessions) memory, enabling stateful behaviors in chatbots and assistants.
+- [**Human-in-the-loop control**](../concepts/human_in_the_loop.md): Execution can pause _indefinitely_ to await human feedback—unlike websocket-based solutions limited to real-time interaction. This enables asynchronous approval, correction, or intervention at any point in the workflow.
+- [**Streaming support**](../how-tos/streaming.md): Real-time streaming of agent state, model tokens, tool outputs, or combined streams.
 - [**Deployment tooling**](./deployment.md): Includes infrastructure-free deployment tools. [**LangGraph Platform**](https://langchain-ai.github.io/langgraph/concepts/langgraph_platform/) supports testing, debugging, and deployment.
-    - **[Studio](https://langchain-ai.github.io/langgraph/concepts/langgraph_studio/)**: A visual IDE for inspecting and debugging workflows.
-    - Supports multiple [**deployment options**](https://langchain-ai.github.io/langgraph/tutorials/deployment/) for production.
+  - **[Studio](https://langchain-ai.github.io/langgraph/concepts/langgraph_studio/)**: A visual IDE for inspecting and debugging workflows.
+  - Supports multiple [**deployment options**](https://langchain-ai.github.io/langgraph/concepts/deployment_options.md) for production.
 
 ## High-level building blocks
 
@@ -40,16 +40,308 @@ LangGraph comes with a set of prebuilt components that implement common agent be
 
 Using LangGraph for agent development allows you to focus on your application's logic and behavior, instead of building and maintaining the supporting infrastructure for state, memory, and human feedback.
 
+:::python
+
 ## Package ecosystem
 
 The high-level components are organized into several packages, each with a specific focus.
 
-| Package                                    | Description                                                                 | Installation                            |
-|--------------------------------------------|-----------------------------------------------------------------------------|-----------------------------------------|
-| `langgraph-prebuilt` (part of `langgraph`) | Prebuilt components to [**create agents**](./agents.md)                     | `pip install -U langgraph langchain`    |
-| `langgraph-supervisor`                     | Tools for building [**supervisor**](./multi-agent.md#supervisor) agents     | `pip install -U langgraph-supervisor`   |
-| `langgraph-swarm`                          | Tools for building a [**swarm**](./multi-agent.md#swarm) multi-agent system | `pip install -U langgraph-swarm`        |
-| `langchain-mcp-adapters`                   | Interfaces to [**MCP servers**](./mcp.md) for tool and resource integration | `pip install -U langchain-mcp-adapters` |
-| `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`             |
+| Package                                    | Description                                                                              | Installation                            |
+| ------------------------------------------ | ---------------------------------------------------------------------------------------- | --------------------------------------- |
+| `langgraph-prebuilt` (part of `langgraph`) | Prebuilt components to [**create agents**](./agents.md)                                  | `pip install -U langgraph langchain`    |
+| `langgraph-supervisor`                     | Tools for building [**supervisor**](./multi-agent.md#supervisor) agents                  | `pip install -U langgraph-supervisor`   |
+| `langgraph-swarm`                          | Tools for building a [**swarm**](./multi-agent.md#swarm) multi-agent system              | `pip install -U langgraph-swarm`        |
+| `langchain-mcp-adapters`                   | Interfaces to [**MCP servers**](./mcp.md) for tool and resource integration              | `pip install -U langchain-mcp-adapters` |
+| `langmem`                                  | Agent memory management: [**short-term and long-term**](../how-tos/memory/add-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>
+
+:::
+
+:::js
+
+## Package ecosystem
+
+The high-level components are organized into several packages, each with a specific focus.
+
+| Package                  | Description                                                                 | Installation                                       |
+| ------------------------ | --------------------------------------------------------------------------- | -------------------------------------------------- |
+| `langgraph`              | Prebuilt components to [**create agents**](./agents.md)                     | `npm install @langchain/langgraph @langchain/core` |
+| `langgraph-supervisor`   | Tools for building [**supervisor**](./multi-agent.md#supervisor) agents     | `npm install @langchain/langgraph-supervisor`      |
+| `langgraph-swarm`        | Tools for building a [**swarm**](./multi-agent.md#swarm) multi-agent system | `npm install @langchain/langgraph-swarm`           |
+| `langchain-mcp-adapters` | Interfaces to [**MCP servers**](./mcp.md) for tool and resource integration | `npm install @langchain/mcp-adapters`              |
+| `agentevals`             | Utilities to [**evaluate agent performance**](./evals.md)                   | `npm install agentevals`                           |
+
+## Visualize an agent graph
+
+Use the following tool to visualize the graph generated by [`createReactAgent`](/langgraphjs/reference/functions/langgraph_prebuilt.createReactAgent.html) 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`](./tools.md): A list of tools (functions, APIs, or other callable objects) that the agent can use to perform tasks.
+- `preModelHook`: A function that is called before the model is invoked. It can be used to condense messages or perform other preprocessing tasks.
+- `postModelHook`: 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.
+- [`responseFormat`](./agents.md#structured-output): A data structure used to constrain the type of the final output (via Zod schemas).
+
+<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="preModelHook"> <code>preModelHook</code></label>
+      <label><input type="checkbox" id="postModelHook"> <code>postModelHook</code></label>
+      <label><input type="checkbox" id="responseFormat"> <code>responseFormat</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 [`createReactAgent`](/langgraphjs/reference/functions/langgraph_prebuilt.createReactAgent.html):
+
+<div class="language-typescript">
+  <pre><code id="agent-code" class="language-typescript"></code></pre>
+</div>
+
+<script>
+function getCheckedValue(id) {
+  return document.getElementById(id).checked ? "1" : "0";
+}
+
+function getKey() {
+  return [
+    getCheckedValue("responseFormat"),
+    getCheckedValue("postModelHook"),
+    getCheckedValue("preModelHook"),
+    getCheckedValue("tools")
+  ].join("");
+}
+
+function dedent(strings, ...values) {
+  const str = String.raw({ raw: strings }, ...values)
+  const [space] = str.split("\n").filter(Boolean).at(0).match(/^(\s*)/)
+  const spaceLen = space.length
+  return str.split("\n").map(line => line.slice(spaceLen)).join("\n").trim()
+}
+
+Object.assign(dedent, {
+  offset: (size) => (strings, ...values) => {
+    return dedent(strings, ...values).split("\n").map(line => " ".repeat(size) + line).join("\n")
+  }
+})
+
+
+
+
+function generateCodeSnippet({ tools, pre, post, response }) {
+  const lines = []
+
+  lines.push(dedent`
+    import { createReactAgent } from "@langchain/langgraph/prebuilt";
+    import { ChatOpenAI } from "@langchain/openai";
+  `)
+
+  if (tools) lines.push(`import { tool } from "@langchain/core/tools";`);  
+  if (response || tools) lines.push(`import { z } from "zod";`);
+
+  lines.push("", dedent`
+    const agent = createReactAgent({
+      llm: new ChatOpenAI({ model: "o4-mini" }),
+  `)
+
+  if (tools) {
+    lines.push(dedent.offset(2)`
+      tools: [
+        tool(() => "Sample tool output", {
+          name: "sampleTool",
+          schema: z.object({}),
+        }),
+      ],
+    `)
+  }
+
+  if (pre) {
+    lines.push(dedent.offset(2)`
+      preModelHook: (state) => ({ llmInputMessages: state.messages }),
+    `)
+  }
+
+  if (post) {
+    lines.push(dedent.offset(2)`
+      postModelHook: (state) => state,
+    `)
+  }
+
+  if (response) {
+    lines.push(dedent.offset(2)`
+      responseFormat: z.object({ result: z.string() }),
+    `)
+  }
+
+  lines.push(`});`);
+
+  return lines.join("\n");
+}
+
+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("preModelHook").checked,
+    post: document.getElementById("postModelHook").checked,
+    response: document.getElementById("responseFormat").checked
+  };
+
+  document.getElementById("agent-code").textContent = generateCodeSnippet(state);
+}
+
+function initializeWidget() {
+  render(); // no need for `await` here
+  document.querySelectorAll(".agent-graph-features input").forEach((input) => {
+    input.addEventListener("change", render);
+  });
+}
+
+// Init for both full reload and SPA nav (used by MkDocs Material)
+window.addEventListener("DOMContentLoaded", initializeWidget);
+document$.subscribe(initializeWidget);
+</script>
+
+:::

docs/docs/agents/prebuilt.md

@@ -1,12 +1,13 @@
 [//]: # (This file is automatically generated using a script in docs/_scripts. Do not edit this file directly!)
-# Community agents
+# Community Agents
 
 If you’re looking for other prebuilt libraries, explore the community-built options 
 below. These libraries can extend LangGraph's functionality in various ways.
 
-## 📚 Available libraries
-
+## 📚 Available Libraries
 [//]: # (This file is automatically generated using a script in docs/_scripts. Do not edit this file directly!)
+
+:::python
 | Name | GitHub URL | Description | Weekly Downloads | Stars |
 | --- | --- | --- | --- | --- |
 | **trustcall** | [hinthornw/trustcall](https://github.com/hinthornw/trustcall) | Tenacious tool calling built on LangGraph. | -12345 | ![GitHub stars](https://img.shields.io/github/stars/hinthornw/trustcall?style=social)
@@ -23,7 +24,7 @@ below. These libraries can extend LangGraph's functionality in various ways.
 | **langgraph-reflection** | [langchain-ai/langgraph-reflection](https://github.com/langchain-ai/langgraph-reflection) | LangGraph agent that runs a reflection step. | -12345 | ![GitHub stars](https://img.shields.io/github/stars/langchain-ai/langgraph-reflection?style=social)
 | **langgraph-codeact** | [langchain-ai/langgraph-codeact](https://github.com/langchain-ai/langgraph-codeact) | LangGraph implementation of CodeAct agent that generates and executes code instead of tool calling. | -12345 | ![GitHub stars](https://img.shields.io/github/stars/langchain-ai/langgraph-codeact?style=social)
 
-## ✨ Contributing your library
+## ✨ Contributing Your Library
 
 Have you built an awesome open-source library using LangGraph? We'd love to feature 
 your project on the official LangGraph documentation pages! 🏆
@@ -32,13 +33,41 @@ To share your project, simply open a Pull Request adding an entry for your packa
 
 **Guidelines**
 
-- Your repo must be distributed as an installable package (e.g., PyPI for Python, npm 
-  for JavaScript/TypeScript, etc.) 📦
+- Your repo must be distributed as an installable package on PyPI 📦
 - The repo should either use the Graph API (exposing a `StateGraph` instance) or 
   the Functional API (exposing an `entrypoint`).
 - The package must include documentation (e.g., a `README.md` or docs site) 
   explaining how to use it.
-  
+
 We'll review your contribution and merge it in!
 
 Thanks for contributing! 🚀
+:::
+
+:::js
+| Name | GitHub URL | Description | Weekly Downloads | Stars |
+| --- | --- | --- | --- | --- |
+| **@langchain/mcp-adapters** | [langchain-ai/langchainjs](https://github.com/langchain-ai/langchainjs) | Make Anthropic Model Context Protocol (MCP) tools compatible with LangGraph agents. | -12345 | ![GitHub stars](https://img.shields.io/github/stars/langchain-ai/langchainjs?style=social)
+| **@langchain/langgraph-supervisor** | [langchain-ai/langgraphjs](https://github.com/langchain-ai/langgraphjs) | Build supervisor multi-agent systems with LangGraph | -12345 | ![GitHub stars](https://img.shields.io/github/stars/langchain-ai/langgraphjs?style=social)
+| **@langchain/langgraph-swarm** | [langchain-ai/langgraphjs](https://github.com/langchain-ai/langgraphjs) | Build multi-agent swarms with LangGraph | -12345 | ![GitHub stars](https://img.shields.io/github/stars/langchain-ai/langgraphjs?style=social)
+| **@langchain/langgraph-cua** | [langchain-ai/langgraphjs](https://github.com/langchain-ai/langgraphjs) | Build computer use agents with LangGraph | -12345 | ![GitHub stars](https://img.shields.io/github/stars/langchain-ai/langgraphjs?style=social)
+
+## ✨ Contributing Your Library
+
+Have you built an awesome open-source library using LangGraph? We'd love to feature 
+your project on the official LangGraph documentation pages! 🏆
+
+To share your project, simply open a Pull Request adding an entry for your package in our [packages.yml](https://github.com/langchain-ai/langgraph/blob/main/docs/_scripts/third_party_page/packages.yml) file.
+
+**Guidelines**
+
+- Your repo must be distributed as an installable package on npm 📦
+- The repo should either use the Graph API (exposing a `StateGraph` instance) or 
+  the Functional API (exposing an `entrypoint`).
+- The package must include documentation (e.g., a `README.md` or docs site) 
+  explaining how to use it.
+
+We'll review your contribution and merge it in!
+
+Thanks for contributing! 🚀
+:::

docs/docs/agents/run_agents.md

@@ -9,19 +9,28 @@ 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](../how-tos/streaming.md) output. This section explains how to provide input, interpret output, enable streaming, and control execution limits.
 
 ## Basic usage
 
 Agents can be executed in two primary modes:
 
-- **Synchronous** using `.invoke()` or `.stream()`
-- **Asynchronous** using `await .invoke()` or `async for` with `.astream()`
+:::python
 
+- **Synchronous** using `.invoke()` or `.stream()`
+- **Asynchronous** using `await .ainvoke()` or `async for` with `.astream()`
+  :::
+
+:::js
+
+- **Synchronous** using `.invoke()` or `.stream()`
+- **Asynchronous** using `await .invoke()` or `for await` with `.stream()`
+  :::
+
+:::python
 === "Sync invocation"
-    ```python
+
+    ````python
     from langgraph.prebuilt import create_react_agent
 
     agent = create_react_agent(...)
@@ -31,14 +40,33 @@ Agents can be executed in two primary modes:
     ```
 
 === "Async invocation"
-    ```python
-    from langgraph.prebuilt import create_react_agent
+
+````python
+from langgraph.prebuilt import create_react_agent
 
     agent = create_react_agent(...)
     # highlight-next-line
     response = await agent.ainvoke({"messages": [{"role": "user", "content": "what is the weather in sf"}]})
     ```
 
+:::
+
+:::js
+
+```typescript
+import { createReactAgent } from "@langchain/langgraph/prebuilt";
+
+const agent = createReactAgent(...);
+// highlight-next-line
+const response = await agent.invoke({
+    "messages": [
+        { "role": "user", "content": "what is the weather in sf" }
+    ]
+});
+````
+
+:::
+
 ## Inputs and outputs
 
 Agents use a language model that expects a list of `messages` as an input. Therefore, agent inputs and outputs are stored as a list of `messages` under the `messages` key in the agent [state](../concepts/low_level.md#working-with-messages-in-graph-state).
@@ -47,33 +75,73 @@ Agents use a language model that expects a list of `messages` as an input. There
 
 Agent input must be a dictionary with a `messages` key. Supported formats are:
 
-| Format             | Example                                                                                                                       |
+:::python
+| Format | Example |
 |--------------------|-------------------------------------------------------------------------------------------------------------------------------|
-| String             | `{"messages": "Hello"}`  — Interpreted as a [HumanMessage](https://python.langchain.com/docs/concepts/messages/#humanmessage) |
-| Message dictionary | `{"messages": {"role": "user", "content": "Hello"}}`                                                                          |
-| List of messages   | `{"messages": [{"role": "user", "content": "Hello"}]}`                                                                        |
-| With custom state  | `{"messages": [{"role": "user", "content": "Hello"}], "user_name": "Alice"}` — If using a custom `state_schema`               |
+| String | `{"messages": "Hello"}` — Interpreted as a [HumanMessage](https://python.langchain.com/docs/concepts/messages/#humanmessage) |
+| Message dictionary | `{"messages": {"role": "user", "content": "Hello"}}` |
+| List of messages | `{"messages": [{"role": "user", "content": "Hello"}]}` |
+| With custom state | `{"messages": [{"role": "user", "content": "Hello"}], "user_name": "Alice"}` — If using a custom `state_schema` |
+:::
 
+:::js
+| Format | Example |
+|--------------------|-------------------------------------------------------------------------------------------------------------------------------|
+| String | `{"messages": "Hello"}` — Interpreted as a [HumanMessage](https://js.langchain.com/docs/concepts/messages/#humanmessage) |
+| Message dictionary | `{"messages": {"role": "user", "content": "Hello"}}` |
+| List of messages | `{"messages": [{"role": "user", "content": "Hello"}]}` |
+| With custom state | `{"messages": [{"role": "user", "content": "Hello"}], "user_name": "Alice"}` — If using a custom state definition |
+:::
+
+:::python
 Messages are automatically converted into LangChain's internal message format. You can read
 more about [LangChain messages](https://python.langchain.com/docs/concepts/messages/#langchain-messages) in the LangChain documentation.
+:::
+
+:::js
+Messages are automatically converted into LangChain's internal message format. You can read
+more about [LangChain messages](https://js.langchain.com/docs/concepts/messages/#langchain-messages) in the LangChain documentation.
+:::
 
 !!! tip "Using custom agent state"
 
-    You can provide additional fields defined in your agent’s state schema directly in the input dictionary. This allows dynamic behavior based on runtime data or prior tool outputs.  
-    See the [context guide](./context.md) for full details.
+:::python
+You can provide additional fields defined in your agent's state schema directly in the input dictionary. This allows dynamic behavior based on runtime data or prior tool outputs.
+See the [context guide](./context.md) for full details.
+:::
+
+:::js
+You can provide additional fields defined in your agent's state directly in the state definition. This allows dynamic behavior based on runtime data or prior tool outputs.
+See the [context guide](./context.md) for full details.
+:::
 
 !!! note
 
-    A string input for `messages` is converted to a [HumanMessage](https://python.langchain.com/docs/concepts/messages/#humanmessage). This behavior differs from the `prompt` parameter in `create_react_agent`, which is interpreted as a [SystemMessage](https://python.langchain.com/docs/concepts/messages/#systemmessage) when passed as a string.
+:::python
+A string input for `messages` is converted to a [HumanMessage](https://python.langchain.com/docs/concepts/messages/#humanmessage). This behavior differs from the `prompt` parameter in `create_react_agent`, which is interpreted as a [SystemMessage](https://python.langchain.com/docs/concepts/messages/#systemmessage) when passed as a string.
+:::
 
+:::js
+A string input for `messages` is converted to a [HumanMessage](https://js.langchain.com/docs/concepts/messages/#humanmessage). This behavior differs from the `prompt` parameter in `createReactAgent`, which is interpreted as a [SystemMessage](https://js.langchain.com/docs/concepts/messages/#systemmessage) when passed as a string.
+:::
 
 ## Output format
 
+:::python
 Agent output is a dictionary containing:
 
 - `messages`: A list of all messages exchanged during execution (user input, assistant replies, tool invocations).
 - Optionally, `structured_response` if [structured output](./agents.md#6-configure-structured-output) is configured.
 - If using a custom `state_schema`, additional keys corresponding to your defined fields may also be present in the output. These can hold updated state values from tool execution or prompt logic.
+  :::
+
+:::js
+Agent output is a dictionary containing:
+
+- `messages`: A list of all messages exchanged during execution (user input, assistant replies, tool invocations).
+- Optionally, `structuredResponse` if [structured output](./agents.md#6-configure-structured-output) is configured.
+- If using a custom state definition, additional keys corresponding to your defined fields may also be present in the output. These can hold updated state values from tool execution or prompt logic.
+  :::
 
 See the [context guide](./context.md) for more details on working with custom state schemas and accessing context.
 
@@ -87,6 +155,7 @@ Agents support streaming responses for more responsive applications. This includ
 
 Streaming is available in both sync and async modes:
 
+:::python
 === "Sync streaming"
 
     ```python
@@ -107,14 +176,36 @@ Streaming is available in both sync and async modes:
         print(chunk)
     ```
 
+:::
+
+:::js
+
+```typescript
+for await (const chunk of agent.stream(
+  { messages: [{ role: "user", content: "what is the weather in sf" }] },
+  { streamMode: "updates" }
+)) {
+  console.log(chunk);
+}
+```
+
+:::
+
 !!! tip
 
-    For full details, see the [streaming guide](./streaming.md).
+    For full details, see the [streaming guide](../how-tos/streaming.md).
 
 ## Max iterations
 
+:::python
 To control agent execution and avoid infinite loops, set a recursion limit. This defines the maximum number of steps the agent can take before raising a `GraphRecursionError`. You can configure `recursion_limit` at runtime or when defining agent via `.with_config()`:
+:::
 
+:::js
+To control agent execution and avoid infinite loops, set a recursion limit. This defines the maximum number of steps the agent can take before raising a `GraphRecursionError`. You can configure `recursionLimit` at runtime or when defining agent via `.withConfig()`:
+:::
+
+:::python
 === "Runtime"
 
     ```python
@@ -163,6 +254,70 @@ To control agent execution and avoid infinite loops, set a recursion limit. This
         print("Agent stopped due to max iterations.")
     ```
 
+:::
+
+:::js
+=== "Runtime"
+
+    ```typescript
+    import { GraphRecursionError } from "@langchain/langgraph";
+    import { ChatAnthropic } from "@langchain/langgraph/prebuilt";
+    import { createReactAgent } from "@langchain/langgraph/prebuilt";
+
+    const maxIterations = 3;
+    // highlight-next-line
+    const recursionLimit = 2 * maxIterations + 1;
+    const agent = createReactAgent({
+        llm: new ChatAnthropic({ model: "claude-3-5-haiku-latest" }),
+        tools: [getWeather]
+    });
+
+    try {
+        const response = await agent.invoke(
+            {"messages": [{"role": "user", "content": "what's the weather in sf"}]},
+            // highlight-next-line
+            { recursionLimit }
+        );
+    } catch (error) {
+        if (error instanceof GraphRecursionError) {
+            console.log("Agent stopped due to max iterations.");
+        }
+    }
+    ```
+
+=== "`.withConfig()`"
+
+    ```typescript
+    import { GraphRecursionError } from "@langchain/langgraph";
+    import { ChatAnthropic } from "@langchain/langgraph/prebuilt";
+    import { createReactAgent } from "@langchain/langgraph/prebuilt";
+
+    const maxIterations = 3;
+    // highlight-next-line
+    const recursionLimit = 2 * maxIterations + 1;
+    const agent = createReactAgent({
+        llm: new ChatAnthropic({ model: "claude-3-5-haiku-latest" }),
+        tools: [getWeather]
+    });
+    // highlight-next-line
+    const agentWithRecursionLimit = agent.withConfig({ recursionLimit });
+
+    try {
+        const response = await agentWithRecursionLimit.invoke(
+            {"messages": [{"role": "user", "content": "what's the weather in sf"}]},
+        );
+    } catch (error) {
+        if (error instanceof GraphRecursionError) {
+            console.log("Agent stopped due to max iterations.");
+        }
+    }
+    ```
+
+:::
+
+:::python
+
 ## Additional Resources
 
-* [Async programming in LangChain](https://python.langchain.com/docs/concepts/async)
+- [Async programming in LangChain](https://python.langchain.com/docs/concepts/async)
+  :::

docs/docs/agents/streaming.md

@@ -1,223 +0,0 @@
----
-search:
-  boost: 2
-tags:
-  - agent
-hide:
-  - tags
----
-
-# Streaming
-
-Streaming is key to building responsive applications. There are a few types of data you’ll want to stream:
-
-1. [**Agent progress**](#agent-progress) — get updates after each node in the agent graph is executed.
-2. [**LLM tokens**](#llm-tokens) — stream tokens as they are generated by the language model.
-3. [**Custom updates**](#tool-updates) — emit custom data from tools during execution (e.g., "Fetched 10/100 records")
-
-You can stream [more than one type of data](#stream-multiple-modes) at a time. 
-
-
-<figure markdown="1">
-![image](./assets/fast_parrot.png){: style="max-height:300px"}
-<figcaption>
-Waiting is for pigeons.
-</figcaption>
-</figure>
-
-## Agent progress
-
-To stream agent progress, use the [`stream()`][langgraph.graph.state.CompiledStateGraph.stream] or [`astream()`][langgraph.graph.state.CompiledStateGraph.astream] methods with [`stream_mode="updates"`](https://langchain-ai.github.io/langgraph/how-tos/streaming/#updates). This emits an event after every agent step.
-
-For example, if you have an agent that calls a tool once, you should see the following updates:
-
-* **LLM node**: AI message with tool call requests
-* **Tool node**: Tool message with execution result
-* **LLM node**: Final AI response
-
-=== "Sync"
-
-    ```python
-    agent = create_react_agent(
-        model="anthropic:claude-3-7-sonnet-latest",
-        tools=[get_weather],
-    )
-    # highlight-next-line
-    for chunk in agent.stream(
-        {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
-        # highlight-next-line
-        stream_mode="updates"
-    ):
-        print(chunk)
-        print("\n")
-    ```
-
-=== "Async"
-
-    ```python
-    agent = create_react_agent(
-        model="anthropic:claude-3-7-sonnet-latest",
-        tools=[get_weather],
-    )
-    # highlight-next-line
-    async for chunk in agent.astream(
-        {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
-        # highlight-next-line
-        stream_mode="updates"
-    ):
-        print(chunk)
-        print("\n")
-    ```
-
-## LLM tokens
-
-To stream tokens as they are produced by the LLM, use `stream_mode="messages"`:
-
-=== "Sync"
-
-    ```python
-    agent = create_react_agent(
-        model="anthropic:claude-3-7-sonnet-latest",
-        tools=[get_weather],
-    )
-    # highlight-next-line
-    for token, metadata in agent.stream(
-        {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
-        # highlight-next-line
-        stream_mode="messages"
-    ):
-        print("Token", token)
-        print("Metadata", metadata)
-        print("\n")
-    ```
-
-=== "Async"
-
-    ```python
-    agent = create_react_agent(
-        model="anthropic:claude-3-7-sonnet-latest",
-        tools=[get_weather],
-    )
-    # highlight-next-line
-    async for token, metadata in agent.astream(
-        {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
-        # highlight-next-line
-        stream_mode="messages"
-    ):
-        print("Token", token)
-        print("Metadata", metadata)
-        print("\n")
-    ```
-
-## Tool updates
-
-To stream updates from tools as they are executed, you can use [get_stream_writer][langgraph.config.get_stream_writer].
-
-=== "Sync"
-
-    ```python
-    # highlight-next-line
-    from langgraph.config import get_stream_writer
-
-    def get_weather(city: str) -> str:
-        """Get weather for a given city."""
-        # highlight-next-line
-        writer = get_stream_writer()
-        # stream any arbitrary data
-        # highlight-next-line
-        writer(f"Looking up data for city: {city}")
-        return f"It's always sunny in {city}!"
-
-    agent = create_react_agent(
-        model="anthropic:claude-3-7-sonnet-latest",
-        tools=[get_weather],
-    )
-
-    for chunk in agent.stream(
-        {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
-        # highlight-next-line
-        stream_mode="custom"
-    ):
-        print(chunk)
-        print("\n")
-    ```
-
-=== "Async"
-
-    ```python
-    # highlight-next-line
-    from langgraph.config import get_stream_writer
-
-    def get_weather(city: str) -> str:
-        """Get weather for a given city."""
-        # highlight-next-line
-        writer = get_stream_writer()
-        # stream any arbitrary data
-        # highlight-next-line
-        writer(f"Looking up data for city: {city}")
-        return f"It's always sunny in {city}!"
-
-    agent = create_react_agent(
-        model="anthropic:claude-3-7-sonnet-latest",
-        tools=[get_weather],
-    )
-
-    async for chunk in agent.astream(
-        {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
-        # highlight-next-line
-        stream_mode="custom"
-    ):
-        print(chunk)
-        print("\n")
-    ```
-
-!!! Note
-    If you add `get_stream_writer` inside your tool, you won't be able to invoke the tool outside of a LangGraph execution context. 
-
-## Stream multiple modes
-
-You can specify multiple streaming modes by passing stream mode as a list: `stream_mode=["updates", "messages", "custom"]`:
-
-=== "Sync"
-
-    ```python
-    agent = create_react_agent(
-        model="anthropic:claude-3-7-sonnet-latest",
-        tools=[get_weather],
-    )
-
-    for stream_mode, chunk in agent.stream(
-        {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
-        # highlight-next-line
-        stream_mode=["updates", "messages", "custom"]
-    ):
-        print(chunk)
-        print("\n")
-    ```
-
-=== "Async"
-
-    ```python
-    agent = create_react_agent(
-        model="anthropic:claude-3-7-sonnet-latest",
-        tools=[get_weather],
-    )
-
-    async for stream_mode, chunk in agent.astream(
-        {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
-        # highlight-next-line
-        stream_mode=["updates", "messages", "custom"]
-    ):
-        print(chunk)
-        print("\n")
-    ```
-
-## Disable streaming
-
-In some applications you might need to disable streaming of individual tokens for a given model. This is useful in [multi-agent](./multi-agent.md) systems to control which agents stream their output.
-
-See the [Models](./models.md#disable-streaming) guide to learn how to disable streaming.
-
-## Additional resources
-
-* [Streaming in LangGraph](https://langchain-ai.github.io/langgraph/how-tos/streaming)

docs/docs/agents/tools.md

@@ -9,6 +9,7 @@ hide:
 
 # Tools
 
+:::python
 [Tools](https://python.langchain.com/docs/concepts/tools/) are a way to encapsulate a function and its input schema in a way that can be passed to a chat model that supports tool calling. This allows the model to request the execution of this function with specific inputs.
 
 You can either [define your own tools](#define-simple-tools) or use [prebuilt integrations](#prebuilt-tools) that LangChain provides.
@@ -31,9 +32,37 @@ create_react_agent(
 ```
 
 `create_react_agent` automatically converts vanilla functions to [LangChain tools](https://python.langchain.com/docs/concepts/tools/#tool-interface).
+:::
+
+:::js
+[Tools](https://js.langchain.com/docs/concepts/tools/) are a way to encapsulate a function and its input schema in a way that can be passed to a chat model that supports tool calling. This allows the model to request the execution of this function with specific inputs.
+
+You can either [define your own tools](#define-simple-tools) or use [prebuilt integrations](#prebuilt-tools) that LangChain provides.
+
+## Define simple tools
+
+You can pass a vanilla function to `createReactAgent` to use as a tool:
+
+```typescript
+import { ChatAnthropic } from "@langchain/anthropic";
+import { createReactAgent } from "@langchain/langgraph/prebuilt";
+
+function multiply(a: number, b: number): number {
+  return a * b;
+}
+
+createReactAgent({
+  llm: new ChatAnthropic({ model: "anthropic:claude-3-7-sonnet" }),
+  tools: [multiply],
+});
+```
+
+`createReactAgent` automatically converts vanilla functions to [LangChain tools](https://js.langchain.com/docs/concepts/tools/#tool-interface).
+:::
 
 ## Customize tools
 
+:::python
 For more control over tool behavior, use the `@tool` decorator:
 
 ```python
@@ -69,6 +98,34 @@ def multiply(a: int, b: int) -> int:
 ```
 
 For additional customization, refer to the [custom tools guide](https://python.langchain.com/docs/how_to/custom_tools/).
+:::
+
+:::js
+For more control over tool behavior, use the `tool` function:
+
+```typescript
+// highlight-next-line
+import { tool } from "@langchain/core/tools";
+import { z } from "zod";
+
+// highlight-next-line
+const multiply = tool(
+  (input) => {
+    return input.a * input.b;
+  },
+  {
+    name: "multiply_tool",
+    description: "Multiply two numbers",
+    schema: z.object({
+      a: z.number().describe("First operand"),
+      b: z.number().describe("Second operand"),
+    }),
+  }
+);
+```
+
+For additional customization, refer to the [custom tools guide](https://js.langchain.com/docs/how_to/custom_tools/).
+:::
 
 ## Hide arguments from the model
 
@@ -77,6 +134,8 @@ Some tools require runtime-only arguments (e.g., user ID or session context) tha
 You can put these arguments in the `state` or `config` of the agent, and access
 this information inside the tool:
 
+:::python
+
 ```python
 from langgraph.prebuilt import InjectedState
 from langgraph.prebuilt.chat_agent_executor import AgentState
@@ -98,11 +157,49 @@ def my_tool(
     ...
 ```
 
+:::
+
+:::js
+
+```typescript
+import { tool } from "@langchain/core/tools";
+import { LangGraphRunnableConfig } from "@langchain/langgraph";
+import { z } from "zod";
+
+const myTool = tool(
+  async (input, config: LangGraphRunnableConfig) => {
+    // This will be populated by an LLM
+    const toolArg = input.toolArg;
+
+    // access information that's dynamically updated inside the agent
+    // highlight-next-line
+    const state = config.store;
+
+    // access static data that is passed at agent invocation
+    // highlight-next-line
+    const userId = config.configurable?.userId;
+
+    // Use state and config in your tool logic
+    return "Tool result";
+  },
+  {
+    name: "my_tool",
+    description: "My tool",
+    schema: z.object({
+      toolArg: z.string().describe("Tool argument"),
+    }),
+  }
+);
+```
+
+:::
+
 ## Disable parallel tool calling
 
 Some model providers support executing multiple tools in parallel, but
 allow users to disable this feature.
 
+:::python
 For supported providers, you can disable parallel tool calling by setting `parallel_tool_calls=False` via the `model.bind_tools()` method:
 
 ```python
@@ -130,8 +227,58 @@ agent.invoke(
 )
 ```
 
+:::
+
+:::js
+For supported providers, you can disable parallel tool calling by setting `parallel_tool_calls: false` via the `bindTools()` method:
+
+```typescript
+import { ChatAnthropic } from "@langchain/anthropic";
+import { tool } from "@langchain/core/tools";
+import { createReactAgent } from "@langchain/langgraph/prebuilt";
+import { z } from "zod";
+
+const add = tool((input) => input.a + input.b, {
+  name: "add",
+  description: "Add two numbers",
+  schema: z.object({
+    a: z.number(),
+    b: z.number(),
+  }),
+});
+
+const multiply = tool((input) => input.a * input.b, {
+  name: "multiply",
+  description: "Multiply two numbers",
+  schema: z.object({
+    a: z.number(),
+    b: z.number(),
+  }),
+});
+
+const model = new ChatAnthropic({
+  model: "claude-3-5-sonnet-latest",
+  temperature: 0,
+});
+const tools = [add, multiply];
+
+const agent = createReactAgent({
+  // disable parallel tool calls
+  // highlight-next-line
+  llm: model.bindTools(tools, { parallel_tool_calls: false }),
+  tools,
+});
+
+await agent.invoke({
+  messages: [{ role: "user", content: "what's 3 + 5 and 4 * 7?" }],
+});
+```
+
+:::
+
 ## Return tool results directly
 
+:::python
 Use `return_direct=True` to return tool results immediately and stop the agent loop:
 
 ```python
@@ -153,8 +300,42 @@ agent.invoke(
 )
 ```
 
+:::
+
+:::js
+Use `returnDirect: true` to return tool results immediately and stop the agent loop:
+
+```typescript
+import { tool } from "@langchain/core/tools";
+import { z } from "zod";
+
+// highlight-next-line
+const add = tool((input) => input.a + input.b, {
+  name: "add",
+  description: "Add two numbers",
+  schema: z.object({
+    a: z.number(),
+    b: z.number(),
+  }),
+  // highlight-next-line
+  returnDirect: true,
+});
+
+const agent = createReactAgent({
+  llm: model,
+  tools: [add],
+});
+
+await agent.invoke({
+  messages: [{ role: "user", content: "what's 3 + 5?" }],
+});
+```
+
+:::
+
 ## Force tool use
 
+:::python
 To force the agent to use specific tools, you can set the `tool_choice` option in `model.bind_tools()`:
 
 ```python
@@ -179,6 +360,41 @@ agent.invoke(
 )
 ```
 
+:::
+
+:::js
+To force the agent to use specific tools, you can set the `tool_choice` option in `bindTools()`:
+
+```typescript
+import { tool } from "@langchain/core/tools";
+import { z } from "zod";
+
+// highlight-next-line
+const greet = tool((input) => `Hello ${input.userName}!`, {
+  name: "greet",
+  description: "Greet user",
+  schema: z.object({
+    userName: z.string(),
+  }),
+  // highlight-next-line
+  returnDirect: true,
+});
+
+const tools = [greet];
+
+const agent = createReactAgent({
+  // highlight-next-line
+  llm: model.bindTools(tools, { tool_choice: { type: "tool", name: "greet" } }),
+  tools,
+});
+
+await agent.invoke({
+  messages: [{ role: "user", content: "Hi, I am Bob" }],
+});
+```
+
+:::
+
 !!! Warning "Avoid infinite loops"
 
     Forcing tool usage without stopping conditions can create infinite loops. Use one of the following safeguards:
@@ -188,10 +404,17 @@ agent.invoke(
 
 ## Handle tool errors
 
+:::python
 By default, the agent will catch all exceptions raised during tool calls and will pass those as tool messages to the LLM. To control how the errors are handled, you can use the prebuilt [`ToolNode`][langgraph.prebuilt.tool_node.ToolNode] — the node that executes tools inside `create_react_agent` — via its `handle_tool_errors` parameter:
+:::
+
+:::js
+By default, the agent will catch all exceptions raised during tool calls and will pass those as tool messages to the LLM. To control how the errors are handled, you can use the prebuilt [`ToolNode`][<insert-ref>] — the node that executes tools inside `createReactAgent` — via its `handleToolErrors` parameter:
+:::
 
 === "Enable error handling (default)"
 
+    :::python
     ```python
     from langgraph.prebuilt import create_react_agent
 
@@ -210,9 +433,47 @@ By default, the agent will catch all exceptions raised during tool calls and wil
         {"messages": [{"role": "user", "content": "what's 42 x 7?"}]}
     )
     ```
+    :::
+
+    :::js
+    ```typescript
+    import { ChatAnthropic } from "@langchain/anthropic";
+    import { createReactAgent } from "@langchain/langgraph/prebuilt";
+    import { tool } from "@langchain/core/tools";
+    import { z } from "zod";
+
+    const multiply = tool(
+      (input) => {
+        if (input.a === 42) {
+          throw new Error("The ultimate error");
+        }
+        return input.a * input.b;
+      },
+      {
+        name: "multiply",
+        description: "Multiply two numbers",
+        schema: z.object({
+          a: z.number(),
+          b: z.number(),
+        }),
+      }
+    );
+
+    // Run with error handling (default)
+    const agent = createReactAgent({
+      llm: new ChatAnthropic({ model: "claude-3-7-sonnet-latest" }),
+      tools: [multiply]
+    });
+
+    await agent.invoke({
+      messages: [{ role: "user", content: "what's 42 x 7?" }]
+    });
+    ```
+    :::
 
 === "Disable error handling"
 
+    :::python
     ```python
     from langgraph.prebuilt import create_react_agent, ToolNode
 
@@ -238,9 +499,58 @@ By default, the agent will catch all exceptions raised during tool calls and wil
     ```
 
     1. This disables error handling (enabled by default). See all available strategies in the [API reference][langgraph.prebuilt.tool_node.ToolNode].
+    :::
+
+    :::js
+    ```typescript
+    import { ChatAnthropic } from "@langchain/anthropic";
+    import { createReactAgent } from "@langchain/langgraph/prebuilt";
+    import { ToolNode } from "@langchain/langgraph/prebuilt";
+    import { tool } from "@langchain/core/tools";
+    import { z } from "zod";
+
+    const multiply = tool(
+      (input) => {
+        if (input.a === 42) {
+          throw new Error("The ultimate error");
+        }
+        return input.a * input.b;
+      },
+      {
+        name: "multiply",
+        description: "Multiply two numbers",
+        schema: z.object({
+          a: z.number(),
+          b: z.number(),
+        }),
+      }
+    );
+
+    // highlight-next-line
+    const toolNode = new ToolNode(
+      [multiply],
+      {
+        // highlight-next-line
+        handleToolErrors: false  // (1)!
+      }
+    );
+
+    const agentNoErrorHandling = createReactAgent({
+      llm: new ChatAnthropic({ model: "claude-3-7-sonnet-latest" }),
+      tools: toolNode
+    });
+
+    await agentNoErrorHandling.invoke({
+      messages: [{ role: "user", content: "what's 42 x 7?" }]
+    });
+    ```
+
+    1. This disables error handling (enabled by default). See all available strategies in the [API reference][toolnode].
+    :::
 
 === "Custom error handling"
 
+    :::python
     ```python
     from langgraph.prebuilt import create_react_agent, ToolNode
 
@@ -268,21 +578,115 @@ By default, the agent will catch all exceptions raised during tool calls and wil
     ```
 
     1. This provides a custom message to send to the LLM in case of an exception. See all available strategies in the [API reference][langgraph.prebuilt.tool_node.ToolNode].
+    :::
 
+    :::js
+    ```typescript
+    import { ChatAnthropic } from "@langchain/anthropic";
+    import { createReactAgent } from "@langchain/langgraph/prebuilt";
+    import { ToolNode } from "@langchain/langgraph/prebuilt";
+    import { tool } from "@langchain/core/tools";
+    import { z } from "zod";
+
+    const multiply = tool(
+      (input) => {
+        if (input.a === 42) {
+          throw new Error("The ultimate error");
+        }
+        return input.a * input.b;
+      },
+      {
+        name: "multiply",
+        description: "Multiply two numbers",
+        schema: z.object({
+          a: z.number(),
+          b: z.number(),
+        }),
+      }
+    );
+
+    // highlight-next-line
+    const toolNode = new ToolNode(
+      [multiply],
+      {
+        // highlight-next-line
+        handleToolErrors: "Can't use 42 as a first operand, you must switch operands!"  // (1)!
+      }
+    );
+
+    const agentCustomErrorHandling = createReactAgent({
+      llm: new ChatAnthropic({ model: "claude-3-7-sonnet-latest" }),
+      tools: toolNode
+    });
+
+    await agentCustomErrorHandling.invoke({
+      messages: [{ role: "user", content: "what's 42 x 7?" }]
+    });
+    ```
+
+    1. This provides a custom message to send to the LLM in case of an exception. See all available strategies in the [API reference][toolnode].
+    :::
+
+:::python
 See [API reference][langgraph.prebuilt.tool_node.ToolNode] for more information on different tool error handling options.
+:::
+
+:::js
+See [API reference][toolnode] for more information on different tool error handling options.
+:::
 
 ## Working with memory
 
-LangGraph allows access to short-term and long-term memory from tools. See [Memory](./memory.md) guide for more information on:
+LangGraph allows access to short-term and long-term memory from tools. See [Memory](../how-tos/memory/add-memory.md) guide for more information on:
 
-* how to [read](./memory.md#read-short-term) from and [write](./memory.md#write-short-term) to **short-term** memory
-* how to [read](./memory.md#read-long-term) from and [write](./memory.md#write-long-term) to **long-term** memory
+- how to [read](../how-tos/memory/add-memory.md#read-short-term) from and [write](../how-tos/memory/add-memory.md#write-short-term) to **short-term** memory
+- how to [read](../how-tos/memory/add-memory.md#read-long-term) from and [write](../how-tos/memory/add-memory.md#write-long-term) to **long-term** memory
 
 ## 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.
+:::python
+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/).
+:::
+
+:::js
+You can use prebuilt tools from model providers by passing a dictionary with tool specs to the `tools` parameter of `createReactAgent`. For example, to use the `web_search_preview` tool from OpenAI:
+
+```typescript
+import { ChatAnthropic } from "@langchain/anthropic";
+import { createReactAgent } from "@langchain/langgraph/prebuilt";
+
+const agent = createReactAgent({
+  llm: new ChatAnthropic({ model: "claude-3-7-sonnet-latest" }),
+  tools: [{ type: "web_search_preview" }],
+});
+
+const response = await agent.invoke({
+  messages: [
+    { role: "user", content: "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://js.langchain.com/docs/integrations/tools/).
+:::
 
 Some commonly used tool categories include:
 
@@ -293,4 +697,3 @@ Some commonly used tool categories include:
 - **APIs**: OpenWeatherMap, NewsAPI, and others
 
 These integrations can be configured and added to your agents using the same `tools` parameter shown in the examples above.
-

docs/docs/agents/ui.md

@@ -25,7 +25,7 @@ Then, navigate to [Agent Chat UI](https://agentchat.vercel.app), or clone the re
 
 ## Add human-in-the-loop
 
-Agent Chat UI has full support for [human-in-the-loop](../concepts/human_in_the_loop.md) workflows. To try it out, replace the agent code in `src/agent/graph.py` (from the [deployment](./deployment.md) guide) with this [agent implementation](./human-in-the-loop.md#using-with-agent-inbox):
+Agent Chat UI has full support for [human-in-the-loop](../concepts/human_in_the_loop.md) workflows. To try it out, replace the agent code in `src/agent/graph.py` (from the [deployment](./deployment.md) guide) with this [agent implementation](../how-tos/human_in_the_loop/add-human-in-the-loop.md#add-interrupts-to-any-tool):
 
 <video controls src="../assets/interrupt-chat-ui.mp4" type="video/mp4"></video>
 

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

@@ -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__;"
+}
+  

docs/docs/cloud/concepts/runs.md

@@ -1,5 +0,0 @@
-# Runs
-
-A run is an invocation of an [assistant](../../concepts/assistants.md). Each run may have its own input, configuration, and metadata, which may affect execution and output of the underlying graph. A run can optionally be executed on a [thread](./threads.md).
-
-The LangGraph Platform API provides several endpoints for creating and managing runs. See the [API reference](../../cloud/reference/api/api_ref.html#tag/thread-runs/) for more details.

docs/docs/cloud/concepts/streaming.md

@@ -1,138 +0,0 @@
-# Streaming
-
-Streaming is critical for making LLM applications feel responsive to end users.  
-When creating a streaming run, the **streaming mode** determines what kinds of data are streamed back to the API client.
-
-## Supported streaming modes
-
-LangGraph Platform supports the following streaming modes:
-
-| Mode                 | Description                                                                                                                                                    | LangGraph Library Method                                                |
-|----------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------|
-| **`values`**         | Stream the full graph state after each [super-step](https://langchain-ai.github.io/langgraph/concepts/low_level/#graphs). [Guide](../how-tos/streaming.md#stream-graph-state) | `.stream()` / `.astream()` with `stream_mode="values"`                  |
-| **`updates`**        | Stream only the updates to the graph state after each node. [Guide](../how-tos/streaming.md#stream-graph-state)                                                              | `.stream()` / `.astream()` with `stream_mode="updates"`                 |
-| **`messages-tuple`** | Stream LLM tokens for any messages generated inside the graph (useful for chat apps). [Guide](../how-tos/streaming.md#messages)                                   | `.stream()` / `.astream()` with `stream_mode="messages"`                |
-| **`debug`**          | Stream debug information throughout graph execution. [Guide](../how-tos/streaming.md#debug)                                                                       | `.stream()` / `.astream()` with `stream_mode="debug"`                   |
-| **`custom`**         | Stream custom data. [Guide](../../how-tos/streaming.md#stream-custom-data)                                                                                                                                             | `.stream()` / `.astream()` with `stream_mode="custom"`                  |
-| **`events`**         | Stream all events (including the state of the graph); mainly useful when migrating large LCEL apps. [Guide](../how-tos/streaming.md#stream-events)                       | `.astream_events()`                                                     |
-
-✅ You can also **combine multiple modes** at the same time.  See the [how-to guide](../how-tos/streaming.md#stream-multiple-modes) for configuration details.
-
-## Stateless runs
-
-If you don't want to **persist the outputs** of a streaming run in the [checkpointer](../../concepts/persistence.md) DB, you can create a stateless run without creating a thread:
-
-=== "Python"
-
-    ```python
-    from langgraph_sdk import get_client
-    client = get_client(url=<DEPLOYMENT_URL>, api_key=<API_KEY>)
-
-    async for chunk in client.runs.stream(
-        # highlight-next-line
-        None,  # (1)!
-        assistant_id,
-        input=inputs,
-        stream_mode="updates"
-    ):
-        print(chunk.data)
-    ```
-
-    1. We are passing `None` instead of a `thread_id` UUID.
-
-=== "JavaScript"
-
-    ```js
-    import { Client } from "@langchain/langgraph-sdk";
-    const client = new Client({ apiUrl: <DEPLOYMENT_URL>, apiKey: <API_KEY> });
-
-    // create a streaming run
-    // highlight-next-line
-    const streamResponse = client.runs.stream(
-      // highlight-next-line
-      null,  // (1)!
-      assistantID,
-      {
-        input,
-        streamMode: "updates"
-      }
-    );
-    for await (const chunk of streamResponse) {
-      console.log(chunk.data);
-    }
-    ```
-
-    1. We are passing `None` instead of a `thread_id` UUID.
-
-=== "cURL"
-
-    ```bash
-    curl --request POST \
-    --url <DEPLOYMENT_URL>/runs/stream \
-    --header 'Content-Type: application/json' \
-    --header 'x-api-key: <API_KEY>'
-    --data "{
-      \"assistant_id\": \"agent\",
-      \"input\": <inputs>,
-      \"stream_mode\": \"updates\"
-    }"
-    ```
-
-## Join and stream
-
-LangGraph Platform allows you to join an active [background run](../how-tos/background_run.md) and stream outputs from it. To do so, you can use [LangGraph SDK's](https://langchain-ai.github.io/langgraph/cloud/reference/sdk/python_sdk_ref/) `client.runs.join_stream` method:
-
-=== "Python"
-
-    ```python
-    from langgraph_sdk import get_client
-    client = get_client(url=<DEPLOYMENT_URL>, api_key=<API_KEY>)
-
-    # highlight-next-line
-    async for chunk in client.runs.join_stream(
-        thread_id,
-        # highlight-next-line
-        run_id,  # (1)!
-    ):
-        print(chunk)
-    ```
-
-    1. This is the `run_id` of an existing run you want to join.
-
-
-=== "JavaScript"
-
-    ```js
-    import { Client } from "@langchain/langgraph-sdk";
-    const client = new Client({ apiUrl: <DEPLOYMENT_URL>, apiKey: <API_KEY> });
-
-    // highlight-next-line
-    const streamResponse = client.runs.joinStream(
-      threadID,
-      // highlight-next-line
-      runId  // (1)!
-    );
-    for await (const chunk of streamResponse) {
-      console.log(chunk);
-    }
-    ```
-
-    1. This is the `run_id` of an existing run you want to join.
-
-=== "cURL"
-
-    ```bash
-    curl --request GET \
-    --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/<RUN_ID>/stream \
-    --header 'Content-Type: application/json' \
-    --header 'x-api-key: <API_KEY>'
-    ```
-
-!!! warning "Outputs not buffered"
-
-    When you use `.join_stream`, output is not buffered, so any output produced before joining will not be received.
-
-## API Reference
-
-For API usage and implementation, refer to the [API reference](../reference/api/api_ref.html#tag/thread-runs/POST/threads/{thread_id}/runs/stream). 
-

docs/docs/cloud/concepts/threads.md

@@ -1,6 +1,6 @@
 # Threads
 
-A thread contains the accumulated state of a sequence of [runs](./runs.md). When a run is executed, the [state](../../concepts/low_level.md#state) of the underlying graph of the assistant will be persisted to the thread.
+A thread contains the accumulated state of a sequence of [runs](../../concepts/assistants.md#execution). When a run is executed, the [state](../../concepts/low_level.md#state) of the underlying graph of the assistant will be persisted to the thread.
 
 A thread's current and historical state can be retrieved. To persist state, a thread must be created prior to executing a run.
 

docs/docs/cloud/concepts/webhooks.md

@@ -2,6 +2,6 @@
 
 Webhooks enable event-driven communication from your LangGraph Platform application to external services. For example, you may want to issue an update to a separate service once an API call to LangGraph Platform has finished running.
 
-Many LangGraph Platform endpoints accept a `webhook` parameter. If this parameter is specified by 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.

docs/docs/cloud/deployment/cloud.md

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

docs/docs/cloud/deployment/custom_docker.md

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

docs/docs/cloud/deployment/self_hosted_control_plane.md

@@ -2,8 +2,8 @@
 
 Before deploying, review the [conceptual guide for the Self-Hosted Control Plane](../../concepts/langgraph_self_hosted_control_plane.md) deployment option.
 
-!!! 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

docs/docs/cloud/deployment/self_hosted_data_plane.md

@@ -2,8 +2,8 @@
 
 Before deploying, review the [conceptual guide for the Self-Hosted Data Plane](../../concepts/langgraph_self_hosted_data_plane.md) deployment option.
 
-!!! 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

docs/docs/cloud/deployment/setup.md

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

docs/docs/cloud/deployment/setup_javascript.md

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

docs/docs/cloud/deployment/setup_pyproject.md

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

docs/docs/cloud/how-tos/add-human-in-the-loop.md

@@ -1,38 +1,8 @@
-# Human-in-the-loop
+# Human-in-the-loop using Server API
 
-LangGraph supports robust **human-in-the-loop (HIL)** workflows, enabling human intervention at any point in an automated process. This is especially useful in large language model (LLM)-driven applications where model output may require validation, correction, or additional context.
+To review, edit, and approve tool calls in an agent or workflow, use LangGraph's [human-in-the-loop](../../concepts/human_in_the_loop.md) features.
 
-Please see [the overview of LangGraph human-in-the-loop](../../concepts/human_in_the_loop.md) features for more information.
-
-## `interrupt`
-
-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.
-
-**Graph node with `interrupt`:**
-
-```python
-# highlight-next-line
-from langgraph.types import interrupt, Command
-
-def human_node(state: State):
-    # highlight-next-line
-    value = interrupt( # (1)!
-        {
-            "text_to_revise": state["some_text"] # (2)!
-        }
-    )
-    return {
-        "some_text": value # (3)!
-    }
-```
-
-1. `interrupt(...)` pauses execution at `human_node`, surfacing the given payload to a human.
-2. Any JSON serializable value can be passed to the `interrupt` function. Here, a dict containing the text to revise.
-3. Once resumed, the return value of `interrupt(...)` is the human-provided input, which is used to update the state.
-
-**LangGraph API invoke & resume:**
+## LangGraph API invoke & resume
 
 === "Python"
 
@@ -337,6 +307,5 @@ def human_node(state: State):
 
 ## Learn more
 
-- [**LangGraph human-in-the-loop overview**](../../concepts/human_in_the_loop.md): learn more about LangGraph human-in-the-loop features. 
-- [**Design patterns**](../../how-tos/human_in_the_loop/add-human-in-the-loop.md#design-patterns): learn how to implement patterns like approving/rejecting actions, requesting user input, and more.
-- [**How to review tool calls**](./human_in_the_loop_review_tool_calls.md): detailed examples of how to review and approve/edit tool calls or provide feedback to the tool-calling LLM.
+- [Human-in-the-loop conceptual guide](../../concepts/human_in_the_loop.md): learn more about LangGraph human-in-the-loop features. 
+- [Common patterns](../../how-tos/human_in_the_loop/add-human-in-the-loop.md#common-patterns): learn how to implement patterns like approving/rejecting actions, requesting user input, tool call review, and validating human input.

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

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

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

@@ -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`.
 
@@ -212,6 +212,7 @@ We have now created an assistant called "Open AI Assistant" that has `model_name
 
 Output:
 
+    ```
     Receiving event of type: metadata
     {'run_id': '1ef6746e-5893-67b1-978a-0f1cd4060e16'}
 
@@ -219,6 +220,7 @@ Output:
 
     Receiving event of type: updates
     {'agent': {'messages': [{'content': 'I was created by OpenAI, a research organization focused on developing and advancing artificial intelligence technology.', 'additional_kwargs': {}, 'response_metadata': {'finish_reason': 'stop', 'model_name': 'gpt-4o-2024-05-13', 'system_fingerprint': 'fp_157b3831f5'}, 'type': 'ai', 'name': None, 'id': 'run-e1a6b25c-8416-41f2-9981-f9cfe043f414', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}}
+    ```
 
 ### LangGraph Platform UI
 
@@ -228,12 +230,14 @@ 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"
 
     ```python
@@ -321,7 +325,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.

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

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

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

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