bump checkpoint sqlite, postgres (#3021)

Example screenshot:

![image](https://github.com/user-attachments/assets/8304b08d-bc9b-4cd3-8ff4-ed2471d3d6c7)

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -7,35 +7,29 @@ body:
       value: >
         Thank you for taking the time to file a bug report. 
         
-        Use this to report bugs in LangChain. 
-        
-        If you're not certain that your issue is due to a bug in LangChain, please use [GitHub Discussions](https://github.com/langchain-ai/langchain/discussions)
-        to ask for help with your issue.
+        Use this to report BUGS in LangGraph. For usage questions, feature requests and general design questions, please use [GitHub Discussions](https://github.com/langchain-ai/langgraph/discussions).
         
         Relevant links to check before filing a bug report to see if your issue has already been reported, fixed or
         if there's another way to solve your problem:
         
-        [LangGraph documentation](https://langchain-ai.github.io/langgraph/).
+        [LangGraph Github Discussions](https://github.com/langchain-ai/langgraph/discussions),
+        [LangGraph Github Issues](https://github.com/langchain-ai/langgraph/issues),
+        [LangGraph how-to guides](https://langchain-ai.github.io/langgraph/how-tos/).
         [LangChain documentation with the integrated search](https://python.langchain.com/docs/get_started/introduction),
         [GitHub search](https://github.com/langchain-ai/langgraph),
-        [LangChain Github Discussions](https://github.com/langchain-ai/langgraph/discussions),
-        [LangChain Github Issues](https://github.com/langchain-ai/langgraph/issues),
-        [LangChain ChatBot](https://chat.langchain.com/)
   - type: checkboxes
     id: checks
     attributes:
       label: Checked other resources
-      description: Please confirm and check all the following options.
+      description: Before submitting this issue, please confirm that you have completed all the steps below by checking each option. These steps help ensure your issue is well-defined, relevant, and actionable.
       options:
-        - label: I added a very descriptive title to this issue.
+        - label: This is a bug, not a usage question. For questions, please use GitHub Discussions.
           required: true
-        - label: I searched the [LangGraph](https://langchain-ai.github.io/langgraph/)/LangChain documentation with the integrated search.
+        - label: I added a clear and detailed title that summarizes the issue.
           required: true
-        - label: I used the GitHub search to find a similar question and didn't find it.
+        - label: I read what a minimal reproducible example is (https://stackoverflow.com/help/minimal-reproducible-example).
           required: true
-        - label: I am sure that this is a bug in LangGraph/LangChain rather than my code.
-          required: true
-        - label: I am sure this is better as an issue [rather than a GitHub discussion](https://github.com/langchain-ai/langgraph/discussions/new/choose), since this is a LangGraph bug and not a design question.
+        - label: I included a self-contained, minimal example that demonstrates the issue INCLUDING all the relevant imports. The code run AS IS to reproduce the issue.
           required: true
   - type: textarea
     id: reproduction
@@ -45,14 +39,6 @@ body:
       label: Example Code
       description: |
         Please add a self-contained, [minimal, reproducible, example](https://stackoverflow.com/help/minimal-reproducible-example) with your use case.
-        
-        If a maintainer can copy it, run it, and see it right away, there's a much higher chance that you'll be able to get help.
-        
-        **Important!** 
-        
-        * Reduce your code to the minimum required to reproduce the issue if possible. This makes it much easier for others to help you.
-        * Avoid screenshots when possible, as they are hard to read and (more importantly) don't allow others to copy-and-paste your code.
-
       placeholder: |
         from langgraph.graph import StateGraph
 
@@ -92,25 +78,8 @@ body:
     attributes:
       label: System Info
       description: |
-        Please share your system info with us. 
-        
-        "pip freeze | grep langchain" 
-        platform (windows / linux / mac)
-        python version
-        
-        OR if you're on a recent version of langchain-core you can paste the output of:
-        
         python -m langchain_core.sys_info
       placeholder: |
-        "pip freeze | grep langgraph"
-        platform
-        python version
-        
-        Alternatively, if you're on a recent version of langchain-core you can paste the output of:
-        
         python -m langchain_core.sys_info
-        
-        These will only surface LangChain packages, don't forget to include any other relevant
-        packages you're using (if you're not sure what's relevant, you can paste the entire output of `pip freeze`).
     validations:
       required: true

.github/scripts/check_sdk_methods.py

@@ -0,0 +1,64 @@
+import ast
+import os
+from itertools import filterfalse
+from typing import List, Tuple
+
+ROOT_PATH = os.path.abspath(os.path.join(__file__, "..", "..", ".."))
+CLIENT_PATH = os.path.join(ROOT_PATH, "libs", "sdk-py", "langgraph_sdk", "client.py")
+
+
+def get_class_methods(node: ast.ClassDef) -> List[str]:
+    return [n.name for n in node.body if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))]
+
+
+def find_classes(tree: ast.AST) -> List[Tuple[str, List[str]]]:
+    classes = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef):
+            methods = get_class_methods(node)
+            classes.append((node.name, methods))
+    return classes
+
+
+def compare_sync_async_methods(sync_methods: List[str], async_methods: List[str]) -> List[str]:
+    sync_set = set(sync_methods)
+    async_set = set(async_methods)
+    missing_in_sync = list(async_set - sync_set)
+    missing_in_async = list(sync_set - async_set)
+    return missing_in_sync + missing_in_async
+
+
+def main():
+    with open(CLIENT_PATH, "r") as file:
+        tree = ast.parse(file.read())
+
+    classes = find_classes(tree)
+  
+    def is_sync(class_spec: Tuple[str, List[str]]) -> bool:
+        return class_spec[0].startswith("Sync")
+
+    sync_class_name_to_methods = {class_name: class_methods for class_name, class_methods in filter(is_sync, classes)}
+    async_class_name_to_methods = {class_name: class_methods for class_name, class_methods in filterfalse(is_sync, classes)}
+
+    mismatches = []
+
+    for async_class_name, async_class_methods in async_class_name_to_methods.items():
+        sync_class_name = "Sync" + async_class_name
+        sync_class_methods = sync_class_name_to_methods.get(sync_class_name, [])
+        diff = compare_sync_async_methods(sync_class_methods, async_class_methods)
+        if diff:
+            mismatches.append((sync_class_name, async_class_name, diff))
+
+    if mismatches:
+        error_message = "Mismatches found between sync and async client methods:\n"
+        for sync_class_name, async_class_name, diff in mismatches:
+            error_message += f"{sync_class_name} vs {async_class_name}:\n"
+            for method in diff:
+                error_message += f"  - {method}\n"
+        raise ValueError(error_message)
+
+    print("All sync and async client methods match.")
+
+
+if __name__ == "__main__":
+    main()

.github/scripts/run_langgraph_cli_test.py

@@ -0,0 +1,115 @@
+import asyncio
+import json
+import os
+import pathlib
+import sys
+import langgraph_cli
+import langgraph_cli.docker
+import langgraph_cli.config
+
+from langgraph_cli.exec import Runner, subp_exec
+from langgraph_cli.progress import Progress
+from langgraph_cli.constants import DEFAULT_PORT
+
+
+def test(
+    config: pathlib.Path,
+    port: int,
+    tag: str,
+    verbose: bool,
+):
+    with Runner() as runner, Progress(message="Pulling...") as set:
+        # check docker available
+        capabilities = langgraph_cli.docker.check_capabilities(runner)
+        # open config
+        config_json = langgraph_cli.config.validate_config_file(config)
+
+        set("Running...")
+        args = [
+            "run",
+            "--rm",
+            "-p",
+            f"{port}:8000",
+        ]
+        if isinstance(config_json["env"], str):
+            args.extend(
+                [
+                    "--env-file",
+                    str(config.parent / config_json["env"]),
+                ]
+            )
+        else:
+            for k, v in config_json["env"].items():
+                args.extend(
+                    [
+                        "-e",
+                        f"{k}={v}",
+                    ]
+                )
+        if capabilities.healthcheck_start_interval:
+            args.extend(
+                [
+                    "--health-interval",
+                    "5s",
+                    "--health-retries",
+                    "1",
+                    "--health-start-period",
+                    "10s",
+                    "--health-start-interval",
+                    "1s",
+                ]
+            )
+        else:
+            args.extend(
+                [
+                    "--health-interval",
+                    "5s",
+                    "--health-retries",
+                    "2",
+                ]
+            )
+
+        _task = None
+
+        def on_stdout(line: str):
+            nonlocal _task
+            if "GET /ok" in line or "Uvicorn running on" in line:
+                set("")
+                sys.stdout.write(
+                    f"""Ready!
+- API: http://localhost:{port}
+"""
+                )
+                sys.stdout.flush()
+                _task.cancel()
+                return True
+            return False
+
+        async def subp_exec_task(*args, **kwargs):
+            nonlocal _task
+            _task = asyncio.create_task(subp_exec(*args, **kwargs))
+            await _task
+
+        try:
+            runner.run(
+                subp_exec_task(
+                    "docker",
+                    *args,
+                    tag,
+                    verbose=verbose,
+                    on_stdout=on_stdout,
+                )
+            )
+        except asyncio.CancelledError:
+            pass
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-t", "--tag", type=str)
+    parser.add_argument("-c", "--config", type=str, default="./langgraph.json")
+    parser.add_argument("-p", "--port", default=DEFAULT_PORT)
+    args = parser.parse_args()
+    test(pathlib.Path(args.config), args.port, args.tag, verbose=True)

.github/workflows/_integration_test.yml

@@ -22,7 +22,7 @@ jobs:
       - uses: actions/checkout@v4
       - name: Get changed files
         id: changed-files
-        uses: Ana06/get-changed-files@v2.2.0
+        uses: Ana06/get-changed-files@v2.3.0
         with:
           filter: "libs/cli/**"
       - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
@@ -39,22 +39,36 @@ jobs:
       - name: Install cli globally
         if: steps.changed-files.outputs.all
         run: pip install -e .
-      - name: Start service A
+      - name: Build and test service A
         if: steps.changed-files.outputs.all
+        working-directory: libs/cli/examples
         run: |
-          timeout 60 langgraph test -c examples/langgraph.json --verbose || (exit "$(($? == 124 ? 0 : $?))")
-      - name: Start service B
+          # The build-arg isn't used; just testing that we accept other args
+          langgraph build -t langgraph-test-a  --base-image "langchain/langgraph-trial"
+          cp .env.example .envg
+          timeout 60 python ../../../.github/scripts/run_langgraph_cli_test.py -c langgraph.json -t langgraph-test-a
+      - name: Build and test service B
         if: steps.changed-files.outputs.all
         working-directory: libs/cli/examples/graphs
         run: |
-          timeout 60 langgraph test --verbose || (exit "$(($? == 124 ? 0 : $?))")
-      - name: Start service C
+          langgraph build -t langgraph-test-b  --base-image "langchain/langgraph-trial"
+          timeout 60 python ../../../../.github/scripts/run_langgraph_cli_test.py -t langgraph-test-b
+      - name: Build and test service C
         if: steps.changed-files.outputs.all
         working-directory: libs/cli/examples/graphs_reqs_a
         run: |
-          timeout 60 langgraph test --verbose || (exit "$(($? == 124 ? 0 : $?))")
-      - name: Start service D
+          langgraph build -t langgraph-test-c  --base-image "langchain/langgraph-trial"
+          timeout 60 python ../../../../.github/scripts/run_langgraph_cli_test.py -t langgraph-test-c
+      - name: Build and test service D
         if: steps.changed-files.outputs.all
         working-directory: libs/cli/examples/graphs_reqs_b
         run: |
-          timeout 60 langgraph test --verbose || (exit "$(($? == 124 ? 0 : $?))")
+          langgraph build -t langgraph-test-d  --base-image "langchain/langgraph-trial"
+          timeout 60 python ../../../../.github/scripts/run_langgraph_cli_test.py -t langgraph-test-d
+
+      - name: Build JS service
+        if: steps.changed-files.outputs.all
+        working-directory: libs/cli/js-examples
+        run: |
+          langgraph build -t langgraph-test-e
+  

.github/workflows/_lint.yml

@@ -27,14 +27,13 @@ jobs:
         # Starting new jobs is also relatively slow,
         # so linting on fewer versions makes CI faster.
         python-version:
-          - "3.9"
-          - "3.11"
+          - "3.12"
     name: "lint #${{ matrix.python-version }}"
     steps:
       - uses: actions/checkout@v4
       - name: Get changed files
         id: changed-files
-        uses: Ana06/get-changed-files@v2.2.0
+        uses: Ana06/get-changed-files@v2.3.0
         with:
           filter: "${{ inputs.working-directory }}/**"
       - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
@@ -43,8 +42,7 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
           poetry-version: ${{ env.POETRY_VERSION }}
-          working-directory: ${{ inputs.working-directory }}
-          cache-key: lint-with-extras
+          cache-key: lint-${{ inputs.working-directory }}
 
       - name: Check Poetry File
         if: steps.changed-files.outputs.all

.github/workflows/_test.yml

@@ -21,6 +21,8 @@ jobs:
           - "3.10"
           - "3.11"
           - "3.12"
+          - "3.13"
+
     name: "test #${{ matrix.python-version }}"
     steps:
       - uses: actions/checkout@v4
@@ -29,15 +31,21 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
           poetry-version: ${{ env.POETRY_VERSION }}
-          working-directory: ${{ inputs.working-directory }}
-          cache-key: core
+          cache-key: test-${{ inputs.working-directory }}
+      - 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
         working-directory: ${{ inputs.working-directory }}
-        run: poetry install --with dev
+        run: |
+          poetry install --with dev
 
-      - name: Run core tests
+      - name: Run tests
         shell: bash
         working-directory: ${{ inputs.working-directory }}
         run: |

.github/workflows/_test_langgraph.yml

@@ -0,0 +1,75 @@
+name: test
+
+on:
+  workflow_call:
+
+env:
+  POETRY_VERSION: "1.7.1"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version:
+          - "3.9"
+          - "3.10"
+          - "3.11"
+          - "3.12"
+          - "3.13"
+        core-version:
+          - "latest"
+        ff-send-v2:
+          - "false"
+        include:
+          - python-version: "3.11"
+            core-version: ">=0.2.42,<0.3.0"
+          - python-version: "3.11"
+            core-version: "latest"
+            ff-send-v2: "true"
+
+    defaults:
+      run:
+        working-directory: libs/langgraph
+    name: "test #${{ matrix.python-version }} (langchain-core: ${{ matrix.core-version }}, ff-send-v2: ${{ matrix.ff-send-v2 }})"
+    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-langgraph
+      - 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
+          if [ "${{ matrix.core-version }}" != "latest" ]; then
+            poetry run pip install "langchain-core${{ matrix.core-version }}"
+          fi
+
+      - name: Run tests
+        shell: bash
+        env:
+          LANGGRAPH_FF_SEND_V2: ${{ matrix.ff-send-v2 }}
+        run: |
+          make test_parallel
+
+      - 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/_test_release.yml

@@ -29,7 +29,6 @@ jobs:
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           poetry-version: ${{ env.POETRY_VERSION }}
-          working-directory: ${{ inputs.working-directory }}
           cache-key: release
 
       # We want to keep this build stage *separate* from the release stage,
@@ -93,3 +92,5 @@ jobs:
           # This is *only for CI use* and is *extremely dangerous* otherwise!
           # https://github.com/pypa/gh-action-pypi-publish#tolerating-release-package-file-duplicates
           skip-existing: true
+          # Temp workaround since attestations are on by default as of gh-action-pypi-publish v1.11.0
+          attestations: false

.github/workflows/_test_scheduler_kafka.yml

@@ -0,0 +1,57 @@
+name: test
+
+on:
+  workflow_call:
+
+env:
+  POETRY_VERSION: "1.7.1"
+
+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

@@ -0,0 +1,37 @@
+name: baseline
+
+on:
+  workflow_dispatch:
+  push:
+    branches: [main]
+    paths:
+      - "libs/**"
+
+env:
+  POETRY_VERSION: "1.7.1"
+
+jobs:
+  benchmark:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: libs/langgraph
+    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"
+        with:
+          python-version: "3.11"
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: bench
+      - name: Install dependencies
+        run: poetry install --with dev
+      - name: Run benchmarks
+        run: OUTPUT=out/benchmark-baseline.json make -s benchmark
+      - name: Save outputs
+        uses: actions/cache/save@v4
+        with:
+          key: ${{ runner.os }}-benchmark-baseline-${{ env.SHA }}
+          path: |
+            libs/langgraph/out/benchmark-baseline.json

.github/workflows/bench.yml

@@ -0,0 +1,71 @@
+name: bench
+
+on:
+  pull_request:
+    paths:
+      - "libs/**"
+
+env:
+  POETRY_VERSION: "1.7.1"
+
+jobs:
+  benchmark:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: libs/langgraph
+    steps:
+      - uses: actions/checkout@v4
+      - id: files
+        name: Get changed files
+        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"
+        with:
+          python-version: "3.11"
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: bench
+      - name: Install dependencies
+        run: poetry install --with dev
+      - name: Download baseline
+        uses: actions/cache/restore@v4
+        with:
+          key: ${{ runner.os }}-benchmark-baseline
+          restore-keys: |
+            ${{ runner.os }}-benchmark-baseline-
+          fail-on-cache-miss: true
+          path: |
+            libs/langgraph/out/benchmark-baseline.json
+      - name: Run benchmarks
+        id: benchmark
+        run: |
+          {
+            echo 'OUTPUT<<EOF'
+            make -s benchmark
+            echo EOF
+          } >> "$GITHUB_OUTPUT"
+      - name: Compare benchmarks
+        id: compare
+        run: |
+          {
+            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
+            echo EOF
+          } >> "$GITHUB_OUTPUT"
+      - name: Annotation
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const file = JSON.parse(`${{ steps.files.outputs.added_modified_renamed }}`)[0]
+            core.notice(`${{ steps.benchmark.outputs.OUTPUT }}`, {
+              title: 'Benchmark results',
+              file,
+            })
+            core.notice(`${{ steps.compare.outputs.OUTPUT }}`, {
+              title: 'Comparison against main',
+              file,
+            })

.github/workflows/ci.yml

@@ -1,114 +1,150 @@
 ---
-    name: CI
+name: CI
 
-    on:
-      push:
-        branches: [main]
-      pull_request:
+on:
+  push:
+    branches: [main]
+  pull_request:
 
-    # If another push to the same PR or branch happens while this workflow is still running,
-    # cancel the earlier run in favor of the next run.
-    #
-    # There's no point in testing an outdated version of the code. GitHub only allows
-    # a limited number of job runners to be active at the same time, so it's better to cancel
-    # pointless jobs early so that more useful jobs can run sooner.
-    concurrency:
-      group: ${{ github.workflow }}-${{ github.ref }}
-      cancel-in-progress: true
+# If another push to the same PR or branch happens while this workflow is still running,
+# cancel the earlier run in favor of the next run.
+#
+# There's no point in testing an outdated version of the code. GitHub only allows
+# a limited number of job runners to be active at the same time, so it's better to cancel
+# pointless jobs early so that more useful jobs can run sooner.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
 
+env:
+  POETRY_VERSION: "1.7.1"
+
+jobs:
+  lint:
+    name: cd ${{ matrix.working-directory }}
+    strategy:
+      matrix:
+        working-directory:
+          [
+            "libs/langgraph",
+            "libs/sdk-py",
+            "libs/cli",
+            "libs/checkpoint",
+            "libs/checkpoint-sqlite",
+            "libs/checkpoint-duckdb",
+            "libs/checkpoint-postgres",
+            "libs/scheduler-kafka",
+          ]
+    uses: ./.github/workflows/_lint.yml
+    with:
+      working-directory: ${{ matrix.working-directory }}
+    secrets: inherit
+
+  test:
+    name: cd ${{ matrix.working-directory }}
+    strategy:
+      matrix:
+        working-directory: [
+            "libs/cli",
+            "libs/checkpoint",
+            "libs/checkpoint-sqlite",
+            "libs/checkpoint-duckdb",
+            "libs/checkpoint-postgres"
+          ]
+    uses: ./.github/workflows/_test.yml
+    with:
+      working-directory: ${{ matrix.working-directory }}
+    secrets: inherit
+
+  # NOTE: we're testing langgraph separately because it requires a different matrix
+  test-langgraph:
+    name: "cd libs/langgraph"
+    uses: ./.github/workflows/_test_langgraph.yml
+    secrets: inherit
+
+  # NOTE: we're testing scheduler-kafka separately because it requires a different matrix
+  test-scheduler-kafka:
+    name: "cd libs/scheduler-kafka"
+    uses: ./.github/workflows/_test_scheduler_kafka.yml
+    secrets: inherit
+
+  check-sdk-methods:
+    name: "Check SDK methods matching"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - name: Run check_sdk_methods script
+        run: python .github/scripts/check_sdk_methods.py
+
+  integration-test:
+    name: CLI integration test
+    uses: ./.github/workflows/_integration_test.yml
+    secrets: inherit
+
+  lint-js:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        working-directory:
+          - "libs/sdk-js"
+    defaults:
+      run:
+        working-directory: ${{ matrix.working-directory }}
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup Node.js (LTS)
+        uses: actions/setup-node@v3
+        with:
+          node-version: "20"
+          cache: "yarn"
+          cache-dependency-path: ${{ matrix.working-directory }}/yarn.lock
+      - name: Install dependencies
+        run: yarn install
+      - name: Run lint
+        run: yarn lint
+      - name: Build
+        run: yarn build
+
+  test-js:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        working-directory:
+          - "libs/sdk-js"
+    defaults:
+      run:
+        working-directory: ${{ matrix.working-directory }}
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup Node.js (LTS)
+        uses: actions/setup-node@v3
+        with:
+          node-version: "20"
+          cache: "yarn"
+          cache-dependency-path: ${{ matrix.working-directory }}/yarn.lock
+      - name: Install dependencies
+        run: yarn install
+      - name: Run tests
+        run: yarn test
+
+  ci_success:
+    name: "CI Success"
+    needs: [lint, lint-js, test, test-langgraph, test-scheduler-kafka, integration-test, test-js]
+    if: |
+      always()
+    runs-on: ubuntu-latest
     env:
-      POETRY_VERSION: "1.7.1"
-
-    jobs:
-      build:
-        runs-on: ubuntu-latest
-        steps:
-          - uses: actions/checkout@v4
-          - uses: actions/setup-python@v5
-            with:
-              python-version: '3.10'
-
-      lint:
-        name: cd ${{ matrix.working-directory }}
-        needs: [ build ]
-        strategy:
-          matrix:
-            working-directory: [
-                "libs/langgraph",
-                "libs/sdk-py",
-                "libs/cli",
-                "libs/checkpoint",
-                "libs/checkpoint-sqlite",
-                "libs/checkpoint-postgres"
-            ]
-        uses: ./.github/workflows/_lint.yml
-        with:
-          working-directory: ${{ matrix.working-directory }}
-        secrets: inherit
-
-      test:
-        name: cd ${{ matrix.working-directory }}
-        needs: [ build ]
-        strategy:
-          matrix:
-            working-directory: [
-                "libs/langgraph",
-                "libs/cli",
-                "libs/checkpoint",
-                "libs/checkpoint-sqlite",
-                "libs/checkpoint-postgres"
-            ]
-        uses: ./.github/workflows/_test.yml
-        with:
-          working-directory: ${{ matrix.working-directory }}
-        secrets: inherit
-
-      integration-test:
-        name: CLI integration test
-        needs: [ build ]
-        uses: ./.github/workflows/_integration_test.yml
-        secrets: inherit
-
-      lint-js:
-        runs-on: ubuntu-latest
-        needs: [ build ]
-        strategy:
-          matrix:
-            working-directory:
-              - "libs/sdk-js"
-        defaults:
-          run:
-            working-directory: ${{ matrix.working-directory }}
-        steps:
-          - uses: actions/checkout@v3
-          - name: Setup Node.js (LTS)
-            uses: actions/setup-node@v3
-            with:
-              node-version: "20"
-              cache: "yarn"
-              cache-dependency-path: ${{ matrix.working-directory }}/yarn.lock
-          - name: Install dependencies
-            run: yarn install
-          - name: Run lint
-            run: yarn lint
-          - name: Build
-            run: yarn build
-
-      ci_success:
-        name: "CI Success"
-        needs: [build, lint, lint-js, test, integration-test]
-        if: |
-          always()
-        runs-on: ubuntu-latest
-        env:
-          JOBS_JSON: ${{ toJSON(needs) }}
-          RESULTS_JSON: ${{ toJSON(needs.*.result) }}
-          EXIT_CODE: ${{!contains(needs.*.result, 'failure') && !contains(needs.*.result, 'cancelled') && '0' || '1'}}
-        steps:
-          - name: "CI Success"
-            run: |
-              echo $JOBS_JSON
-              echo $RESULTS_JSON
-              echo "Exiting with $EXIT_CODE"
-              exit $EXIT_CODE
-    
+      JOBS_JSON: ${{ toJSON(needs) }}
+      RESULTS_JSON: ${{ toJSON(needs.*.result) }}
+      EXIT_CODE: ${{!contains(needs.*.result, 'failure') && !contains(needs.*.result, 'cancelled') && '0' || '1'}}
+    steps:
+      - name: "CI Success"
+        run: |
+          echo $JOBS_JSON
+          echo $RESULTS_JSON
+          echo "Exiting with $EXIT_CODE"
+          exit $EXIT_CODE

.github/workflows/codespell.yml

@@ -32,7 +32,7 @@
           - name: Codespell
             uses: codespell-project/actions-codespell@v2
             with:
-              skip: '*.ambr,*.lock,*.ipynb'
+              skip: '*.ambr,*.lock,*.ipynb,*.yaml,*.zlib'
               ignore_words_list: ${{ steps.extract_ignore_words.outputs.ignore_words_list }}
           # We do this to avoid spellchecking cell outputs
           - name: Codespell Notebooks

.github/workflows/deploy_docs.yml

@@ -22,8 +22,30 @@ concurrency:
   cancel-in-progress: false
 
 jobs:
-  deploy:
+  get-changed-files:
     runs-on: ubuntu-latest
+    outputs:
+      changed-files: ${{ steps.changed-files.outputs.added_modified }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Get changed files
+        id: changed-files
+        uses: Ana06/get-changed-files@v2.3.0
+        with:
+          filter: "docs/docs/**"
+
+  run-changed-notebooks:
+    needs: get-changed-files
+    uses: ./.github/workflows/run_notebooks.yml
+    secrets: inherit
+    with:
+      changed-files: ${{ needs.get-changed-files.outputs.changed-files }}
+
+  deploy:
+    # needs: run-changed-notebooks
+    runs-on: ubuntu-latest
+    env:
+      GITHUB_TOKEN: ${{ secrets.MKDOCS_GITHUB_TOKEN }}
     steps:
       - uses: actions/checkout@v4
         with:
@@ -38,13 +60,66 @@ jobs:
 
       - name: Install dependencies
         run: |
-          poetry install --with docs
+          poetry install --with test --no-root
+          poetry run pip install -U \
+            pytest \
+            pytest-check-links \
+            langsmith \
+            langchain \
+            GitPython \
+            "git+https://${GITHUB_TOKEN}@github.com/langchain-ai/mkdocs-material-insiders.git"
 
+      - name: Lint Docs
+        # This step lints the docs using the existing linting set up.
+        # It should be very fast and should not require any external services.
+        run: make lint-docs
       - name: Build site
         run: make build-docs
         env:
           MKDOCS_GIT_COMMITTERS_APIKEY: ${{ secrets.MKDOCS_GIT_COMMITTERS_APIKEY }}
 
+      - name: Check links in notebooks
+        env:
+          LANGCHAIN_API_KEY: test
+        run: |
+          if [ "${{ github.event_name }}" == "schedule" ] || [ "${{ github.event_name }}" == "workflow_dispatch" ] || ([ "${{ github.event_name }}" == "push" ] && [ "${{ github.ref }}" == "refs/heads/main" ]); then
+            echo "Running link check on all HTML files matching notebooks in docs directory..."
+            poetry run pytest -v \
+              --check-links-ignore "https://(api|web|docs)\.smith\.langchain\.com/.*" \
+              --check-links-ignore "https://x.com/.*" \
+              --check-links-ignore "https://github\.com/.*" \
+              --check-links-ignore "http://localhost:8123/.*" \
+              --check-links-ignore "http://localhost:2024.*" \
+              --check-links-ignore "http://127.0.0.1:.*" \
+              --check-links-ignore "/.*\.(ipynb|html)$" \
+              --check-links-ignore "https://python\.langchain\.com/.*" \
+              --check-links-ignore "https://openai\.com/.*" \
+              --check-links-ignore "https://pepy\.tech/.*" \
+              --check-links $(find docs/site -name "index.html" | grep -v 'storm/index.html') 
+              
+          else
+            echo "Fetching changes from origin/main..."
+            git fetch origin main
+            echo "Checking for changed notebook files..."
+            CHANGED_FILES=$(git diff --name-only --diff-filter=d origin/main | grep 'docs/docs/.*\.ipynb$' | grep -v 'storm.ipynb' | sed -E 's|^docs/docs/|docs/site/|; s/\.ipynb$/\/index.html/' || true)
+            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 \
+                --check-links-ignore "https://(api|web|docs)\.smith\.langchain\.com/.*" \
+                --check-links-ignore "http://localhost:8123/.*" \
+                --check-links-ignore "http://localhost:2024.*" \
+                --check-links-ignore "http://127.0.0.1:.*" \
+                --check-links-ignore "https://x.com/.*" \
+                --check-links-ignore "https://github\.com/.*" \
+                --check-links-ignore "/.*\.(ipynb|html)$" \
+                --check-links ${CHANGED_FILES} \
+                || ([ $? = 5 ] && exit 0 || exit $?)
+            else
+              echo "No notebook files changed."
+            fi
+          fi
+
       - name: Configure GitHub Pages
         if: github.ref == 'refs/heads/main'
         uses: actions/configure-pages@v4
@@ -59,10 +134,3 @@ jobs:
         if: github.ref == 'refs/heads/main'
         id: deployment
         uses: actions/deploy-pages@v4
-
-      - name: Deploy Pull Request Preview
-        if: github.event_name == 'pull_request'
-        uses: actions/upload-artifact@v2
-        with:
-          name: pr-preview-${{ github.event.number }}
-          path: ./docs/site/

.github/workflows/link_check.yml

@@ -26,49 +26,11 @@ jobs:
       - name: Check links in Markdown files
         uses: gaurav-nelson/github-action-markdown-link-check@v1
         with:
-          folder-path: "examples/,docs/"
+          folder-path: "docs/"
           check-modified-files-only: ${{ github.event_name != 'schedule' }}
           file-path: "./README.md"
           config-file: "./.markdown-link-check.config.json"
 
-  notebook-link-check:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-      - name: Set up Python 3.x + Poetry ${{ env.POETRY_VERSION }}
-        uses: "./.github/actions/poetry_setup"
-        with:
-          python-version: "3.11"
-          poetry-version: ${{ env.POETRY_VERSION }}
-          cache-key: core
-
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          poetry install --with docs
-          poetry run pip install -U pytest pytest-check-links langsmith langchain GitPython
-
-      - name: Check links in notebooks
-        env:
-          LANGCHAIN_API_KEY: test
-        run: |
-          if [ "${{ github.event_name }}" == "schedule" ] || [ "${{ github.event_name }}" == "workflow_dispatch" ] || ([ "${{ github.event_name }}" == "push" ] && [ "${{ github.ref }}" == "refs/heads/main" ]); then
-            echo "Running link check on all notebooks in examples directory..."
-            poetry run pytest -v --check-links-ignore "https://(api|web)\.smith\.langchain\.com/.*" --check-links-ignore "https://x.com/.*" --check-links examples
-          else
-            echo "Fetching changes from origin/main..."
-            git fetch origin main
-            echo "Checking for changed notebook files..."
-            CHANGED_FILES=$(git diff --name-only --diff-filter=d origin/main | grep '\.ipynb$' || true)
-            echo "Changed files: ${CHANGED_FILES}"
-            if [ -n "${CHANGED_FILES}" ]; then
-              echo "Running link check on changed notebook files..."
-              poetry run pytest -v --check-links-ignore "https://(api|web)\.smith\.langchain\.com/.*" --check-links-ignore "https://x.com/.*" --check-links ${CHANGED_FILES} || ([ $? = 5 ] && exit 0 || exit $?)
-            else
-              echo "No notebook files changed."
-            fi
-          fi
   check-readmes-synced:
     # This checks that the repo README.md is identical to the libs/langgraph/README.md
     runs-on: ubuntu-latest

.github/workflows/release.yml

@@ -31,7 +31,6 @@ jobs:
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           poetry-version: ${{ env.POETRY_VERSION }}
-          working-directory: ${{ inputs.working-directory }}
           cache-key: release
 
       # We want to keep this build stage *separate* from the release stage,
@@ -169,7 +168,6 @@ jobs:
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           poetry-version: ${{ env.POETRY_VERSION }}
-          working-directory: ${{ inputs.working-directory }}
 
       - name: Import published package
         shell: bash
@@ -256,7 +254,6 @@ jobs:
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           poetry-version: ${{ env.POETRY_VERSION }}
-          working-directory: ${{ inputs.working-directory }}
           cache-key: release
 
       - uses: actions/download-artifact@v4
@@ -270,6 +267,8 @@ jobs:
           packages-dir: ${{ inputs.working-directory }}/dist/
           verbose: true
           print-hash: true
+          # Temp workaround since attestations are on by default as of gh-action-pypi-publish v1.11.0
+          attestations: false
 
   mark-release:
     needs:
@@ -296,7 +295,6 @@ jobs:
         with:
           python-version: ${{ env.PYTHON_VERSION }}
           poetry-version: ${{ env.POETRY_VERSION }}
-          working-directory: ${{ inputs.working-directory }}
           cache-key: release
 
       - uses: actions/download-artifact@v4

.github/workflows/run_notebooks.yml

@@ -0,0 +1,78 @@
+name: Run notebooks
+
+on:
+  workflow_dispatch:
+  workflow_call:
+    inputs:
+      changed-files:
+        required: false
+        type: string
+        description: "JSON string of changed files"
+  schedule:
+    - cron: '0 13 * * *'
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        lib-version:
+          - "development"
+          - "latest"
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python + Poetry
+        uses: "./.github/actions/poetry_setup"
+        with:
+          python-version: 3.11
+          poetry-version: 1.7.1
+          cache-key: test-langgraph-notebooks
+
+      - name: Install dependencies
+        run: |
+          poetry install --with test
+          poetry run pip install jupyter
+
+      - name: Start services
+        run: make start-services
+
+      - name: Pre-download tiktoken files
+        run: |
+          poetry run python docs/_scripts/download_tiktoken.py
+
+      - name: Prepare notebooks
+        run: |
+          if [ "${{ matrix.lib-version }}" = "development" ]; then
+            poetry run python docs/_scripts/prepare_notebooks_for_ci.py --comment-install-cells
+          else
+            poetry run python docs/_scripts/prepare_notebooks_for_ci.py
+          fi
+
+      - name: Run notebooks
+        env:
+          # these won't actually be used because of the VCR cassettes
+          # but need to set them to avoid triggering getpass()
+          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          TAVILY_API_KEY: ${{ secrets.TAVILY_API_KEY }}
+          LANGSMITH_API_KEY: ${{ secrets.LANGSMITH_API_KEY }}
+          NOMIC_API_KEY: ${{ secrets.NOMIC_API_KEY }}
+          COHERE_API_KEY: ${{ secrets.COHERE_API_KEY }}
+          FIREWORKS_API_KEY: ${{ secrets.FIREWORKS_API_KEY }}
+        run: |
+          if [ "${{ github.event_name }}" = "workflow_dispatch" ] || [ "${{ github.event_name }}" = "schedule" ]; then
+            echo "Running all notebooks"
+            ./docs/_scripts/execute_notebooks.sh
+          else
+            CHANGED_FILES=$(echo '${{ inputs.changed-files }}' | tr ' ' '\n' | grep '\.ipynb$' || true)
+            if [ -n "$CHANGED_FILES" ]; then
+              echo "Running changed notebooks: $CHANGED_FILES"
+              ./docs/_scripts/execute_notebooks.sh $CHANGED_FILES
+            else
+              echo "No notebook files changed, skipping execution"
+            fi
+          fi
+
+      - name: Stop services
+        run: make stop-services

.github/workflows/size.yml

@@ -18,8 +18,9 @@ jobs:
         id: changed-files
         uses: tj-actions/changed-files@v44
       - name: Filter by size
+        # TODO: roll back the web voyager hack
         run: |
-          large_added_files=$(find ${{ steps.changed-files.outputs.added_files }} -maxdepth 0 -size +1M)
+          large_added_files=$(find ${{ steps.changed-files.outputs.added_files }} -maxdepth 0 -size +1M | grep -v "web_voyager" || true)
           if [ -n "$large_added_files" ]; then
             echo "Large files added: $large_added_files"
             echo "# Large files added:" >> $GITHUB_STEP_SUMMARY

.gitignore

@@ -177,3 +177,5 @@ docs/docs_skeleton/yarn.lock
 Untitled*.ipynb
 
 Chinook.db
+
+libs/langgraph/out

CONTRIBUTING.md

@@ -49,7 +49,7 @@ gain understanding of concepts and how they interact by showing one way to achie
 
 They should **avoid** giving
 multiple permutations of ways to achieve that goal in-depth. Choice is burdensome. Instead, they should guide a new user through a recommended path to accomplishing a concrete goal. While the end result of a tutorial does not necessarily need to
-be completely production-ready, it should be useful and practically satisfy the the goal that you clearly stated in the tutorial's introduction.
+be completely production-ready, it should be useful and practically satisfy the goal that you clearly stated in the tutorial's introduction.
 
 To quote the Diataxis website:
 

Makefile

@@ -1,4 +1,4 @@
-.PHONY: build-docs serve-docs serve-clean-docs clean-docs codespell build-typedoc
+.PHONY: lint-docs format-docs build-docs serve-docs serve-clean-docs clean-docs codespell build-typedoc
 
 build-typedoc:
 	cd libs/sdk-js && yarn install --include-dev && yarn typedoc
@@ -6,23 +6,34 @@ build-typedoc:
 	#  Add links to the monorepo
 	sed -e '1,10s|@langchain/langgraph-sdk|[@langchain/langgraph-sdk](https://github.com/langchain-ai/langgraph/tree/main/libs/sdk-js)|g' docs/docs/cloud/reference/sdk/js_ts_sdk_ref.md > temp_file && mv temp_file docs/docs/cloud/reference/sdk/js_ts_sdk_ref.md
 
-
-
 build-docs: build-typedoc
-	poetry run python docs/_scripts/copy_notebooks.py
 	poetry run python -m mkdocs build --clean -f docs/mkdocs.yml --strict
 
 serve-clean-docs: clean-docs
-	poetry run python docs/_scripts/copy_notebooks.py
 	poetry run python -m mkdocs serve -c -f docs/mkdocs.yml --strict -w ./libs/langgraph
 
 serve-docs: build-typedoc
-	poetry run python docs/_scripts/copy_notebooks.py
-	poetry run python -m mkdocs serve -f docs/mkdocs.yml -w ./libs/langgraph --dirty
+	poetry run python -m mkdocs serve -f docs/mkdocs.yml -w ./libs/langgraph  -w ./libs/checkpoint -w ./libs/sdk-py --dirty
 
 clean-docs:
 	find ./docs/docs -name "*.ipynb" -type f -delete
 	rm -rf docs/site
 
+## Run format against the project documentation.
+format-docs:
+	poetry run ruff format docs/docs
+	poetry run ruff check --fix docs/docs
+
+# Check the docs for linting violations
+lint-docs:
+	poetry run ruff format --check docs/docs
+	poetry run ruff check docs/docs
+
 codespell:
-	./docs/codespell_notebooks.sh .
+	./docs/codespell_notebooks.sh .
+
+start-services:
+	docker compose -f docs/test-compose.yml up -V --force-recreate --wait --remove-orphans
+
+stop-services:
+	docker compose -f docs/test-compose.yml down

README.md

@@ -8,7 +8,7 @@
 ⚡ Building language agents as graphs ⚡
 
 > [!NOTE]
-> Looking for the JS version? Click [here](https://github.com/langchain-ai/langgraphjs) ([JS docs](https://langchain-ai.github.io/langgraphjs/)).
+> Looking for the JS version? See the [JS repo](https://github.com/langchain-ai/langgraphjs) and the [JS docs](https://langchain-ai.github.io/langgraphjs/).
 
 ## Overview
 
@@ -16,6 +16,10 @@
 
 LangGraph is inspired by [Pregel](https://research.google/pubs/pub37252/) and [Apache Beam](https://beam.apache.org/). The public interface draws inspiration from [NetworkX](https://networkx.org/documentation/latest/). LangGraph is built by LangChain Inc, the creators of LangChain, but can be used without LangChain.
 
+[LangGraph Platform](https://langchain-ai.github.io/langgraph/concepts/langgraph_platform) is infrastructure for deploying LangGraph agents. It is a commercial solution for deploying agentic applications to production, built on the open-source LangGraph framework. The LangGraph Platform consists of several components that work together to support the development, deployment, debugging, and monitoring of LangGraph applications: [LangGraph Server](https://langchain-ai.github.io/langgraph/concepts/langgraph_server) (APIs), [LangGraph SDKs](https://langchain-ai.github.io/langgraph/concepts/sdk) (clients for the APIs), [LangGraph CLI](https://langchain-ai.github.io/langgraph/concepts/langgraph_cli) (command line tool for building the server), [LangGraph Studio](https://langchain-ai.github.io/langgraph/concepts/langgraph_studio) (UI/debugger),
+
+To learn more about LangGraph, check out our first LangChain Academy course, *Introduction to LangGraph*, available for free [here](https://academy.langchain.com/courses/intro-to-langgraph).
+
 ### Key Features
 
 - **Cycles and Branching**: Implement loops and conditionals in your apps.
@@ -24,6 +28,16 @@ LangGraph is inspired by [Pregel](https://research.google/pubs/pub37252/) and [A
 - **Streaming Support**: Stream outputs as they are produced by each node (including token streaming).
 - **Integration with LangChain**: LangGraph integrates seamlessly with [LangChain](https://github.com/langchain-ai/langchain/) and [LangSmith](https://docs.smith.langchain.com/) (but does not require them).
 
+### LangGraph Platform
+
+LangGraph Platform is a commercial solution for deploying agentic applications to production, built on the open-source LangGraph framework.
+Here are some common issues that arise in complex deployments, which LangGraph Platform addresses:
+
+- **Streaming support**: LangGraph Server provides [multiple streaming modes](https://langchain-ai.github.io/langgraph/concepts/streaming) optimized for various application needs
+- **Background runs**: Runs agents asynchronously in the background
+- **Support for long running agents**: Infrastructure that can handle long running processes
+- **[Double texting](https://langchain-ai.github.io/langgraph/concepts/double_texting)**: Handle the case where you get two messages from the user before the agent can respond
+- **Handle burstiness**: Task queue for ensuring requests are handled consistently without loss, even under heavy loads
 
 ## Installation
 
@@ -222,9 +236,9 @@ final_state["messages"][-1].content
 
 * [Tutorials](https://langchain-ai.github.io/langgraph/tutorials/): Learn to build with LangGraph through guided examples.
 * [How-to Guides](https://langchain-ai.github.io/langgraph/how-tos/): Accomplish specific things within LangGraph, from streaming, to adding memory & persistence, to common design patterns (branching, subgraphs, etc.), these are the place to go if you want to copy and run a specific code snippet.
-* [Conceptual Guides](https://langchain-ai.github.io/langgraph/concepts/): In-depth explanations of the key concepts and principles behind LangGraph, such as nodes, edges, state and more.
+* [Conceptual Guides](https://langchain-ai.github.io/langgraph/concepts/high_level/): In-depth explanations of the key concepts and principles behind LangGraph, such as nodes, edges, state and more.
 * [API Reference](https://langchain-ai.github.io/langgraph/reference/graphs/): Review important classes and methods, simple examples of how to use the graph and checkpointing APIs, higher-level prebuilt components and more.
-* [Cloud (beta)](https://langchain-ai.github.io/langgraph/cloud/): With one click, deploy LangGraph applications to LangGraph Cloud.
+* [LangGraph Platform](https://langchain-ai.github.io/langgraph/concepts/#langgraph-platform): LangGraph Platform is a commercial solution for deploying agentic applications in production, built on the open-source LangGraph framework.
 
 ## Contributing
 

docs/.gitignore

@@ -1,4 +1,2 @@
-*.ipynb
 site/
-docs/tutorials/**/*.png
 docs/cloud/reference/sdk/js_ts_sdk_ref.md

docs/README.md

@@ -0,0 +1,61 @@
+# Setup
+
+To setup requirements for building docs you can run:
+
+```bash
+poetry install --with test
+```
+
+## Serving documentation locally
+
+To run the documentation server locally you can run:
+
+```bash
+make serve-docs
+```
+
+## Execute notebooks
+
+If you would like to automatically execute all of the notebooks, to mimic the "Run notebooks" GHA, you can run:
+
+```bash
+python docs/_scripts/prepare_notebooks_for_ci.py
+./docs/_scripts/execute_notebooks.sh
+```
+
+**Note**: if you want to run the notebooks without `%pip install` cells, you can run:
+
+```bash
+python docs/_scripts/prepare_notebooks_for_ci.py --comment-install-cells
+./docs/_scripts/execute_notebooks.sh
+```
+
+`prepare_notebooks_for_ci.py` script will add VCR cassette context manager for each cell in the notebook, so that:
+* when the notebook is run for the first time, cells with network requests will be recorded to a VCR cassette file
+* when the notebook is run subsequently, the cells with network requests will be replayed from the cassettes
+
+**Note**: this is currently limited only to the notebooks in `docs/docs/how-tos`
+
+## Adding new notebooks
+
+If you are adding a notebook with API requests, it's **recommended** to record network requests so that they can be subsequently replayed. If this is not done, the notebook runner will make API requests every time the notebook is run, which can be costly and slow.
+
+To record network requests, please make sure to first run `prepare_notebooks_for_ci.py` script.
+
+Then, run
+
+```bash
+jupyter execute <path_to_notebook>
+```
+
+Once the notebook is executed, you should see the new VCR cassettes recorded in `docs/cassettes` directory and discard the updated notebook.
+
+## Updating existing notebooks
+
+If you are updating an existing notebook, please make sure to remove any existing cassettes for the notebook in `docs/cassettes` directory (each cassette is prefixed with the notebook name), and then run the steps from the "Adding new notebooks" section above.
+
+To delete cassettes for a notebook, you can run:
+
+```bash
+rm docs/cassettes/<notebook_name>*
+```

docs/_scripts/_patch.py

@@ -0,0 +1,93 @@
+import functools
+
+from urllib3 import __version__ as urllib3version  # type: ignore[import-untyped]
+from urllib3 import connection  # type: ignore[import-untyped]
+
+
+def _ensure_str(s, encoding="utf-8", errors="strict") -> str:
+    if isinstance(s, str):
+        return s
+
+    if isinstance(s, bytes):
+        return s.decode(encoding, errors)
+    return str(s)
+
+
+# Copied from https://github.com/urllib3/urllib3/blob/1c994dfc8c5d5ecaee8ed3eb585d4785f5febf6e/src/urllib3/connection.py#L231
+def request(self, method, url, body=None, headers=None):
+    """Make the request.
+
+    This function is based on the urllib3 request method, with modifications
+    to handle potential issues when using vcrpy in concurrent workloads.
+
+    Args:
+        self: The HTTPConnection instance.
+        method (str): The HTTP method (e.g., 'GET', 'POST').
+        url (str): The URL for the request.
+        body (Optional[Any]): The body of the request.
+        headers (Optional[dict]): Headers to send with the request.
+
+    Returns:
+        The result of calling the parent request method.
+    """
+    # Update the inner socket's timeout value to send the request.
+    # This only triggers if the connection is re-used.
+    if getattr(self, "sock", None) is not None:
+        self.sock.settimeout(self.timeout)
+
+    if headers is None:
+        headers = {}
+    else:
+        # Avoid modifying the headers passed into .request()
+        headers = headers.copy()
+    if "user-agent" not in (_ensure_str(k.lower()) for k in headers):
+        headers["User-Agent"] = connection._get_default_user_agent()
+    # The above is all the same ^^^
+    # The following is different:
+    return self._parent_request(method, url, body=body, headers=headers)
+
+
+_PATCHED = False
+
+
+def patch_urllib3():
+    """Patch the request method of urllib3 to avoid type errors when using vcrpy.
+
+    In concurrent workloads (such as the tracing background queue), the
+    connection pool can get in a state where an HTTPConnection is created
+    before vcrpy patches the HTTPConnection class. In urllib3 >= 2.0 this isn't
+    a problem since they use the proper super().request(...) syntax, but in older
+    versions, super(HTTPConnection, self).request is used, resulting in a TypeError
+    since self is no longer a subclass of "HTTPConnection" (which at this point
+    is vcr.stubs.VCRConnection).
+
+    This method patches the class to fix the super() syntax to avoid mixed inheritance.
+    In the case of the LangSmith tracing logic, it doesn't really matter since we always
+    exclude cache checks for calls to LangSmith.
+
+    The patch is only applied for urllib3 versions older than 2.0.
+    """
+    global _PATCHED
+    if _PATCHED:
+        return
+    from packaging import version
+
+    if version.parse(urllib3version) >= version.parse("2.0"):
+        _PATCHED = True
+        return
+
+    # Lookup the parent class and its request method
+    parent_class = connection.HTTPConnection.__bases__[0]
+    parent_request = parent_class.request
+
+    def new_request(self, *args, **kwargs):
+        """Handle parent request.
+
+        This method binds the parent's request method to self and then
+        calls our modified request function.
+        """
+        self._parent_request = functools.partial(parent_request, self)
+        return request(self, *args, **kwargs)
+
+    connection.HTTPConnection.request = new_request
+    _PATCHED = True

docs/_scripts/copy_notebooks.py

@@ -1,226 +0,0 @@
-import json
-import os
-import re
-import shutil
-from pathlib import Path
-
-root_dir = Path(__file__).resolve().parents[2]
-
-examples_dir = root_dir / "examples"
-docs_dir = root_dir / "docs/docs"
-how_tos_dir = docs_dir / "how-tos"
-tutorials_dir = docs_dir / "tutorials"
-cloud_how_tos_dir = docs_dir / "cloud/how-tos"
-cloud_sdk_dir = docs_dir / "cloud"
-
-_MANUAL = {
-    "how-tos": [
-        "state-context-key.ipynb",
-        "async.ipynb",
-        "stream-values.ipynb",
-        "stream-updates.ipynb",
-        "stream-multiple.ipynb",
-        "streaming-tokens.ipynb",
-        "streaming-tokens-without-langchain.ipynb",
-        "streaming-content.ipynb",
-        "streaming-events-from-within-tools.ipynb",
-        "streaming-events-from-within-tools-without-langchain.ipynb",
-        "streaming-from-final-node.ipynb",
-        "persistence.ipynb",
-        "input_output_schema.ipynb",
-        "pass_private_state.ipynb",
-        "memory/manage-conversation-history.ipynb",
-        "memory/delete-messages.ipynb",
-        "memory/add-summary-conversation-history.ipynb",
-        "persistence_postgres.ipynb",
-        "persistence_mongodb.ipynb",
-        "persistence_redis.ipynb",
-        "visualization.ipynb",
-        "state-model.ipynb",
-        "subgraph.ipynb",
-        "recursion-limit.ipynb",
-        "force-calling-a-tool-first.ipynb",
-        "pass-run-time-values-to-tools.ipynb",
-        "tool-calling.ipynb",
-        "tool-calling-errors.ipynb",
-        "pass-config-to-tools.ipynb",
-        "many-tools.ipynb",
-        "dynamic-returning-direct.ipynb",
-        "managing-agent-steps.ipynb",
-        "respond-in-format.ipynb",
-        "branching.ipynb",
-        "dynamically-returning-directly.ipynb",
-        "configuration.ipynb",
-        "map-reduce.ipynb",
-        "create-react-agent.ipynb",
-        "create-react-agent-system-prompt.ipynb",
-        "create-react-agent-memory.ipynb",
-        "create-react-agent-hitl.ipynb",
-        "human_in_the_loop/breakpoints.ipynb",
-        "human_in_the_loop/dynamic_breakpoints.ipynb",
-        "human_in_the_loop/time-travel.ipynb",
-        "human_in_the_loop/edit-graph-state.ipynb",
-        "human_in_the_loop/wait-user-input.ipynb",
-        "human_in_the_loop/review-tool-calls.ipynb",
-        "node-retries.ipynb",
-        "react_diagrams.png",
-        "react-agent-structured-output.ipynb",
-    ],
-    "tutorials": [
-        "introduction.ipynb",
-        "customer-support/customer-support.ipynb",
-        "tutorials/tnt-llm/tnt-llm.ipynb",
-        "tutorials/sql-agent.ipynb",
-    ],
-}
-_MANUAL_INVERSE = {v: docs_dir / k for k, vs in _MANUAL.items() for v in vs}
-_HOW_TOS = {"agent_executor", "chat_agent_executor_with_function_calling", "docs"}
-_HIDE = set(
-    str(examples_dir / f)
-    for f in [
-        "agent_executor/base.ipynb",
-        "agent_executor/force-calling-a-tool-first.ipynb",
-        "agent_executor/high-level.ipynb",
-        "agent_executor/human-in-the-loop.ipynb",
-        "agent_executor/managing-agent-steps.ipynb",
-        "chat_agent_executor_with_function_calling/anthropic.ipynb",
-        "chat_agent_executor_with_function_calling/base.ipynb",
-        "chat_agent_executor_with_function_calling/dynamically-returning-directly.ipynb",
-        "chat_agent_executor_with_function_calling/force-calling-a-tool-first.ipynb",
-        "chat_agent_executor_with_function_calling/high-level-tools.ipynb",
-        "chat_agent_executor_with_function_calling/high-level.ipynb",
-        "chat_agent_executor_with_function_calling/human-in-the-loop.ipynb",
-        "chat_agent_executor_with_function_calling/managing-agent-steps.ipynb",
-        "chat_agent_executor_with_function_calling/prebuilt-tool-node.ipynb",
-        "chat_agent_executor_with_function_calling/respond-in-format.ipynb",
-        "chatbots/customer-support.ipynb",
-        "rag/langgraph_rag_agent_llama3_local.ipynb",
-        "rag/langgraph_self_rag_pinecone_movies.ipynb",
-        "rag/langgraph_adaptive_rag_cohere.ipynb",
-        "dynamically-returning-directly.ipynb",
-        "force-calling-a-tool-first.ipynb",
-        "managing-agent-steps.ipynb",
-        "respond-in-format.ipynb",
-        "quickstart.ipynb",
-        "human-in-the-loop.ipynb",
-        "learning.ipynb",
-        "docs/quickstart.ipynb",
-        "tutorials/rag-agent-testing.ipynb",
-        "tutorials/rag-agent-testing-local.ipynb",
-        "tutorials/tool-calling-agent-local.ipynb",
-        "time-travel.ipynb",
-        "code_assistant/langgraph_code_assistant_mistral.ipynb",
-    ]
-)
-
-
-def clean_notebooks():
-    roots = (how_tos_dir, tutorials_dir)
-    for dir_ in roots:
-        traversed = []
-        for root, dirs, files in os.walk(dir_):
-            for file in files:
-                if file.endswith(".ipynb"):
-                    os.remove(os.path.join(root, file))
-            # Now delete the dir if it is empty now
-            if root not in roots:
-                traversed.append(root)
-
-        for root in reversed(traversed):
-            if not os.listdir(root):
-                os.rmdir(root)
-
-
-def update_notebook_links(notebook_path):
-    with open(notebook_path, "r", encoding="utf-8") as f:
-        notebook = json.load(f)
-
-    for cell in notebook["cells"]:
-        if cell["cell_type"] == "markdown":
-            for i, source in enumerate(cell["source"]):
-                # Update relative notebook links
-                cell["source"][i] = re.sub(
-                    r"\[([^\]]+)\]\(([^:)]+\.ipynb)\)",
-                    lambda m: transform_link(m.group(1), m.group(2)),
-                    source,
-                )
-
-    with open(notebook_path, "w", encoding="utf-8") as f:
-        json.dump(notebook, f, indent=2)
-
-
-def transform_link(text, link):
-    dir_path, filename = os.path.split(link)
-
-    # Remove the .ipynb extension
-    filename_without_ext = os.path.splitext(filename)[0]
-
-    # If it's a local link (starts with ./)
-    if link.startswith("./"):
-        # Change to parent directory and remove ./ prefix
-        new_link = f"../{filename_without_ext}/"
-    elif dir_path:
-        # If there's a directory path, keep it and add one more level up
-        new_link = f"../{dir_path}/{filename_without_ext}/"
-    else:
-        # If it's just a filename, simply go one level up
-        new_link = f"../{filename_without_ext}/"
-
-    return f"[{text}]({new_link})"
-
-
-def copy_notebooks():
-    # Nested ones are mostly tutorials rn
-    for root, dirs, files in os.walk(examples_dir):
-        if any(
-            path.startswith(".") or path.startswith("__") for path in root.split(os.sep)
-        ):
-            continue
-        if any(path in _HOW_TOS for path in root.split(os.sep)):
-            dst_dir = how_tos_dir
-        elif "sdk" in root.split(os.sep):
-            dst_dir = cloud_sdk_dir
-        elif "cloud_examples" in root.split(os.sep):
-            dst_dir = cloud_how_tos_dir
-        else:
-            dst_dir = tutorials_dir
-        for file in files:
-            dst_dir_ = dst_dir
-            if file.endswith((".ipynb", ".png")):
-                src_path = os.path.join(root, file)
-                if src_path in _HIDE:
-                    print("Hiding:", src_path)
-                    continue
-                dst_path = os.path.join(
-                    dst_dir, os.path.relpath(src_path, examples_dir)
-                )
-                for k in _MANUAL_INVERSE:
-                    if src_path.endswith(k):
-                        overridden_dir = _MANUAL_INVERSE[k]
-                        dst_path = os.path.join(
-                            overridden_dir, os.path.relpath(src_path, examples_dir)
-                        )
-                        print(f"Overriding: {src_path} to {dst_path}")
-                        break
-                # Avoid double nesting.
-                dst_path = dst_path.replace("tutorials/tutorials", "tutorials").replace(
-                    "how-tos/how-tos", "how-tos"
-                )
-                os.makedirs(os.path.dirname(dst_path), exist_ok=True)
-                print(f"Copying: {src_path} to {dst_path}")
-                shutil.copy(src_path, dst_path)
-                # Convert all ./img/* to ../img/*
-                if file.endswith(".ipynb"):
-                    with open(dst_path, "r") as f:
-                        content = f.read()
-                    content = content.replace("(./img/", "(../img/")
-                    content = content.replace('src=\\"./img/', 'src=\\"../img/')
-                    with open(dst_path, "w") as f:
-                        f.write(content)
-                    update_notebook_links(dst_path)
-                dst_dir = dst_dir_
-
-
-if __name__ == "__main__":
-    clean_notebooks()
-    copy_notebooks()

docs/_scripts/download_tiktoken.py

@@ -0,0 +1,5 @@
+import tiktoken
+
+# This will trigger the download and caching of the necessary files
+for encoding in ("gpt2", "gpt-3.5"):
+    tiktoken.encoding_for_model(encoding)

docs/_scripts/execute_notebooks.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+
+# Read the list of notebooks to skip from the JSON file
+SKIP_NOTEBOOKS=$(python -c "import json; print('\n'.join(json.load(open('docs/notebooks_no_execution.json'))))")
+
+# Function to execute a single notebook
+execute_notebook() {
+    file="$1"
+    echo "Starting execution of $file"
+    start_time=$(date +%s)
+    if ! output=$(time poetry run jupyter execute "$file" 2>&1); then
+        end_time=$(date +%s)
+        execution_time=$((end_time - start_time))
+        echo "Error in $file. Execution time: $execution_time seconds"
+        echo "Error details: $output"
+        exit 1
+    fi
+    end_time=$(date +%s)
+    execution_time=$((end_time - start_time))
+    echo "Finished $file. Execution time: $execution_time seconds"
+}
+
+export -f execute_notebook
+
+# Check if custom notebook paths are provided
+if [ $# -gt 0 ]; then
+    notebooks=$(echo "$@" | tr ' ' '\n' | grep -vFf <(echo "$SKIP_NOTEBOOKS"))
+else
+    # Find all notebooks and filter out those in the skip list
+    notebooks=$(find docs/docs/tutorials docs/docs/how-tos -name "*.ipynb" | grep -v ".ipynb_checkpoints" | grep -vFf <(echo "$SKIP_NOTEBOOKS"))
+fi
+
+# Execute notebooks sequentially
+for file in $notebooks; do
+    execute_notebook "$file"
+done

docs/_scripts/generate_api_reference_links.py

@@ -0,0 +1,290 @@
+import importlib
+import inspect
+import logging
+import os
+import re
+from typing import List, Literal, Optional
+from typing_extensions import TypedDict
+
+
+from functools import lru_cache
+
+import nbformat
+from nbconvert.preprocessors import Preprocessor
+
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+# Base URL for all class documentation
+_LANGCHAIN_API_REFERENCE = "https://python.langchain.com/api_reference/"
+_LANGGRAPH_API_REFERENCE = "https://langchain-ai.github.io/langgraph/reference/"
+
+
+# (alias/re-exported modules, source module, class, docs namespace)
+MANUAL_API_REFERENCES_LANGGRAPH = [
+    (
+        ["langgraph.prebuilt"],
+        "langgraph.prebuilt.chat_agent_executor",
+        "create_react_agent",
+        "prebuilt",
+    ),
+    (["langgraph.prebuilt"], "langgraph.prebuilt.tool_node", "ToolNode", "prebuilt"),
+    (
+        ["langgraph.prebuilt"],
+        "langgraph.prebuilt.tool_node",
+        "tools_condition",
+        "prebuilt",
+    ),
+    (
+        ["langgraph.prebuilt"],
+        "langgraph.prebuilt.tool_node",
+        "InjectedState",
+        "prebuilt",
+    ),
+    # Graph
+    (["langgraph.graph"], "langgraph.graph.message", "add_messages", "graphs"),
+    (["langgraph.graph"], "langgraph.graph.state", "StateGraph", "graphs"),
+    (["langgraph.graph"], "langgraph.graph.state", "CompiledStateGraph", "graphs"),
+    ([], "langgraph.types", "StreamMode", "types"),
+    (["langgraph.graph"], "langgraph.constants", "START", "constants"),
+    (["langgraph.graph"], "langgraph.constants", "END", "constants"),
+    (["langgraph.constants"], "langgraph.types", "Send", "types"),
+    (["langgraph.constants"], "langgraph.types", "Interrupt", "types"),
+    (["langgraph.constants"], "langgraph.types", "interrupt", "types"),
+    (["langgraph.constants"], "langgraph.types", "Command", "types"),
+    ([], "langgraph.types", "RetryPolicy", "types"),
+    ([], "langgraph.checkpoint.base", "Checkpoint", "checkpoints"),
+    ([], "langgraph.checkpoint.base", "CheckpointMetadata", "checkpoints"),
+    ([], "langgraph.checkpoint.base", "BaseCheckpointSaver", "checkpoints"),
+    ([], "langgraph.checkpoint.base", "SerializerProtocol", "checkpoints"),
+    ([], "langgraph.checkpoint.serde.jsonplus", "JsonPlusSerializer", "checkpoints"),
+    ([], "langgraph.checkpoint.memory", "MemorySaver", "checkpoints"),
+    ([], "langgraph.checkpoint.sqlite.aio", "AsyncSqliteSaver", "checkpoints"),
+    ([], "langgraph.checkpoint.sqlite", "SqliteSaver", "checkpoints"),
+    ([], "langgraph.checkpoint.postgres.aio", "AsyncPostgresSaver", "checkpoints"),
+    ([], "langgraph.checkpoint.postgres", "PostgresSaver", "checkpoints"),
+]
+
+WELL_KNOWN_LANGGRAPH_OBJECTS = {
+    (module_, class_): (source_module, namespace)
+    for (modules, source_module, class_, namespace) in MANUAL_API_REFERENCES_LANGGRAPH
+    for module_ in modules + [source_module]
+}
+
+
+def _make_regular_expression(pkg_prefix: str) -> re.Pattern:
+    if not pkg_prefix.isidentifier():
+        raise ValueError(f"Invalid package prefix: {pkg_prefix}")
+    return re.compile(
+        r"from\s+(" + pkg_prefix + "(?:_\w+)?(?:\.\w+)*?)\s+import\s+"
+        r"((?:\w+(?:,\s*)?)*"  # Match zero or more words separated by a comma+optional ws
+        r"(?:\s*\(.*?\))?)",  # Match optional parentheses block
+        re.DOTALL,  # Match newlines as well
+    )
+
+
+# Regular expression to match langchain import lines
+_IMPORT_LANGCHAIN_RE = _make_regular_expression("langchain")
+_IMPORT_LANGGRAPH_RE = _make_regular_expression("langgraph")
+
+
+
+
+@lru_cache(maxsize=10_000)
+def _get_full_module_name(module_path: str, class_name: str) -> Optional[str]:
+    """Get full module name using inspect, with LRU cache to memoize results."""
+    try:
+        module = importlib.import_module(module_path)
+        class_ = getattr(module, class_name)
+        module = inspect.getmodule(class_)
+        if module is None:
+            # For constants, inspect.getmodule() might return None
+            # In this case, we'll return the original module_path
+            return module_path
+        return module.__name__
+    except AttributeError as e:
+        logger.warning(f"API Reference: Could not find module for {class_name}, {e}")
+        return None
+    except ImportError as e:
+        logger.warning(f"API Reference: Failed to load for class {class_name}, {e}")
+        return None
+
+def _get_doc_title(data: str, file_name: str) -> str:
+    try:
+        return re.findall(r"^#\s*(.*)", data, re.MULTILINE)[0]
+    except IndexError:
+        pass
+    # Parse the rst-style titles
+    try:
+        return re.findall(r"^(.*)\n=+\n", data, re.MULTILINE)[0]
+    except IndexError:
+        return file_name
+
+
+class ImportInformation(TypedDict):
+    imported: str  # The name of the class that was imported.
+    source: str  # The full module path from which the class was imported.
+    docs: str  # The URL pointing to the class's documentation.
+    title: str  # The title of the document where the import is used.
+
+
+def _get_imports(
+    code: str, doc_title: str, package_ecosystem: Literal["langchain", "langgraph"]
+) -> List[ImportInformation]:
+    """Get imports from the given code block.
+
+    Args:
+        code: Python code block from which to extract imports
+        doc_title: Title of the document
+        package_ecosystem: "langchain" or "langgraph". The two live in different
+            repositories and have separate documentation sites.
+
+    Returns:
+        List of import information for the given code block
+    """
+    imports = []
+
+    if package_ecosystem == "langchain":
+        pattern = _IMPORT_LANGCHAIN_RE
+    elif package_ecosystem == "langgraph":
+        pattern = _IMPORT_LANGGRAPH_RE
+    else:
+        raise ValueError(f"Invalid package ecosystem: {package_ecosystem}")
+
+    for import_match in pattern.finditer(code):
+        module = import_match.group(1)
+        if "pydantic_v1" in module:
+            continue
+        imports_str = (
+            import_match.group(2).replace("(\n", "").replace("\n)", "")
+        )  # Handle newlines within parentheses
+        # remove any newline and spaces, then split by comma
+        imported_classes = [
+            imp.strip()
+            for imp in re.split(r",\s*", imports_str.replace("\n", ""))
+            if imp.strip()
+        ]
+        for class_name in imported_classes:
+            module_path = _get_full_module_name(module, class_name)
+            if not module_path:
+                continue
+            if len(module_path.split(".")) < 2:
+                continue
+
+            if package_ecosystem == "langchain":
+                pkg = module_path.split(".")[0].replace("langchain_", "")
+                top_level_mod = module_path.split(".")[1]
+
+                url = (
+                    _LANGCHAIN_API_REFERENCE
+                    + pkg
+                    + "/"
+                    + top_level_mod
+                    + "/"
+                    + module_path
+                    + "."
+                    + class_name
+                    + ".html"
+                )
+            elif package_ecosystem == "langgraph":
+                if (module, class_name) not in WELL_KNOWN_LANGGRAPH_OBJECTS:
+                    # Likely not documented yet
+                    continue
+
+                source_module, namespace = WELL_KNOWN_LANGGRAPH_OBJECTS[
+                    (module, class_name)
+                ]
+                url = (
+                    _LANGGRAPH_API_REFERENCE
+                    + namespace
+                    + "/#"
+                    + source_module
+                    + "."
+                    + class_name
+                )
+            else:
+                raise ValueError(f"Invalid package ecosystem: {package_ecosystem}")
+
+            # Add the import information to our list
+            imports.append(
+                {
+                    "imported": class_name,
+                    "source": module,
+                    "docs": url,
+                    "title": doc_title,
+                }
+            )
+
+    return imports
+
+
+def get_imports(code: str, doc_title: str) -> List[ImportInformation]:
+    """Retrieve all import references from the given code for specified ecosystems.
+
+    Args:
+        code: The source code from which to extract import references.
+        doc_title: The documentation title associated with the code.
+
+    Returns:
+        A list of import information for each import found.
+    """
+    ecosystems = ["langchain", "langgraph"]
+    all_imports = []
+    for package_ecosystem in ecosystems:
+        all_imports.extend(_get_imports(code, doc_title, package_ecosystem))
+    return all_imports
+
+
+def update_markdown_with_imports(markdown: str) -> str:
+    """Update markdown to include API reference links for imports in Python code blocks.
+
+    This function scans the markdown content for Python code blocks, extracts any imports, and appends links to their API documentation.
+
+    Args:
+        markdown: The markdown content to process.
+
+    Returns:
+        Updated markdown with API reference links appended to Python code blocks.
+
+    Example:
+        Given a markdown with a Python code block:
+
+        ```python
+        from langchain.nlp import TextGenerator
+        ```
+        This function will append an API reference link to the `TextGenerator` class from the `langchain.nlp` module if it's recognized.
+    """
+    code_block_pattern = re.compile(
+        r'(?P<indent>[ \t]*)```(?P<language>python|py)\n(?P<code>.*?)\n(?P=indent)```', re.DOTALL
+    )
+
+    def replace_code_block(match: re.Match) -> str:
+        """Replace the matched code block with additional API reference links if imports are found.
+
+        Args:
+            match (re.Match): The regex match object containing the code block.
+
+        Returns:
+            str: The modified code block with API reference links appended if applicable.
+        """
+        indent = match.group('indent')
+        code_block = match.group('code')
+        language = match.group('language')  # Preserve the language from the regex match
+        # Retrieve import information from the code block
+        imports = get_imports(code_block, "__unused__")
+
+        original_code_block = match.group(0)
+        # If no imports are found, return the original code block
+        if not imports:
+            return original_code_block
+
+        # Generate API reference links for each import
+        api_links = ' | '.join(
+            f'<a href="{imp["docs"]}">{imp["imported"]}</a>' for imp in imports
+        )
+        # Return the code block with appended API reference links
+        return f'{original_code_block}\n\n{indent}API Reference: {api_links}'
+
+    # Apply the replace_code_block function to all matches in the markdown
+    updated_markdown = code_block_pattern.sub(replace_code_block, markdown)
+    return updated_markdown

docs/_scripts/notebook_convert.py

@@ -0,0 +1,123 @@
+import os
+import re
+from pathlib import Path
+
+import nbformat
+from nbconvert.exporters import MarkdownExporter
+from nbconvert.preprocessors import Preprocessor
+
+
+class EscapePreprocessor(Preprocessor):
+    def preprocess_cell(self, cell, resources, cell_index):
+        if cell.cell_type == "markdown":
+            # rewrite markdown links to html links (excluding image links)
+            cell.source = re.sub(
+                r"(?<!!)\[([^\]]*)\]\((?![^\)]*//)([^)]*)(?:\.ipynb)?\)",
+                r'<a href="\2">\1</a>',
+                cell.source,
+            )
+            # Fix image paths in <img> tags
+            cell.source = re.sub(
+                r'<img\s+src="\.?/img/([^"]+)"', r'<img src="../img/\1"', cell.source
+            )
+
+        elif cell.cell_type == "code":
+            # escape ``` in code
+            cell.source = cell.source.replace("```", r"\`\`\`")
+            # escape ``` in output
+            if "outputs" in cell:
+                filter_out = set()
+                for i, output in enumerate(cell["outputs"]):
+                    if "text" in output:
+                        if not output["text"].strip():
+                            filter_out.add(i)
+                            continue
+
+                        value = output["text"].replace("```", r"\`\`\`")
+                        # handle a funky case w/ references in text
+                        value = re.sub(r"\[(\d+)\](?=\[(\d+)\])", r"[\1]\\", value)
+                        output["text"] = value
+                    elif "data" in output:
+                        for key, value in output["data"].items():
+                            if isinstance(value, str):
+                                value = value.replace("```", r"\`\`\`")
+                                # handle a funky case w/ references in text
+                                output["data"][key] = re.sub(
+                                    r"\[(\d+)\](?=\[(\d+)\])", r"[\1]\\", value
+                                )
+                cell["outputs"] = [
+                    output
+                    for i, output in enumerate(cell["outputs"])
+                    if i not in filter_out
+                ]
+
+        return cell, resources
+
+
+class ExtractAttachmentsPreprocessor(Preprocessor):
+    """
+    Extracts all of the outputs from the notebook file.  The extracted
+    outputs are returned in the 'resources' dictionary.
+    """
+
+    def preprocess_cell(self, cell, resources, cell_index):
+        """
+        Apply a transformation on each cell,
+        Parameters
+        ----------
+        cell : NotebookNode cell
+            Notebook cell being processed
+        resources : dictionary
+            Additional resources used in the conversion process.  Allows
+            preprocessors to pass variables into the Jinja engine.
+        cell_index : int
+            Index of the cell being processed (see base.py)
+        """
+
+        # Get files directory if it has been specified
+
+        # Make sure outputs key exists
+        if not isinstance(resources["outputs"], dict):
+            resources["outputs"] = {}
+
+        # Loop through all of the attachments in the cell
+        for name, attach in cell.get("attachments", {}).items():
+            for mime, data in attach.items():
+                if mime not in {
+                    "image/png",
+                    "image/jpeg",
+                    "image/svg+xml",
+                    "application/pdf",
+                }:
+                    continue
+
+                # attachments are pre-rendered. Only replace markdown-formatted
+                # images with the following logic
+                attach_str = f"({name})"
+                if attach_str in cell.source:
+                    data = f"(data:{mime};base64,{data})"
+                    cell.source = cell.source.replace(attach_str, data)
+
+        return cell, resources
+
+
+exporter = MarkdownExporter(
+    preprocessors=[
+        EscapePreprocessor,
+        ExtractAttachmentsPreprocessor,
+    ],
+    template_name="mdoutput",
+    extra_template_basedirs=[
+        os.path.join(os.path.dirname(__file__), "notebook_convert_templates")
+    ],
+)
+
+
+def convert_notebook(
+    notebook_path: Path,
+) -> Path:
+    with open(notebook_path) as f:
+        nb = nbformat.read(f, as_version=4)
+
+    body, _ = exporter.from_notebook_node(nb)
+    return body

docs/_scripts/notebook_convert_templates/mdoutput/conf.json

@@ -0,0 +1,5 @@
+{
+  "mimetypes": {
+    "text/markdown": true
+  }
+}

docs/_scripts/notebook_convert_templates/mdoutput/index.md.j2

@@ -0,0 +1,33 @@
+{% extends 'markdown/index.md.j2' %}
+
+{%- block traceback_line -%}
+```output
+{{ line.rstrip() | strip_ansi }}
+```
+{%- endblock traceback_line -%}
+
+{%- block stream -%}
+```output
+{{ output.text.rstrip() }}
+```
+{%- endblock stream -%}
+
+{%- block data_text scoped -%}
+```output
+{{ output.data['text/plain'].rstrip() }}
+```
+{%- endblock data_text -%}
+
+{%- block data_html scoped -%}
+```html
+{{ output.data['text/html'] | safe }} 
+```
+{%- endblock data_html -%}
+
+{%- block data_jpg scoped -%}
+![](data:image/jpg;base64,{{ output.data['image/jpeg'] }})
+{%- endblock data_jpg -%}
+
+{%- block data_png scoped -%}
+![](data:image/png;base64,{{ output.data['image/png'] }})
+{%- endblock data_png -%}

docs/_scripts/notebook_hooks.py

@@ -0,0 +1,120 @@
+import logging
+import os
+import re
+from typing import Any, Dict
+
+from mkdocs.structure.files import Files, File
+from mkdocs.structure.pages import Page
+
+from notebook_convert import convert_notebook
+from generate_api_reference_links import update_markdown_with_imports
+
+logger = logging.getLogger(__name__)
+logging.basicConfig()
+logger.setLevel(logging.INFO)
+DISABLED = os.getenv("DISABLE_NOTEBOOK_CONVERT") in ("1", "true", "True")
+
+
+class NotebookFile(File):
+    def is_documentation_page(self):
+        return True
+
+
+def on_files(files: Files, **kwargs: Dict[str, Any]):
+    if DISABLED:
+        return files
+    new_files = Files([])
+    for file in files:
+        if file.src_path.endswith(".ipynb"):
+            new_file = NotebookFile(
+                path=file.src_path,
+                src_dir=file.src_dir,
+                dest_dir=file.dest_dir,
+                use_directory_urls=file.use_directory_urls,
+            )
+            new_files.append(new_file)
+        else:
+            new_files.append(file)
+    return new_files
+
+
+def _highlight_code_blocks(markdown: str) -> str:
+    """Find code blocks with highlight comments and add hl_lines attribute.
+
+    Args:
+        markdown: The markdown content to process.
+
+    Returns:
+        updated Markdown code with code blocks containing highlight comments
+        updated to use the hl_lines attribute.
+    """
+    # Pattern to find code blocks with highlight comments and without
+    # existing hl_lines for Python and JavaScript
+    # Pattern to find code blocks with highlight comments, handling optional indentation
+    code_block_pattern = re.compile(
+        r"(?P<indent>[ \t]*)```(?P<language>py|python|js|javascript)(?!\s+hl_lines=)\n"
+        r"(?P<code>((?:.*\n)*?))"  # Capture the code inside the block using named group
+        r"(?P=indent)```"  # Match closing backticks with the same indentation
+    )
+
+    def replace_highlight_comments(match: re.Match) -> str:
+        indent = match.group("indent")
+        language = match.group("language")
+        code_block = match.group("code")
+        lines = code_block.split("\n")
+        highlighted_lines = []
+
+        # Skip initial empty lines
+        while lines and not lines[0].strip():
+            lines.pop(0)
+
+        lines_to_keep = []
+
+        comment_syntax = (
+            "# highlight-next-line"
+            if language in ["py", "python"]
+            else "// highlight-next-line"
+        )
+
+        for line in lines:
+            if comment_syntax in line:
+                count = len(lines_to_keep) + 1
+                highlighted_lines.append(str(count))
+            else:
+                lines_to_keep.append(line)
+
+        # Reconstruct the new code block
+        new_code_block = "\n".join(lines_to_keep)
+
+        if highlighted_lines:
+            return (
+                f'{indent}```{language} hl_lines="{" ".join(highlighted_lines)}"\n'
+                # The indent and terminating \n is already included in the code block
+                f'{new_code_block}'
+                f'{indent}```'
+            )
+        else:
+            return (
+                f"{indent}```{language}\n"
+                # The indent and terminating \n is already included in the code block
+                f"{new_code_block}"
+                f"{indent}```"
+            )
+
+    # Replace all code blocks in the markdown
+    markdown = code_block_pattern.sub(replace_highlight_comments, markdown)
+    return markdown
+
+
+def on_page_markdown(markdown: str, page: Page, **kwargs: Dict[str, Any]):
+    if DISABLED:
+        return markdown
+    if page.file.src_path.endswith(".ipynb"):
+        logger.info("Processing Jupyter notebook: %s", page.file.src_path)
+        markdown = convert_notebook(page.file.abs_src_path)
+
+    # Append API reference links to code blocks
+    markdown = update_markdown_with_imports(markdown)
+    # Apply highlight comments to code blocks
+    markdown = _highlight_code_blocks(markdown)
+    return markdown

docs/_scripts/prepare_notebooks_for_ci.py

@@ -0,0 +1,230 @@
+"""Preprocess notebooks for CI. Currently adds VCR cassettes and optionally removes pip install cells."""
+
+import logging
+import os
+import json
+import click
+import nbformat
+
+logger = logging.getLogger(__name__)
+NOTEBOOK_DIRS = ("docs/docs/how-tos","docs/docs/tutorials")
+DOCS_PATH = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+CASSETTES_PATH = os.path.join(DOCS_PATH, "cassettes")
+
+BLOCKLIST_COMMANDS = (
+    # skip if has WebBaseLoader to avoid caching web pages
+    "WebBaseLoader",
+    # skip if has draw_mermaid_png to avoid generating mermaid images via API
+    "draw_mermaid_png",
+)
+
+NOTEBOOKS_NO_CASSETTES = (
+    "docs/docs/how-tos/visualization.ipynb",
+    "docs/docs/how-tos/many-tools.ipynb"
+)
+
+NOTEBOOKS_NO_EXECUTION = [
+    # this uses a user provided project name for langsmith
+    "docs/docs/tutorials/tnt-llm/tnt-llm.ipynb",
+    # this uses langsmith datasets
+    "docs/docs/tutorials/chatbot-simulation-evaluation/langsmith-agent-simulation-evaluation.ipynb",
+    # this uses browser APIs
+    "docs/docs/tutorials/web-navigation/web_voyager.ipynb",
+    # these RAG guides use an ollama model
+    "docs/docs/tutorials/rag/langgraph_adaptive_rag_local.ipynb",
+    "docs/docs/tutorials/rag/langgraph_crag_local.ipynb",
+    "docs/docs/tutorials/rag/langgraph_self_rag_local.ipynb",
+    # this loads a massive dataset from gcp
+    "docs/docs/tutorials/usaco/usaco.ipynb",
+    # TODO: figure out why autogen notebook is not runnable (they are just hanging. possible due to code execution?)
+    "docs/docs/how-tos/autogen-integration.ipynb",
+    # TODO: need to update these notebooks to make sure they are runnable in CI
+    "docs/docs/tutorials/storm/storm.ipynb",  # issues only when running with VCR
+    "docs/docs/tutorials/lats/lats.ipynb",  # issues only when running with VCR
+    "docs/docs/tutorials/rag/langgraph_crag.ipynb",  # flakiness from tavily
+    "docs/docs/tutorials/rag/langgraph_adaptive_rag.ipynb",  # Cannot create a consistent method resolution error from VCR
+    "docs/docs/how-tos/map-reduce.ipynb",  # flakiness from structured output, only when running with VCR
+    "docs/docs/tutorials/tot/tot.ipynb",
+    "docs/docs/how-tos/visualization.ipynb"
+]
+
+
+def comment_install_cells(notebook: nbformat.NotebookNode) -> nbformat.NotebookNode:
+    for cell in notebook.cells:
+        if cell.cell_type != "code":
+            continue
+
+        if "pip install" in cell.source:
+            # Comment out the lines in cells containing "pip install"
+            cell.source = "\n".join(
+                f"# {line}" if line.strip() else line
+                for line in cell.source.splitlines()
+            )
+
+    return notebook
+
+
+def is_magic_command(code: str) -> bool:
+    return code.strip().startswith("%") or code.strip().startswith("!")
+
+
+def is_comment(code: str) -> bool:
+    return code.strip().startswith("#")
+
+
+def has_blocklisted_command(code: str, metadata: dict) -> bool:
+    if 'hide_from_vcr' in metadata:
+        return True
+    
+    code = code.strip()
+    for blocklisted_pattern in BLOCKLIST_COMMANDS:
+        if blocklisted_pattern in code:
+            return True
+    return False
+
+
+def add_vcr_to_notebook(
+    notebook: nbformat.NotebookNode, cassette_prefix: str
+) -> nbformat.NotebookNode:
+    """Inject `with vcr.cassette` into each code cell of the notebook."""
+
+    uses_langsmith = False
+    # Inject VCR context manager into each code cell
+    for idx, cell in enumerate(notebook.cells):
+        if cell.cell_type != "code":
+            continue
+
+        lines = cell.source.splitlines()
+        # skip if empty cell
+        if not lines:
+            continue
+
+        are_magic_lines = [is_magic_command(line) for line in lines]
+
+        # skip if all magic
+        if all(are_magic_lines):
+            continue
+
+        if any(are_magic_lines):
+            raise ValueError(
+                "Cannot process code cells with mixed magic and non-magic code."
+            )
+
+        # skip if just comments
+        if all(is_comment(line) or not line.strip() for line in lines):
+            continue
+
+        if has_blocklisted_command(cell.source, cell.metadata):
+            continue
+
+        cell_id = cell.get("id", idx)
+        cassette_name = f"{cassette_prefix}_{cell_id}.msgpack.zlib"
+        cell.source = f"with custom_vcr.use_cassette('{cassette_name}', filter_headers=['x-api-key', 'authorization'], record_mode='once', serializer='advanced_compressed'):\n" + "\n".join(
+            f"    {line}" for line in lines
+        )
+
+        if any("hub.pull" in line or "from langsmith import" in line for line in lines):
+            uses_langsmith = True
+
+    # Add import statement
+    vcr_import_lines = [
+        "import nest_asyncio",
+        "nest_asyncio.apply()",
+        "import vcr",
+        "import msgpack",
+        "import base64",
+        "import zlib",
+        "import os",
+        "os.environ.pop(\"LANGCHAIN_TRACING_V2\", None)",
+        "custom_vcr = vcr.VCR()",
+        "",
+        "def compress_data(data, compression_level=9):",
+        "    packed = msgpack.packb(data, use_bin_type=True)",
+        "    compressed = zlib.compress(packed, level=compression_level)",
+        "    return base64.b64encode(compressed).decode('utf-8')",
+        "",
+        "def decompress_data(compressed_string):",
+        "    decoded = base64.b64decode(compressed_string)",
+        "    decompressed = zlib.decompress(decoded)",
+        "    return msgpack.unpackb(decompressed, raw=False)",
+        "",
+        "class AdvancedCompressedSerializer:",
+        "    def serialize(self, cassette_dict):",
+        "        return compress_data(cassette_dict)",
+        "",
+        "    def deserialize(self, cassette_string):",
+        "        return decompress_data(cassette_string)",
+        "",
+        "custom_vcr.register_serializer('advanced_compressed', AdvancedCompressedSerializer())",
+        "custom_vcr.serializer = 'advanced_compressed'",
+    ]
+    if uses_langsmith:
+        vcr_import_lines.extend(
+            # patch urllib3 to handle vcr errors, see more here:
+            # https://github.com/langchain-ai/langsmith-sdk/blob/main/python/langsmith/_internal/_patch.py
+            "import sys",
+            f"sys.path.insert(0, '{os.path.join(DOCS_PATH, '_scripts')}')",
+            "import _patch as patch_urllib3",
+            "patch_urllib3.patch_urllib3()",
+        )
+    import_cell = nbformat.v4.new_code_cell(source="\n".join(vcr_import_lines))
+    import_cell.pop("id", None)
+    notebook.cells.insert(0, import_cell)
+    return notebook
+
+
+def process_notebooks(should_comment_install_cells: bool) -> None:
+    for directory in NOTEBOOK_DIRS:
+        for root, _, files in os.walk(directory):
+            for file in files:
+                if not file.endswith(".ipynb") or "ipynb_checkpoints" in root:
+                    continue
+
+                notebook_path = os.path.join(root, file)
+                try:
+                    notebook = nbformat.read(notebook_path, as_version=4)
+
+                    if should_comment_install_cells:
+                        notebook = comment_install_cells(notebook)
+
+                    base_filename = os.path.splitext(os.path.basename(file))[0]
+                    cassette_prefix = os.path.join(CASSETTES_PATH, base_filename)
+                    if notebook_path not in NOTEBOOKS_NO_CASSETTES:
+                        notebook = add_vcr_to_notebook(
+                            notebook, cassette_prefix=cassette_prefix
+                        )
+
+                    if notebook_path in NOTEBOOKS_NO_EXECUTION:
+                        # Add a cell at the beginning to indicate that this notebook should not be executed
+                        warning_cell = nbformat.v4.new_markdown_cell(
+                            source="**Warning:** This notebook is not meant to be executed automatically."
+                        )
+                        notebook.cells.insert(0, warning_cell)
+
+                        # Add a special tag to the first code cell
+                        if notebook.cells and notebook.cells[1].cell_type == "code":
+                            notebook.cells[1].metadata["tags"] = notebook.cells[1].metadata.get("tags", []) + ["no_execution"]
+
+                    nbformat.write(notebook, notebook_path)
+                    logger.info(f"Processed: {notebook_path}")
+                except Exception as e:
+                    logger.error(f"Error processing {notebook_path}: {e}")
+    
+    with open(os.path.join(DOCS_PATH, "notebooks_no_execution.json"), "w") as f:
+        json.dump(NOTEBOOKS_NO_EXECUTION, f)
+
+
+@click.command()
+@click.option(
+    "--comment-install-cells",
+    is_flag=True,
+    default=False,
+    help="Whether to comment out install cells",
+)
+def main(comment_install_cells):
+    process_notebooks(should_comment_install_cells=comment_install_cells)
+    logger.info("All notebooks processed successfully.")
+
+
+if __name__ == "__main__":
+    main()

docs/cassettes/LLMCompiler_15dd9639-691f-4906-9012-83fd6e9ac126.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/LLMCompiler_31854dfd-b82f-4c24-9b58-6bae66777909.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/LLMCompiler_730490c6-6e3a-4173-82a1-9eb9d5eeff20.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/LLMCompiler_942dab42-ad42-4ba2-90d5-49edbe4fae68.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/add-summary-conversation-history_048805a4-3d97-4e76-ac45-8d80d4364c46.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/add-summary-conversation-history_40e5db8e-9db9-4ac7-9d76-a99fd4034bf3.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/add-summary-conversation-history_57b27553-21be-43e5-ac48-d1d0a3aa0dca.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/add-summary-conversation-history_7094c5ab-66f8-42ff-b1c3-90c8a9468e62.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/agent-handoffs_62ba5113-e972-41e6-8392-cc970d4eea72.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/agent-handoffs_f39f99b0-95c7-422f-96a6-e612fde186df.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/agent-simulation-evaluation_6f80669e-aa78-4666-b67c-a539366d5aab.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/agent-simulation-evaluation_f58959bf-2ab5-4330-9ac2-c00f45237e24.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/agent_supervisor_56ba78e9-d9c1-457c-a073-d606d5d3e013.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/async_8edb04b9-40b6-46f1-a7a8-4b2d8aba7752.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/async_cfd140f0-a5a6-4697-8115-322242f197b5.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/async_f544977e-31f7-41f0-88c4-ec9c27b8cecb.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/breakpoints_51923913-20f7-4ee1-b9ba-d01f5fb2869b.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/breakpoints_cfd140f0-a5a6-4697-8115-322242f197b5.msgpack.zlib

@@ -0,0 +1 @@
+eNqFVH1sE2UY77IER8ISnBqDQLgVMBO4rtfryjpiZJaBhMFY122yyfDt3dPesevd7e5ttzEnbMOEAAqHYCAhgKxrWZmw8SEmQKICQT6MQjDblK9oRFH/QMQPEhJ8r2vZCIj9p++9z+95fs/z/J73aY9HQNNFRc7oEWUMGuIw+dCN9rgGDWHQ8epYCLCg8NHFZRW+zrAmDk4VMFb1ovx8pIo2JGNBU1SRs3FKKD/C5IdA11EQ9Khf4Zu/zXC3WEOoaRlW6kHWrUUUY3c4Z1DWNIrc1LZYNUUCcrKGddCsxMopJBUZm1c6II0TqICiUVgAqhEQ+dMoUab0ACUrjdbWpWY4hQfJhHMSCvNAs3QBrSuyDJh2EEK7y2E342JFkVKUMgrBcHzTyIPOaaJqlm8aPEiSKKxQelgLpKj9NhMnymoYL9M5AUKIAFusKqkfNCwmq2mxkq5pzckTblaHOLAmykFrayvxNrsqasCbWaSgZgFpqOJfDhwm0KWtcQEQT7TZEBUUHRt9j3R7P+I4UDENMqfwhMD4KLhCVGdQPAQkhCHBmQ1Iymkk6gFUGkliBGJDXkYvUlVJ5JBpz19OmtWT6jpt5vKoOWGKQxPNZGwcKU7nkb+4mQyHTNltrNPm6G2idYxEWSLq0hIiKcXUpP3oSIOKuHoSh04NnhEbct43EqPoRtdCxJVVPBTSlMroQlrI5Tw48l4Ly1gMgRH3LH6ULmUcpmNtDGNz9z0UWG+WOaMrgCQd+h40+YFLggwRS9tdtJ3Zl+6SBHIQC0Yny7B7NNBV8migI0ZC4rDeHiWKwPkv4qkx3122IK3mVUtOdA5RxzjuE8IzKIeLqgCVMoeUYtgitqCogKXmLfT1eFI0vseK0efTkKwHiCAlafHjnBCW64FPeB4r+6B1uCyN8EtiSMR06o0TscxPI+q02+2DLz4RqZGxF2WTMcq63e7/iUs6A9g4ZNZH2920w+VLVemsGaQe5zm0KFL5xMx8SEZTnoAczieNpp6I/o982JpEKmla5I1j5LzMzpSWVlYH9Igyd0lEdwHjb6rxesPlh5toTlLCPI3JtgQ6ORBN2Bik2AAHjNvlcjNQOBN4vxMcvB3YwpkMW+gu4AOdEREZCcbGUEFFCUqw3zOX9iCySOiK5NgY8TlLFhUvnO/peZ32Kn6F9M+HSJ9lRYZYBWhkHI1Ekpo8cA1ixN1bvMQ4VMi5WcT6A27eUWjnkIMuqfb2pgfowYBEze2Q3MptsaGNdCqjdtK6LEvyl7m6/NyiE7PH3Nty6nlb7eZRZyfPO1u7auya2zlrq7q/6xkYgP69OZV3Gw91T7t+8syBl7kNp6f3VuTtGv2HY/zVN377sXr/waO/a463t02acG3C5f67k4WNkbbR7+RudbeP+sr2XGmWa01uRnZ22YXijC1sw9qOK58JY7dmwcbg3bqPdwZ3fejPmdL2fejwuGn/bPm5Ne/N9XXrp/bL3edCP/lm/7C35suB6d3llRdappQvcHo7qz+41JEbvpFd6fJdzqx9b9YvL5QU7PF/uuOTbc9055yLrv7m/EXf/FDHASd3beulgbZF91/jIjDm5vWrXZtPO8bXbb9W1zDrrRUTr+yYcPHm4KbT7x8Nfj07Nv/YnwdO7i55Nq/q1rgLR85sX3nH03+8PuvzdRc7R5eurLzz7qqdT3e/mpdXFM/965WXqn4Ndd16yrvK34ijbZ339k28sfTvbIvl/v1MS0Nm34nbGRbLv8xd7PE=

docs/cassettes/configuration_070f11a6-2441-4db5-9df6-e318f110e281.msgpack.zlib

@@ -0,0 +1 @@
+eNqFVFlsG0UYDqqKq1akiEOoeSCLoYjDY++u76iIGrdEzdFEsasmLlE0nh17N17vbnbHkd1Sobr0kKgoQyvxVkTio7LSNlFd9aFUSByiHBIPvGAesEQkaCUkVIEA9YEyduwkVaKwT7P/9X3///0z+fI0Ni1F1x6aUzSCTYgI+7FovmziqQy2yNulNCayLhWGhyLR2Yyp1HbKhBhWj8sFDcUJNSKbuqEgJ9LTrmnBlcaWBZPYKsR1KVd744g9DbMTRE9hzbL3cAIvehycvR3ELIeO2E1dxexkz1jYtDMv0hkTjTRMsmI/Ot5I0CWsNgxIhRkJA9Ep2I+WZQwlxv5sQdYtQhfW8LkCEcIGAVhDuqRoSXopeVgxHJyEEyokuMKANNxsmFZSGBsAqso0Li1l0XloGKqCYMPvmrR0ba5FDJCcgde6Kw3+gLWlEXo91ObhGs6x8Wkc73R7nOJ8FlgEKprKBgBUyCiVjKb/xmqHAVGK1QEtaWhpKfny6hjdosVBiIYiD5SEJpJpEZppn+fqaruZ0YiSxrQcHl4L13KuwLmdguAMLjxQ2MppiBYTULXwwvKQl1MqIi+6Ae8DvHC5PSUVa0ki05mgeNHElsG2Ch8vsYokY+ULTBD87a1yaxFmhvrbYv7U8VhhDxOH3ozKGQcn+rgINjhW3sMJ7h63v0cUud7B6Fy4hRJdV4uFqAk1K8H02NvWvozkjJbCUiW8ruo1+0pXJsNXlbRCQOsSMK0av7Qg8jxfe37DSBOn2dAaiAUhGAz+T102GUxotdEf4INA9EWXuvR6YjVuvcylq9TiU/Lwja/23AaRK3za0dyG0evzEcVYpUUaKBL9mJ0neGEgEhqDU6FYrG8wm/UL+uj+yZHe0WtZgFQ9IwHCnhMMmvuQJbTGJRIogVDQ7xb8iQDyegOSJyHFAxIUsB+5A57ZaQXSiuAUuKSuJ1V8Jfw6CEMkYxBprg0t7xnbHxrcF54bBSN6XGfzi0I2Z03XcCmCTbaNtNKEZvfbxCWWPhIao9UACrqhNyH64pDhBgSw9+DIfHuBlhek0Hgcms/WMbamJjN9/mX3O1s6mt+mgXdDqeO7Hz3xVn89d6hafOW3S7b+Oy++t3v7R7dmHp8dT55xb3v47idP7Tx24ek3f1+8m6h6dx1Of+2of3jq58U/M7fvfTD5t7OODg7c22q70VmNFbq68p+9MLU5dO3ANtW4XSxtOfvSyej3i39EOk/1/XD6kX8D9d4zpQP1TxfPxc/bHK92Tornn9385Enb1Hisa8f11+68f/rl/K9PzIZ/vPDPDrD9q75zE/ET37lt+/7qvgm+6WaM79/f1HHxmV1f/MLO/wGUNlTq

docs/cassettes/configuration_718685f7-4cdd-4181-9fc8-e7762d584727.msgpack.zlib

@@ -0,0 +1 @@
+eNqFVF1oHEUcTxOEEhWkqCBiuz1r8SFzt1/3sdGHhGsqbc0lJNfGRkOZzM7dbm9vdrM7G3MNLTaJIliUKehDBSnt5a6cZ5vQD5VqbGxAwaBPgvdgCwr1RSxCfClInLvcJSkJcZ9m/5+//+/3n5kojmLXM22yrWwSil2IKP/x2ETRxSM+9uhUIYupYev53p7+5EXfNSsvGJQ6XnsoBB0zCAk1XNsxURDZ2dCoFMpiz4Np7OWHbT1XeWM8kIVjx6idwcQLtAuSKKttQqARxC2vjwdc28L8FPA97Aa4F9kcCaFVk2EGTg5VE2wdW1UDsqCvYyAHpcDJooGhztF/kDdsj7LZDXiuQISwQwEmyNZNkmafpU+YTpug45QFKS7xRgTXBmalDMYOgJY5igsrWWwGOo5lIlj1h457NinXgQGac/BGd6mKH/CxCGWfdzZwhHpznD4iiEFFDcozY8Cj0CQWJwBYkEMqODX/zfUOB6IMrwPq0rDCSvLl9TG2x6a7Ierpf6gkdJHBpqGbjahX19tdn1Azi1kx3ruxXd251k4JSlJQm32osJcjiE2noOXh2VWSV1NKsigrQIwAUbrcYMnCJE0NdkGTL7nYc/hW4ckCr0h9byLPBcGL3xfri3Ch51BDzDtNO/L7uDjs66ThtwlyROjHjsDLq4KktCvRdn54pTtZjte7JDfVYjbpQuKluB5dDe2LyPBJBuul+KaqVwJrU7m8v2VmTQrql4BrVf1leVkUxcreLSNdnOWkVTvmJU3T/qcuZwZTdq06HxA1IEeSK1OG1cGKsFnmylWq4ymoYvWr7Nkicg1PI1rYMnpzPLI6WKqDBqbOvuLnY6KU6DqSGemWnf0Gob6PkwMwd5ykr48BZNm+Dih/TjCo7cMYZRUhCmNhRRfRcEROQTU6rGjRsBRVVE1TJQWlwhdHTchKUlAS0radtvCV+H4Qh8jAoL+2Nqy472iis/tAvPwa6LOHbc5fEnKeiU1woR+7fBtZqdaa328XF3h6X+dRdi2GNAWGUwhpMSWGYhLoGuibaSzQ6oLkq49D7dk6zdfU5aaF+V3vbW+qfS2vvj/fOtHxZNc30zc/Cbw9uCi/OLi0rW/qsQeieQLNRVPvLu882Pnpo3/sDL7ZMfTtb7sPzyVGK/c+ei72690HA/5fiaEjd69Pnp579lzbjpGn5s8/fqo5kX/aL4tjU2dfbmu9P3zgB/rhrfPbywut48+cev7gv/mf4Mie+7ebf/+5Q1VzhxLNtye+WAzfOGPvXjqz8Mi8u3RH+LHnz7fOfXzpy3demr21NzP5xD+7st/93dLUtLzc0nS2c+aXexz3f2MeVKE=

docs/cassettes/configuration_e043a719-f197-46ef-9d45-84740a39aeb0.msgpack.zlib

@@ -0,0 +1 @@
+eNqFVFlsG0UYdtUXVDVSWomoD0hdVgUByth75XBaEMHuATRNSEyTFqFqPDv2Ll7PLDvjkBAqlJRKASTKShQegCIljl2s0CS0KA+cIqAURLnUAuZSqbjKCw9FgifKrGMnqRKFfZr9z+//vn9mpNiPPWZTsm7SJhx7EHHxw/yRoocfzmHGnyhkMbeome/q7EmM5zy7fJPFucvaIhHo2mFIuOVR10ZhRLORfjWSxYzBNGb5JDUHy48NyVk4cIjTDCZMbpNURTMaJbkWJCwPDMkedbA4yTmGPVl4ERVICA9Mli0ffjBIoCZ2AgNyYM7EQAurQSQbZBxnA7uHmUuJKdlEsjl0bEjkw0ULQ1NMdyxvUcb9mRV4pyBC2OUAE0RNm6T919KP2m6jZOKUAzkuCSAEVwjxSxmMXSAK9+PCQpY/DV3XsREM/JGHGCWTVeCAD7p4pbsUzAfE2IT7s+01HJGuQUEvkZSwboS16QHAOLSJIwgCDhSQCm7F/+ZyhwtRRtQBVen8wkLyqeUxlPkTHRB19lxTEnrI8iegl202Ti+3eznC7Sz2i7Gule2qzqV2elhVw9GZawqzQYL8iRR0GJ5ZJHkxpaQpmg6UZqCop2osOZikueWPq5pxckE+ho8UREmeYyN5oQj+5GyxuiljnffW1PwxtDkfF+r4byesXKOkNUs92JVEfUNS9Ta9pU0cdnckJmPVNolVxZhJeJCwlBBkZ038IrJyJIPNUmxV2cvy0lie6O/YWZuD6i0RYgW/fl5TFKV885qRHs4K1oKOeTUajf5PXcEM5v6ZYD6gRIHWnFiYssk4WJZWy1y4a1U8BUMJvvK2NSKX8NSipTWjV8ejGQdLVdDANv23xPmQovbpSaruV/fdn9n1iKHtgfGEh6jxxgBADs2ZgIv3BoPKQgxwvyxpGtQ1nGoxkI5aUbOqq62qopsmjrZEURJq4/029EtqWJXSlKYdPBXbBWIQWRj0VNbGL8YP7GvvuDs22Qe6aZIK/hJQ8EwowYUe7Il19EuV1uKCe7gg0rvbD/hnWlFUh02pVItp4FbUqoKdvd3TtQVaXJB88DpU3rVhsaaeMH0wt/Xp60KVb/3eZ2Y2vH9nffzdD1/tVG+75esnT758dPSo/NPe5+t3/J3s7zz/7OMvjI5ceO/FeaXu4xsaem/9Er6+Y3I2/e3380Mnpp764VLTHZ/t377l99Njn8qbeus3/nFx+8X4PffNbziSOfvRnHwl/Ov5rXWbt5jDx/vgsXM0fvmLy69M9z0X/uvzExvjseNf/bxNaRy9kkDn/mm4a3bPS5sad/9Zd+m30WyXd33TBffGhm/MZP3Yv+P2d++sC4WuXl0fun14zvtFIP8PysRiVQ==

docs/cassettes/configuration_ef50f048-fc43-40c0-b713-346408fcf052.msgpack.zlib

@@ -0,0 +1 @@
+eNqFVF1oW1UcjxRkdhOKfdnL2PWiE2fPzf1I0ySWQZu01WmW2oS16zbGyb3n5p725t67e09C45jTbvgy5jyMgSgI29JkDXFLcOLEj+HHcIKgwl6CdIqCsBdR9MUHqSdp0na01Pt07v/z9///fufMl/PI9bBtPVTFFkEuVAn78eh82UXHc8gjZ0pZRAxbK44nkqkrORc3njQIcbyI3w8dLECLGK7tYFVQ7aw/L/mzyPNgBnnFtK0VGkdO8Fk4d4zYs8jy+AgniXKgj+M7Qcxy+ATv2iZiJz7nIZdnXtVmSCzSNBmYP3m0mWBryGwaVBPmNARkQeJPlg0ENYb+fNGwPULrG/Bch6qKHAKQpdoatjL0vczL2OnjNKSbkKAKa2Sh1sC0MouQA6CJ86i0kkVr0HFMrMKm3z/j2Va1DQyQgoM2uitN/ICNZRH64VAHh3+8wNZncaKgBAS5Ngc8ArFlsgUAEzJIJafl/3i9w4HqLKsD2tTQ0krytfUxtkcX4lBNJB8oCV3VoAvQzQYD76+3uzmL4Cyi5ej4xnZt51o7RZAkIVx/oLBXsFS6oEPTQ/XVJa+mVGRRVoAYBKJ0rbMlE1kZYtDLYfmqizyHqQqdLrGKJOfNFxkh6Ns75bYQLide6JB5z/dYMcbIoZ+mjFwfJwe5JHI4Vj7ASUpEGYjICjcWT1Wj7S6pTbmop1xoeTrjY6TDfVk1ctYs0irRTVlv8GtTuay/ibOYgPYlYFw1f2lRFkWxsWfLSBdl2dKaHYtSOBz+n7psM4jQG835gBgGcjC1MmV/YLrBbZa5cpXaeEoBsfk1ntgicg1PJ5rbMnpzPLIyXWmDBlijn7DzMVEazs+kjJnRgzp+aSCkY01PH8fS6AdzQDXtnAYIe04QaOlhjtAG1x9QQkGoy4qoyyENBZRgOBxS5aCip9WQruhX8hjSiiRIXMa2Mya6Hh0FUagaCCRbsqHl2KEDQ/Hno9UpMGGnbba/FGR7tmwLlZLIZWqklVZrdr9dVGLpE0OH6I2QGlZgv96vhwIwpIYkMDI5UesIaFUgxebj0Hq2XmMydZnpqy93n93ma31dL77xefcXYk/s1u3wWL27+6NCz0jP4N0Lzz1yn799c3Hp3MH9y0f3dr/78L3B1++PX6zd/GbhLf2f6rR/cl/ir6/hrWcHz7/ykzAgfj8ZPz3C/z4sGumdr/YuxnY9s8OqF33bdx/Ziwff0cQ/6MUpmFiyY4u7/k5MmU+fCQ2fCvacy/3w5oU7NU7YHn/018PblnrrT00deHxn8bveHy/9EsGX/tzfV2vc5fb8O3b2s1NdPt/ycpdvx9s/7/uNIf8P86BOOQ==

docs/cassettes/configuration_f2f7c74b-9fb0-41c6-9728-dcf9d8a3c397.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/create-react-agent-hitl_740bbaeb.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/create-react-agent-hitl_83148e08-63e8-49e5-a08b-02dc907bed1d.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/create-react-agent-hitl_9ffff6c3-a4f5-47c9-b51d-97caaee85cd6.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/create-react-agent-memory_187479f9-32fa-4611-9487-cf816ba2e147.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/create-react-agent-memory_9ffff6c3-a4f5-47c9-b51d-97caaee85cd6.msgpack.zlib

@@ -0,0 +1 @@
+eNrtVglwE9cZtk1LHQKYDG4mJQEWkZA0eKWVdnU6psUXlsGnZHyCWe8+SWtLu/LuylgYDY0xJJQrCySFcCSA8SGMMWDAEJsCU2iAkkkZ8MRQjnAGAwHaAAVC6VtZJnahnaSl006bnZF233v/+4/3/f//vsraMsALDMeGNjCsCHiSEuFAWFRZy4NSDxDEqhoXEB0cXZ2eZrGu9fBMx+sOUXQLJpWKdDNKzg1YklFSnEtVplZRDlJUwW+3EwTUVBdxtPd46JsVChcQBNIOBIUJya9QUBy0xYpwoMiGW14VENEBkKmAhC8eYVgkNTfuZ4ooRMFzTiBLeQTAK3yT4IyLo4FTnrK7RZTgZCEWDtXwLYg8IF1wYCOdAoATInC5YUiih5eVYEpMnuM4Z9AL0esOKLd52EDUsq5H3yakQsGSroCAHYiFQedkGRoIFM+4g2KKLAFA9xkYA4dAyR5h2DjeRcpiSnmbm+ShPnjGQkC5m4dnx4sM6BpSjOgNfADWI8eQr2C9lLxNsCnkuLudhUEyrF3h88mnAyFieEAHxAMKekpyRcWAEqGkb5Kv1gFIGlpeWO3gBFFq7A3dRpKiADxOwFIcDbVLG+zTGHcUQgObkxSBH8LFgsCxSP4SANwo6WTKQE3XLqmJdLudDBUIVFUscGxDEF5U9uTxZb8MJgqTgRWl5jToxFizKt0Lc4xF1ErCoMSaylFBJBnWCXMGdZLQnxp3YP2jngtukiqBStBg/ko1XZsbe8pwgrQuhaTSLL1UkjzlkNaRvEtHbOk5z3tYkXEBqTYu/XFzwcVvzOFKtVpp3NRLseBlKWldIP2299oMRN6LUhzUIa3GGrvPxwlYu+iQ1uIGbR0PBDesGDCzBm4TPUJlNcQC/O7j2mDlrEkb3w3iqZDnq+MhLlKb1eGJQjQ6xALciAbTEIgaN+F6E0Eg41KsDXFBM9YnwrDJypOsYINQJHTDXks5PGwJoP1xTwS8TQYcRiO7DwsTBeVuTgBo0CupIQfN7OoZqDl+S1d2oRxvJ1lmWsCsVC+DCXsEwzYHl2ERyCqhcdQlSGt1WnVjcKX7nP0wLgxVYyim3iHnPgXTSnbczfEiKgAKdiTRK3VEuchyOadicLUW12EYFg3rj3J6aGDxFMVzLmhTiEbcPHByJL2zHIVdATgZFwNBCPwHux3MFzXcjLU8LiFyJYAVpDoc63p29RThgWxBDuORomojfFqfLNStSyPLGPXanb3FBNDDobU6l9Dy+HpQxRpMaCjvFkYZWup4GQ4KDVrcgBE4bSRsNhtZhGtxmiQISk1raEBglHpjXCIaR1IOgFoC2SbVxuemjk0xx/ktUHccx5UwYNHx0D6FhZStsMgVI/KxuYQeM+SWMwk6QE2wi4bsBD7ZGJfnMXD2bHWcNW2qy6op1nsyULVeo8e1eoOOQNVKTKlWqlF7bKoFJ5QevJyPz0wrTLeZC115Ro2DzC21KK1ZyhQvpeWLnRPi8HiPJSM7L2dsDkUn0+PNVGJ5ri2bNrpyQA6WnJ1KZ+umZqUbY20WPCMD4gk7bYwqGoGZCPugEBOsBxTWAypXA2HCuqshGqEDWRCj7N37opEkeJ2lsU5vNCwjmE4AvmGftjAiiEnlWNCxBJ6Bp4yhY7zGskxeF4vbnOOd1vTYeA1RLieXMTMv0+nCPWZWnZdozqA8dqykxyHgah2KBc9BhxGGQPJ84/o/6dW2HLRneaNpgesI4shyAsvYbDUWwMMSkvyUk/PQsI3zoAZinjk2V2o2UEac1OkJijLQehqj0ITszKZubY+aQbV8BwQu8Ddrui6dfaG7h88NDwk8feDv4UMx8/fscizSd2l0w/2XRoWNiG/d4N+M5lmZazXFh6oKhBGT5x++Ojcv8sLp0UlhxPGvp+Te+fOKiunTI4ZRiJD0k7djXs04dvBh+cgTXw/2zcDWf3Dlo+I/LZ3h61+4q63x+nB2O3blhYuXI/rtbBoTbjnWzzzEVzkrIfWz+k8WY3PO0lvnTftQY/QvmNh+XjVveN/P90YUzRi2ck7FyB+akjpUC9X7Bz44lXvUuCv2YGXHuszVQmt80lvj572p9a8PmZpqOvv+FF3lXkfsyR3t8zMH/2JexrIzyfPnp13BjAuNpes2q8ytFw7dv+3N53Rlvvvnrp88fFZ4Z8K9ldUnduqtRF7/uxNurF41WUv1JzZOY+csaUNqY46PNlG7XR3WuvotA98aGm6+NvDI0C8mXj0Tfv3L4W0zVs5IW9OUQyxYLyReulcaPmnZ5m0XD0wC4bOOHrmGz/3DLW5ZYueknbd8H3rvlKTnW44tkbyJJw/sP2CO3L9syB7v9L4HBmVTMc88HHeQf1l5f+FQ2+XzmZ18ZHjfxQ/y92xd0HSwX/345q3vPjj68wz7C6+URjZenPtK+bjrA2SY+oSMiY3tMwZi9jRpXZj/KdG6KKTnVtbjdPYQIeHtAG9EuBQkb4UU6fxHDI6R6ZBCFio067UppM7iLUlxJyfzifETS9NiiSRM/22JHsnbPS7olWxNUVEQoFgF8LtA5mYFCp9Cpla9vVeYRcTF2B0iUgSQQO155cCDXK47KDmOXvEUfhuvv+e//zL/PRUy6HsG/J9nwDVUgGFIHX/8LycY/4ar/zH2rzNovhv7//H/KPvXqLX/h+xfZ3j67N9mJG0aiia0NgwAggS4ASeMGqA2EmpcR+n+Lvt/CqySwg0k9t1Ypf1vWeU7h9mZ2KCq62/sO3hpkFQYtl13x5rV0pw1q3/UmfbPFrTVJWScaqtMXzRs2k1y18qbV1fFhIzq93yfQyWpXqr64Y3XTNbaczdvnW+fdFtMLt+qWhVhbh78zPJbA1f6pqT+utHb+OJIqWpi9or881W+TkXB7PUpLScaf/TpF2GAW9//bsk11cwLxyN0fynSDilBeTFqtj4i5Mwbrb6ErDP6uSOWPnh9gOm3o+mbxA92N7zXtrdF2Ptc9m9s+qUlCXWz283zb8xaUdyMRL40+fanb/tHfTyIrz+xZvnpaPS9Ded8pceSjZ2/qv/l0Xc3mYSRH3yV+drnnUcVU/NunTYdmT3gq7OhrRGjt8/YNmV/5/705HuDs4a3PLux9GrZuRfnJSa+39K6ePtD75GwOc9e/rJxf+OtKj8buudoac6iHZ88p2N+ap3VnlMaU8QcqSuwgT13lUWn9t0P7SJ/FVONF1PCQkL+Cr1ZsOw=

docs/cassettes/create-react-agent-system-prompt_9ffff6c3-a4f5-47c9-b51d-97caaee85cd6.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/create-react-agent_187479f9-32fa-4611-9487-cf816ba2e147.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/create-react-agent_9ffff6c3-a4f5-47c9-b51d-97caaee85cd6.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/delete-messages_3975f34c-c243-40ea-b9d2-424d50a48dc9.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/delete-messages_57b27553-21be-43e5-ac48-d1d0a3aa0dca.msgpack.zlib

@@ -0,0 +1 @@
+eNrtVH1sE2UY35wgBkTQZQRh46xDCOzaXtu13SLMrWNStrqtnWgFxLd3b3u3tnfH3XWsQyCU8TGHzJsONyEat67VZsAWUIJjY3OQKUGMQY0DYtAwNChIwiYfAefbfcAW8A8T/UPj/fXe8/08v+f5BcIlUBAZjo1tYlgJCoCU0I9YHQgLcJUPilJ5yAslmqOCBfm2ogafwPTMpiWJF9NVKsAzSsBKtMDxDKkkOa+qhFB5oSgCFxSDDo7y9whrFF5QulLi3JAVFekYodboUjDFiBGSLFujEDgPRC+FT4SCAmlJDlXCSlERzTyOmed4MQfnUKxdEfXkKOiJakgP8FEQ1+I0YNw+XIMCq7Vqg2JtmIaAQj1VBWlOlOSWu6rcC0gS8hIOWZKjGNYl73aVMXwKRkGnB0gwgtKzcHAMcsQNIY8DD1MCQ0NecjPgeQ9DgqheVSxybNNwubjk5+Hd6ki0Kxw1y0rygcyROlQFfjRUFlMrtTqlprkUFyXAsB40FtwDUEkhflDfOlrBA9KN4uDDgMmhIec9o204UW60ADLfNiYkEEhabgSCV6/bN1ou+FiJ8UI5bCq4O92w8k46rZIglGktYwKLfpaUG53AI8KW20O+7RJBqGhxtR5XE3tGpuSBrEui5QaC0L0vQJFHywY3hlBIyScGgggRePzT8PB+1OfnjqC5LZiNsJHbimhfCqbRYzbIY1HMMUKbrjWkq3XYM5aiJtNwkqJ7QtFSJABWdCI4Fo1AHyZpH+uGVMR0T9Ajw0eAM5R8CL1Xqoms7FKryc35AWmhsrJ9VpeQWpZLfFiKkx7OR+ESuiCIDzZbKsk9mEanh4TekZZmBEadg9AYtUYCOgzQQekJvdqpayhhgBwhlATm4jiXB+415eAmQNIQtw2ORA5n25/NtJhNTS/gVs7BSSJeBFxykOVYGLJBAY1ajgymRssrwBByt2ba5f1GMk0LUg1OAwU0evTAFz1vbR4Zz+32g9HNH7zUDQgCAYmOXJ9VOSFm8IvLqyrM7Xp6SvnAsTRV+/LZlk0X2iYEvg3Ed04rTF4u5s4o69l9cIH7oeu/VkfOnuw4oN2XV/Vkx3uWnZHahbP6KtpfSjrdvOLzrv7uW103WN+4iQsuMVLhknWm5p+St3eEv0rub2qmZxeUmxLXTtbVWT5q7+k1299862hTbVd9wlLHpjUXBx6rWdj9i3lmQnxD7TL7u3WN78zpslhyju7PLt5erTqeNTn0m2fH+R/7F7+25HL3jElcghmu9J17Qz1zq6nxIHkz6ZE21w9vnzV203K+e3nV5qv2+TWJqwI7dyRU92fMqwTXxsfEDAzExXzWkv7N/NiYmL+H8k7Fjvs7OS8Fu2MLRJFBh4Ksxjoshh4Ph2VxDuQnzRExliEhJnGYF0IJ83M+JbaYW42RgMXM2FCMqBRZUMCfMTbFPcpZTYNoUK8fY4EXZvxPw/8pGtboiX8lDRN5Rrup0MHbeGgo03MOv4vKA0v/lIZ1iG6h1ml0Oim1AWgIrT5VnWZwUEa106iFqY5/loaNBGHUqP8SDfePpuHMKA1vGjimmaaaYT8ZaDactnXavty4tTx1emtudZ1Ou8ya9XtrcF5p2eXvriYdmm6NSypLe+4SyMi7mLu99VbfjV26I1d6r0mv3D+xLJFvLEjeNSVl25ndOVPM9RviU/rOvPxA0gXlufGVlqmmYrHwY+FnPbvig7p4c+fhL9ZXvnryVFvFFsOJnKzi4zVX6Ll9dHVt4voXn/Doxrc92jB1ff3Giu8D5yu7aw5v6e0KzH34662ZtR1xVhuT9OC6uE4xJzL1qd49+17nuJuTKjY31QiVyWcPnLjPdYurYe3tsUMU3Gf6ZFKUgv8AZIo4lA==

docs/cassettes/disable-streaming_4.msgpack.zlib

@@ -0,0 +1 @@
+eNqdVd1uG0UUpuKu99yvLKQCyti73vVfogglTtokbeI2TmhShKzx7rF3kt2ZzcysE7fKBYV7WMQL0KZOCSEtagWlUN6ABwgXPARPwFl7TRKlV/jC9sw5c36/75yHhz2Qigl+5ZhxDZK6Gg8qeXgoYScGpb8chKB94R3cbjTXHseSnX7kax2pyUKBRiwvIuCU5V0RFnpWwfWpLuD/KIChmYO28PqnyYNcCErRLqjcpPHpg5wr0BXXeMj5YtcIKe8b8poyqASDcUNpSXfbIGX/49yEkZMigFQ1ViBz+5/hTSg8CNIrYZFIQo/BbqrI8crCX3wPNMSDljHgWUMYYWY6lqkdK2/uH/pAPcz7qwNfKJ2cXMzkGXVdiDQB7gqP8W7yY/c+iyYMDzoB1XCE4XMY1ik52gaICA1YDwajV8lzGkUBc2kqL2wpwY+zdInuR3BZfJTmRbA4XCcvGxjEzGLhdh9LzjFUp5o3n+8RpSnjAdaQBBTjGURD+W/nBRF1t9EIydqZDEaPT87rCJU8WaZuo3nBJJWunzyhMiw7L87fy5hrFkJyWL992V0mPHNn5y0rX/vpgmHV527ypEMDBb9ceAxa9okr0EbynXkyrk8AvKv95LHllJ5KUBECCL4Y4DMdq4cH2Av488rXhxmUfpilnrE6wui4nX+/897BHHYoebPmxxNGsWw0ITKKZtExLHvSsSfxz43lteN65nDtrQ05GYtvZfEUneJR/a09f5P2HBNKM0CYEtiLhAKShZMcb5AsQrI492IEMCJkl3J2f+gv+T7tJ7KG8ZeZOJIiNYmwI6FKHlnmSSYYV/oI8zGJZRLT+hWRzlwElqQcyyU1UeAiRXU/OZ0I6V6KqmnbKtll0zSnkFpuEHvQjNtzIkSXaspA9gSCeq/3CPIDAhYybMPwO6O/Sg5K+PjVZQUttgEHxVPbHH3+OK8iIXWQJnFmx6nVar+/XWlsq1hLPxXn9UU1BefjsYqhenVZIbPxyFTHe2Ntwrzk9H08tNqWW6VQpHbJqZRqDq2US65XqtbaFVorta3qs/p1UqeuD6Q5xFtyOLe5MrO8WD9qou26ENsMvvnryrutlttptcNp+0Z1vnNrZqfUqvHNzfb8WnPzjr+05S3utMwdfXO3ZdsueH6/f1MQq1Ks2KVq0XQIDp+8lbdIJ1y4U/WkKfSit6Xu3tlYWVpRze31ap/NLc3FzUbTh3Z31Q/WW6ZTsXul+s7SRrvtFrf6Vr6xXF52Fjpabu3OrDjK32rszfNSp9jFflLtTxemDAQiw7JMZzwgyAOSssCZtMYsmDK8IQqm8xen35SxgPO9wYP+FNIH4QT4S0NoMg3TK4LD6bdYg7jHvOkbuzs9Z7k7e/NW99696536J0sLS+2QLVj5rfJe2Z4tbtP719c34V7PPVeEcsUiZlaHsulUh+g5C/1/RvXzBjlPa9KIRovskAvFWaczaIJECiVHbiBiDwe5hAH2fHVmM3lZdWs2BbcGnZptIk7I/N3V4er6fJAyjHdP/3lw1TByuJKExBWSHvCYTaJ0Ea1zFUcpA8EzejSIYdK4NlpD1zAhUAYX2shUhmvJ2GXaN7TPlDHcZnkjzQ0vIF0zNA608cFwcH44smeg4n8u8rmJUQTpRkndM45KzGtlsG+NAs2UIiqH23C8F7PrdJ4O1+pZ6K2hqxzK96/u/wtcP/+g

docs/cassettes/disable-streaming_8.msgpack.zlib

@@ -0,0 +1 @@
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

docs/cassettes/edit-graph-state_51923913-20f7-4ee1-b9ba-d01f5fb2869b.msgpack.zlib

@@ -0,0 +1 @@
+eNqNVX1QFOcZ5zNtJpJErE07hunbC8oY2eO+wxEnEc9INVAJR6UI9PLu7nvs5vZ2l9138Q6jo2Kbqi1xrTqTloQMnHeGAIKYSjVNtQY009iSSZuIdOwfTibTkeloYkmbOKXvLneAwtjeH3d77/t8/J7n93ue3Z1oRorKS2J6Dy9ipEAGkz+qvjuhoCYNqXhPPIwwJ7Gxyk3+6i5N4ceWcxjLaklREZR5KxQxp0gyz1gZKVzUbC8KI1WFjUiN0RIbvZIZ2GYJw0gASyEkqpYSYLc5XIXAkrIiJ3XbLIokIPJk0VSkWMgtIxEoIjaOVAQVhgNBSQGYQ2ArguRHAbwI1CAQpa2W7YVgNgBUVV7FBNOdUUgKjCJmPB9SMORFIfpdsKFAEMBd8RlNUYjP3Dx+KIL1ChQZXmUk0zAqaVZQjjAII0Agm46pOJpoNhBgYsqLLLnjVRKFuIWhcWE1kOGobMI1QZkFzJxIkhAgMQ0rEYbRbAuME16UNaOKbRZCjRI1LhcCvN6IaeHZVEAtYLOX01xIRRFX1eaIq7qiqcVlL64NBi3bG+7o33wC6u7CpiBVE+5qr6Wu3rIBF6hA1UQxOq9nhYDWsNE0QCNMJAYESQoBiZzxQeO4QEEAgjIU5kUe1GtssZMl38hWbK23NJjtSjYl8H+VZJSuBpCiSAqxDkJBRaTKBkN0EosEs2kCJAkoJ+WmVEkUEaYcRJY2j8OWSpcU5nwKWKQyCi8bVJpygkRDhGtVU4JJgdLWGaoCKsOhMDQZk8mUEO3xpuZnCZxtr4oVXmy0bDe4M2aPV5BRbl3StGGObiT6BcQQ5ZC6EhyCLJngl2OcpGJ9YN5MHocMg2RMIZGRWJJA721s4eVCwKKgADHqZowGmJrVu0MIyRQU+GYUn/bS+6EsCzxjSrfoBdKsniTtlIFl/nW3oSCKTLaI9VOlKRxFlVGyQkRgszpdVkd/hFLNGSQ7gBIggRSXzfszcy9kyIRIHCq5nvT4tHPfXBtJ1Y9WQGaT/46QBlX6UaiEPa7BueeKJmI+jPSEr3J+uuTlbDqn1W63egfuCKxGRUY/akpqYKbJMy7dREROyuahbPa+VJcEJDZiTu8q9jiPkdGRyWpFrXESEmvq7hhhBL1/MZFchp2bnk2xeTUtN7aOsKP/tprTCoHDA/xIBoZIgd1Z4vSU2LygrKK6x5dMU70gGQPVZATVICHkmRT5CYbTxBBiu30L0j5mmS1LIfkFPsxjKvkmIGQZf/WYy2azja24p6VCZE/GmWSMOb1e7/+ISzqDsH7SqI+yeSmHp3q6SrdryxhYyHP6dZLEEzfwEET597CcxZOyBve0XhiPzbulOwma4ln9bfJM9tAPlKjcFKxkWqo0ukIKlrLldt7R8laEYgRJYylM3qmIMgURwfoYQMUIeoM0Qztotwt63HQQsW7aRnsh7WKQw9nVzEO92261g0ZJahTQcd96ygfJIqH8pmz0xLra75dWbPD1/JCqkmiJ9K8akj6LkojifqQQOerdZmoy4AqKE/eq0lr9ZDHjdUKXnUaIhYzL6aWeqanqTwloRiAxYzuY7+5d8emNNJyx6jv7v55mfjKx/w/iMvui20vXPhL4aH1uQcWZU5MHPu19bzn3QOsRrihE/ebwsaFxMPUj7hcnV+5rz7phb/921UNtraGGjlNvtp5/8/ObX+U1dLx4e7QjMHX6TOR3q79a/dehkbHiyt7O9qZn+5o2MDnP/7E9Z7j+WkvONxquv/huLvdOe8f7g/sOXHr5wba2h67m5Q2NRJc+Zv94RzSS7v6ydjyR0Dps/rSl/W1gyYq/lXbWd35yn/Vc19kDt17LPHcse1LI6xdc/+R6MoY+ov2DRSv1b03c39uVVSi3ZjTeP6xOXtlx+Lgy/sGvss/+Ozu/7cD+i0M7x9uct/Yc3BU+kn6u7PdZ6RcKHHV/SfuiPXpJD2cdSvPlDyzG/ueUC2v3l9w+kTHhrv1a58iJ7Ouj/6l5sPCpI2vSK1//3nvZjz3/69hzpybsaztzluduypl4cjJPPvLKrp/7Ki4svq/cc+mJQztX3l78KjfKRtMfOZ3YtvGSa0fZtWV979zqfeOzV8vfeGr5vp9d/1dPyL/V+cDD0bLRkOViZvRq/0trfvLo56vWde14fc/mXPfo4dcyxy/vXHF5MOvG47tW7T09VbvTXfrSedvulYsOPV625oO9fx4MLas4fDajb6Pnp+zokol1X5xd4nz4l28/mn5+iWekpuZGTXP2l5/mf/MfN+uunfh7/8Y9tcNvteX39OQ3/Wlv+dMbG34cOvru5SHH9lcmzw0sGt4cf/LgxJVrH344wg98PHD+k89u3nyCqGJqKjNtNXh6y8HMtLT/AgDhCAg=

docs/cassettes/edit-graph-state_cfd140f0-a5a6-4697-8115-322242f197b5.msgpack.zlib

@@ -0,0 +1 @@
+eNqFVH1sE2UYXx2J8yMaQUQiCZcGdTG87V2vPdomGGo3iENg6+qAAeLbu7e9Y9e74+7t6LaMj4EJCUG4RYIE5MN1rTQFNmUZinwlKOiMgjFKiVkIC4ZERCUaVAR8r2sZhAX7T997n9/z/J7n+T3v05FpRrohqYotJykY6ZDH5MMwOzI6Wp5ABl6XjiMsqkKqdl59uCuhS/nnRYw1w+90Qk1yQAWLuqpJvINX485mxhlHhgFjyEhFVKHlvM3XZo/D5FKsNiHFsPsphna5p1L2EorcLGqz66qMyMmeMJBuJ1ZeJako2LoyENR5kYqqOoVFRK1AkPzplKRQRpRS1BX29iVWOFVAsgXnZZgQEGCBBxiqoiAMXISQ5ly0FRerqlykVGAcjcS3jAIyeF3SrPItQxDKMoVVykjo0SJ1xGHhJEVL4KUGL6I4JMA2u0bqRzqWCtW02UnX9JbCCbdowxxYl5SYvb2deFtdlXQkWFkUoVYBJagaWYZ4TKBL2jMiggLRZlNKVA1s9t7X7QOQ55GGAVJ4VSAE5r5Yq6RNpQQUlSFGWd5qQEFOM9uEkAagLDWj9LCX2QM1TZZ4aNmdy0izcsWuAyuX+81ZSxxANFOw2R8o5eGsbSHDoVC0g3U7XD1JYGAoKTJRF8iQpJTWCvbDdxs0yDeROKA4eGZ62Hn/3RjVMLvnQH5e/T0hLanMbqjHOfdHd9/rCQVLcWRmgrX30xWNI3Ssg2Ecvt57AhstCm92R6FsoN47Tb7jkiVDxAKaAzSzv9QlGSkxLJpdLMN+oCNDI48GrU2TkDhhdKSIIuir05nimL8/b3ZJzcGysakqoo55JCwmplIujqpHGmUNKcWwfpbz0xw1a044FyzShEcVozesQ8WIEkGqS+JneDGhNCEhGxxV9rx9pCyd8MtSXMKg+MaJWNanmXLTNJ1/4YFInYy9pFiMKdbn8/1PXNIZhM2DVn2A9gEXFx6u0uNuzFOjeQ4vimI+aSsfktGUByBH8imhqQeiR8+H5hqzxaSBJJifkvNSmqlq1jiIF7BJ7/yG6kCdUvt6Szwa7UsCXlYTAsBkWyJQGIgkNvOUG0bcLOt1RQWWRx7E+VhvRPC6BOjhXR4Pw3Q1S9DMMg6GiqlqTEYHgjNBEJJFAuoLY2NmqhbODcx5NZhbAEJqRCX9C0PSZ0VVULoe6WQczWyBmjxwHaWJeyiw0Dzo5X0sdDMMhNMivJv1ger5oZ7SAN0ZkJS1HQpbeU16eCN9Zps/eUNFWeFXvq7uRE154PGbW5gJzkX57xvwpprxvW9kK+wfvtafv3oun3pP6Om7cmwgt7712tPXOrde75x0HOxZ3dCAXt4x8Oc/nT8fbvUf6K9fMTToHHymYuLllWv3PlZ95SXbmvaHcuvH9aU2BwZm/1E741J88cULmJ5YMW7PEzP/Fnfs2qif3h0JTXnr4qXfpoeXb73cXnnh0bWNs1auEpRNR6Z1cOGNe33Pxs+EmTFTPL+KfSfenLTt4dk/+Rdkd4R/nHbVt/PdiVnpbNWJnX9NfzHU/fYXldvPn/1WHDrpzfoOcuPn7h5YmWNuuGoaDx0LfclvezK2IQoOPffNruahUzd+OZVM3lr8w2Zbnvv96MmxG7i6Pd7jXORcZujfocmfXPWU1w2+Y9tH30ycnTCm/6m9r1RWtu4KXFkVmnT0u5pLns4Zy/0fn17ddevzr2ctuf5IWdnt2+VlzPYz6Wu2srL/AMEX7ks=