Type safety w generics

- rm langchain_core dependency
- replace callbacks w run tree
- rm Runnable dependency
- rm non-state Graph
- rm managed values
- rm entrypoint/task/call
- rm async methods
- rm shallow checkpointer
- rm messages stream mode
- rm debug flag
- rm remote graph

.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,11 +21,9 @@ jobs:
           - "3.10"
           - "3.11"
           - "3.12"
-        core-version:
-          - ">=0.3.0.dev1,<0.4.0"
-          - "latest"
+          - "3.13"
 
-    name: "test #${{ matrix.python-version }} (langchain-core: ${{ matrix.core-version }})"
+    name: "test #${{ matrix.python-version }}"
     steps:
       - uses: actions/checkout@v4
       - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
@@ -33,19 +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
-          if [ "${{ matrix.core-version }}" != "latest" ]; then
-            poetry run pip install "langchain-core${{ matrix.core-version }}"
-          fi
 
-      - name: Run core tests
+      - name: Run tests
         shell: bash
         working-directory: ${{ inputs.working-directory }}
         run: |

.github/workflows/_test_langgraph.yml

@@ -0,0 +1,60 @@
+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"
+
+    defaults:
+      run:
+        working-directory: libs/langgraph
+    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-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
+
+      - name: Run tests
+        shell: bash
+        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,199 @@
 ---
-    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:
+  changes:
+    runs-on: ubuntu-latest
+    outputs:
+      python: ${{ steps.filter.outputs.python }}
+      sdk-js: ${{ steps.filter.outputs.sdk-js }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dorny/paths-filter@v3
+        id: filter
+        with:
+          filters: |
+            python:
+              - 'libs/langgraph/**'
+              - 'libs/sdk-py/**'
+              - 'libs/cli/**'
+              - 'libs/checkpoint/**'
+              - 'libs/checkpoint-sqlite/**'
+              - 'libs/checkpoint-postgres/**'
+              - 'libs/scheduler-kafka/**'
+              - 'libs/prebuilt/**'
+            sdk-js:
+              - 'libs/sdk-js/**'
+
+  lint:
+    needs: changes
+    name: cd ${{ matrix.working-directory }}
+    strategy:
+      matrix:
+        working-directory:
+          [
+            "libs/langgraph",
+            "libs/sdk-py",
+            "libs/cli",
+            "libs/checkpoint",
+            "libs/checkpoint-sqlite",
+            "libs/checkpoint-postgres",
+            "libs/scheduler-kafka",
+            "libs/prebuilt",
+          ]
+    if: needs.changes.outputs.python == 'true'
+    uses: ./.github/workflows/_lint.yml
+    with:
+      working-directory: ${{ matrix.working-directory }}
+    secrets: inherit
+
+  test:
+    needs: changes
+    name: cd ${{ matrix.working-directory }}
+    strategy:
+      matrix:
+        working-directory:
+          [
+            "libs/cli",
+            "libs/checkpoint",
+            "libs/checkpoint-sqlite",
+            "libs/checkpoint-postgres",
+            "libs/prebuilt",
+          ]
+    if: needs.changes.outputs.python == 'true'
+    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:
+    needs: changes
+    if: needs.changes.outputs.python == 'true'
+    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:
+    needs: changes
+    if: needs.changes.outputs.python == 'true'
+    name: "cd libs/scheduler-kafka"
+    uses: ./.github/workflows/_test_scheduler_kafka.yml
+    secrets: inherit
+
+  check-sdk-methods:
+    needs: changes
+    if: needs.changes.outputs.python == 'true'
+    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:
+    needs: changes
+    if: needs.changes.outputs.python == 'true'
+    name: CLI integration test
+    uses: ./.github/workflows/_integration_test.yml
+    secrets: inherit
+
+  lint-js:
+    needs: changes
+    if: needs.changes.outputs.sdk-js == 'true'
+    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:
+    needs: changes
+    if: needs.changes.outputs.sdk-js == 'true'
+    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

@@ -9,7 +9,11 @@
     
     permissions:
       contents: read
-    
+
+    defaults:
+      run:
+        working-directory: docs
+
     jobs:
       codespell:
         name: (Check for spelling errors)
@@ -21,18 +25,18 @@
     
           - name: Install Dependencies
             run: |
-              pip install toml codespell jupytext
+              pip install toml codespell==2.3.0 jupytext
     
           - name: Extract Ignore Words List
             run: |
               # Use a Python script to extract the ignore words list from pyproject.toml
-              python .github/workflows/extract_ignored_words_list.py
+              python ../.github/workflows/extract_ignored_words_list.py
             id: extract_ignore_words
     
           - name: Codespell
             uses: codespell-project/actions-codespell@v2
             with:
-              skip: '*.ambr,*.lock,*.ipynb'
+              skip: '*.ambr,*.lock,*.ipynb,*.yaml,*.zlib,*.md'
               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

@@ -21,9 +21,36 @@ concurrency:
   group: "pages"
   cancel-in-progress: false
 
+defaults:
+  run:
+    working-directory: docs
+
 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
+    timeout-minutes: 10 # Job will be cancelled if it runs for more than 10 minutes
+    env:
+      GITHUB_TOKEN: ${{ secrets.MKDOCS_GITHUB_TOKEN }}
     steps:
       - uses: actions/checkout@v4
         with:
@@ -36,21 +63,103 @@ jobs:
           poetry-version: ${{ env.POETRY_VERSION }}
           cache-key: docs
 
+      - name: Use Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: "22"
+          cache: "yarn"
+          cache-dependency-path: docs/yarn.lock
+
       - name: Install dependencies
         run: |
-          poetry install --with docs
+          yarn
+          poetry install --with test --with docs --no-root
+          poetry run pip install -U \
+            pytest \
+            pytest-check-links \
+            GitPython \
+            "git+https://github.com/benjamincburns/markdown-exec.git@cc0d39d737e5ffd4b83d23cd8729d7ea16e363c8"
 
+          # we run this installation only for internal PRs
+          # as GITHUB_TOKEN is not available for PRs from outside contributors
+          if [ -n "${GITHUB_TOKEN}" ]; then
+            poetry run pip install "git+https://${GITHUB_TOKEN}@github.com/langchain-ai/mkdocs-material-insiders.git"
+          fi
+
+          poetry run jupyter kernelspec list
+          poetry run python3 -m ipykernel install --user --name=python3
+          npm install -g tslab
+          poetry run tslab install --python=python3
+          poetry run jupyter kernelspec list
+
+      - name: Run unit tests
+        # Run unit tests on the docs build pipeline
+        run: make tests
+      - 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 llms-text
+        run: make llms-text
       - name: Build site
         run: make build-docs
         env:
           MKDOCS_GIT_COMMITTERS_APIKEY: ${{ secrets.MKDOCS_GIT_COMMITTERS_APIKEY }}
+          OPENAI_API_KEY: sf-proj-1234567890 # fake placeholder, shouldn't actually be used
+          ANTHROPIC_API_KEY: sk-ant-api03-1234567890 # fake placeholder, shouldn't actually be used
+      - 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://academy\.langchain\.com/.*" \
+              --check-links-ignore "https://x.com/.*" \
+              --check-links-ignore "https://twitter.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://www\.uber\.com/.*" \
+              --check-links-ignore "https://pepy\.tech/.*" \
+              --check-links $(find 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/|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 "https://academy\.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://twitter.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
 
       - name: Upload Pages Artifact
-        if: github.ref == 'refs/heads/main'
+        # if: github.ref == 'refs/heads/main'
         uses: actions/upload-pages-artifact@v3
         with:
           path: ./docs/site/
@@ -59,10 +168,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/extract_ignored_words_list.py

@@ -1,6 +1,6 @@
 import toml
 
-pyproject_toml = toml.load("libs/langgraph/pyproject.toml")
+pyproject_toml = toml.load("pyproject.toml")
 
 # Extract the ignore words list (adjust the key as per your TOML structure)
 ignore_words_list = (

.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
@@ -197,7 +195,11 @@ jobs:
               "$PKG_NAME==$VERSION" \
           )
 
-          if [[ "$PKG_NAME" == *checkpoint* ]]; then
+          if [[ "$PKG_NAME" == *prebuilt* ]]; then
+            poetry run pip install langgraph
+          fi
+
+          if [[ "$PKG_NAME" == *checkpoint* || "$PKG_NAME" == *prebuilt* ]]; then
             # since checkpoint packages are namespace packages, import them with . convention
             # i.e. import langgraph.checkpoint or langgraph.checkpoint.sqlite
             IMPORT_NAME="$(echo "$PKG_NAME" | sed s/-/./g)"
@@ -256,7 +258,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 +271,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 +299,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,82 @@
+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 * * *'
+
+defaults:
+  run:
+    working-directory: docs
+
+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 _scripts/download_tiktoken.py
+
+      - name: Prepare notebooks
+        run: |
+          if [ "${{ matrix.lib-version }}" = "development" ]; then
+            poetry run python _scripts/prepare_notebooks_for_ci.py --comment-install-cells
+          else
+            poetry run python _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"
+            ./_scripts/execute_notebooks.sh
+          else
+            CHANGED_FILES=$(echo '${{ inputs.changed-files }}' | tr ' ' '\n' | sed 's|^docs/docs/|docs/|' | grep '\.ipynb$' || true)
+            if [ -n "$CHANGED_FILES" ]; then
+              echo "Running changed notebooks: $CHANGED_FILES"
+              ./_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,6 @@ docs/docs_skeleton/yarn.lock
 Untitled*.ipynb
 
 Chinook.db
+
+.vercel
+.turbo

CLAUDE.md

@@ -0,0 +1,142 @@
+# LangGraph Coding Guide
+
+## Repository Structure
+
+LangGraph follows a monorepo organization, with the following structure:
+
+- `libs/langgraph` is the main Python library, published to pypi as `langgraph`. This contains the majority of the code for the framework, as well as the majority of the unit tests.
+- `libs/checkpoint` , published to pypi as `langgraph-checkpoint` contains the base classes for the persistence layer of langgraph. The two main abstractions are BaseCheckpointSaver (base class for persistence of workflow runs step-by-step) and BaseStore (base class for "long-term memory" operations, offering a key-value interface combined with semantic search over documents, used for persisting information across distinct workflow runs). This library is a dependency of both the main langgraph library, as well as implementations of these storage interfaces for specific databases. This library also contains reference implementations
+- `libs/checkpoint-postgres` published to pypi as langgraph-checkpoint-postgres, contains implementations of checkpoint and store backed by postgres. Majority of the test coverage is in `libs/langgraph` in the form of tests that run over all storage implementations in the repo.
+- `langgraph-java` contains a Java implementation of the langgraph framework, which is in the early stages of development.
+
+## Feature Overview
+
+langgraph is an orchestration framework (in the style of airflow or temporal) designed for LLM applications, with a focus on streaming output, cyclical and parallel workflows, and interrupt/resume capabilities. Applications built with langgraph are variously called workflows, graphs, cognitive architectures, agents. Key features:
+
+1. **Graph-based Architecture**: Build directed computation graphs with nodes and edges
+2. **State Management**: Type-safe state schema with custom reducers and transformations
+3. **Human-in-the-loop**: Support for interrupts, checkpoints, and tool call review
+4. **Persistence**: Save and resume execution with in-memory or database storage
+5. **Streaming**: Multiple modes (values, updates, custom) for real-time feedback
+6. **Multi-agent Patterns**: Support for network, supervisor, and hierarchical architectures
+
+## Python Development
+
+### Build/Test/Lint Commands
+
+(in the respective subdirectory)
+
+- Run all tests: `make test`
+- Run single test: `make test TEST=path/to/test_file.py::test_function`
+- Watch mode tests: `make test_watch`
+- Run tests in parallel: `make test_parallel`
+- Generate coverage report: `make coverage`
+- Format code: `make format`
+- Lint code: `make lint`
+- Check spelling: `make spell_check`
+- Fix spelling: `make spell_fix`
+- Build documentation: `make serve-docs` (from repo root)
+- Run benchmarks: `make benchmark` or `make benchmark-fast`
+
+### Code Style Guidelines
+
+- Follow [ruff](https://github.com/astral-sh/ruff) formatting/linting rules
+- Use [Google Python Style Guide](https://google.github.io/styleguide/pyguide.html) for docstrings
+- Enforce type annotations with mypy (`disallow_untyped_defs = True`)
+- Use double quotes for strings
+- Maximum line length of 88 characters
+- Follow imports sorting with `ruff`
+- All functions/classes must have proper docstrings with args/returns
+- Write comprehensive unit tests for new features
+- Keep backward compatibility
+- PR scope should be isolated (changes shouldn't affect multiple packages)
+- Use descriptive variable names following Python conventions
+- Error handling should use appropriate exception types and messaging
+
+## Java Development
+
+(in the `langgraph-java` subdirectory)
+
+### Build/Test/Lint Commands
+
+- Build the project: `./gradlew build`
+- Run tests: `./gradlew test`
+- Run a specific test: `./gradlew test --tests "com.langgraph.package.TestClass.testMethod"`
+- Check formatting: `./gradlew spotlessCheck`
+- Apply formatting: `./gradlew spotlessApply`
+- Run all checks: `./gradlew check`
+- Generate Javadoc: `./gradlew javadoc`
+
+### Code Style Guidelines
+
+- Follow standard Java code style (Google Java Style Guide)
+- Use 4 spaces for indentation
+- Maximum line length of 100 characters
+- All public methods/classes must have proper Javadoc with @param/@return tags
+- Use descriptive variable names following Java conventions (camelCase)
+- Exception handling should use appropriate exception types with descriptive messages
+- Favor composition over inheritance
+- Use the Builder pattern for complex object creation
+- Write comprehensive unit tests for new features
+
+### Python Compatibility Guidelines
+
+- When implementing features from the Python version:
+  - Maintain semantic equivalence with the Python implementation
+  - Preserve the same behavior for all public APIs
+  - Document any intentional differences in behavior with comments
+  - Pay special attention to collections handling (Python lists vs Java Lists)
+  - Ensure that iteration order and value handling match Python where relevant
+- Use the same test cases as the Python version when possible
+- Do not introduce Java-specific shortcuts that would break Python compatibility
+- Never add test-specific code to source files - tests should adapt to implementation, not vice versa
+
+### Implementation Mapping
+
+- Always consult and update the `PYTHON_JAVA_MAPPING.md` file when:
+  - Adding new Java files or classes
+  - Updating existing Java implementations
+  - Fixing test failures in Java
+  - Implementing Python features in Java
+- This mapping file documents:
+  - Where to find equivalent functionality in Python and Java
+  - Any intentional deviations between implementations
+  - Implementation status and compatibility notes
+- When tests fail, check if the Java implementation matches Python behavior:
+  - Fix the implementation to match Python semantics whenever possible
+  - Update tests only if the Python version also differs
+  - Never create special cases or workarounds in Java just to make tests pass
+  - Document any implementation differences clearly in the mapping file
+- For new features, implement the Python behavior first, then adapt to Java idioms
+
+### Backward Compatibility and API Design
+
+- LangGraph Java has not been released publicly, so there is no need to maintain backward compatibility
+- When renaming methods, members, or classes:
+  - Use the clearest, most intuitive names that match Python semantics
+  - Remove old/deprecated methods completely rather than marking them as deprecated
+  - Update all tests and documentation to use the new names
+  - Do not leave deprecated methods or tests for backward compatibility
+
+### API Design Principles
+
+- Prefer a single, clear way to accomplish each task rather than multiple convenience methods
+- Prefer builder patterns over static factory methods where appropriate
+- For collections, prefer methods that operate on collections rather than having both single-item and collection variants
+- Choose method names that clearly express their purpose and align with Java conventions
+- Maintain consistent naming patterns across similar components
+- Document the recommended usage pattern in JavaDoc
+
+### Project Structure
+
+- `langgraph-core`: Core functionality of the framework
+- `langgraph-checkpoint`: Persistence layer for checkpoints and state management
+- `langgraph-examples`: Example applications and usage patterns
+
+### Error Handling
+
+- Use runtime exceptions for unexpected errors
+- Use checked exceptions for recoverable errors
+- Provide clear error messages that include context about what went wrong
+- Validate inputs early to prevent cascading errors
+- Ensure all resources are properly closed even in error conditions

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,28 +0,0 @@
-.PHONY: build-docs serve-docs serve-clean-docs clean-docs codespell build-typedoc
-
-build-typedoc:
-	cd libs/sdk-js && yarn install --include-dev && yarn typedoc
-	cd libs/sdk-js && yarn --silent concat-md --decrease-title-levels --ignore=js_ts_sdk_ref.md --start-title-level-at 2 docs > ../../docs/docs/cloud/reference/sdk/js_ts_sdk_ref.md 2>/dev/null
-	#  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
-
-clean-docs:
-	find ./docs/docs -name "*.ipynb" -type f -delete
-	rm -rf docs/site
-
-codespell:
-	./docs/codespell_notebooks.sh .

README.md

@@ -8,22 +8,56 @@
 ⚡ 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
 
-[LangGraph](https://langchain-ai.github.io/langgraph/) is a library for building stateful, multi-actor applications with LLMs, used to create agent and multi-agent workflows. Compared to other LLM frameworks, it offers these core benefits: cycles, controllability, and persistence. LangGraph allows you to define flows that involve cycles, essential for most agentic architectures, differentiating it from DAG-based solutions. As a very low-level framework, it provides fine-grained control over both the flow and state of your application, crucial for creating reliable agents. Additionally, LangGraph includes built-in persistence, enabling advanced human-in-the-loop and memory features.
+[LangGraph](https://langchain-ai.github.io/langgraph/) is a library for building
+stateful, multi-actor applications with LLMs, used to create agent and multi-agent
+workflows. Check out an introductory tutorial [here](https://langchain-ai.github.io/langgraph/tutorials/introduction/).
+
 
 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.
 
-### Key Features
+### Why use LangGraph?
 
-- **Cycles and Branching**: Implement loops and conditionals in your apps.
-- **Persistence**: Automatically save state after each step in the graph. Pause and resume the graph execution at any point to support error recovery, human-in-the-loop workflows, time travel and more.
-- **Human-in-the-Loop**: Interrupt graph execution to approve or edit next action planned by the agent.
-- **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 powers [production-grade agents](https://www.langchain.com/built-with-langgraph), trusted by Linkedin, Uber, Klarna, GitLab, and many more. LangGraph provides fine-grained control over both the flow and state of your agent applications. It implements a central [persistence layer](https://langchain-ai.github.io/langgraph/concepts/persistence/), enabling features that are common to most agent architectures:
 
+- **Memory**: LangGraph persists arbitrary aspects of your application's state,
+supporting memory of conversations and other updates within and across user
+interactions;
+- **Human-in-the-loop**: Because state is checkpointed, execution can be interrupted
+and resumed, allowing for decisions, validation, and corrections at key stages via
+human input.
+
+Standardizing these components allows individuals and teams to focus on the behavior
+of their agent, instead of its supporting infrastructure.
+
+Through [LangGraph Platform](#langgraph-platform), LangGraph also provides tooling for
+the development, deployment, debugging, and monitoring of your applications.
+
+LangGraph integrates seamlessly with
+[LangChain](https://python.langchain.com/docs/introduction/) and
+[LangSmith](https://docs.smith.langchain.com/) (but does not require them).
+
+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).
+
+### LangGraph Platform
+
+[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), and [LangGraph Studio](https://langchain-ai.github.io/langgraph/concepts/langgraph_studio) (UI/debugger).
+
+See deployment options [here](https://langchain-ai.github.io/langgraph/concepts/deployment_options/)
+(includes a free tier).
+
+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
 
@@ -33,9 +67,7 @@ pip install -U langgraph
 
 ## Example
 
-One of the central concepts of LangGraph is state. Each graph execution creates a state that is passed between nodes in the graph as they execute, and each node updates this internal state with its return value after it executes. The way that the graph updates its internal state is defined by either the type of graph chosen or a custom function.
-
-Let's take a look at a simple example of an agent that can use a search tool.
+Let's build a tool-calling [ReAct-style](https://langchain-ai.github.io/langgraph/concepts/agentic_concepts/#react-implementation) agent that uses a search tool!
 
 ```shell
 pip install langchain-anthropic
@@ -52,10 +84,72 @@ export LANGSMITH_TRACING=true
 export LANGSMITH_API_KEY=lsv2_sk_...
 ```
 
-```python
-from typing import Annotated, Literal, TypedDict
+The simplest way to create a tool-calling agent in LangGraph is to use `create_react_agent`:
+
+<details open>
+  <summary>High-level implementation</summary>
+
+```python
+from langgraph.prebuilt import create_react_agent
+from langgraph.checkpoint.memory import MemorySaver
+from langchain_anthropic import ChatAnthropic
+from langchain_core.tools import tool
+
+# Define the tools for the agent to use
+@tool
+def search(query: str):
+    """Call to surf the web."""
+    # This is a placeholder, but don't tell the LLM that...
+    if "sf" in query.lower() or "san francisco" in query.lower():
+        return "It's 60 degrees and foggy."
+    return "It's 90 degrees and sunny."
+
+
+tools = [search]
+model = ChatAnthropic(model="claude-3-5-sonnet-latest", temperature=0)
+
+# Initialize memory to persist state between graph runs
+checkpointer = MemorySaver()
+
+app = create_react_agent(model, tools, checkpointer=checkpointer)
+
+# Use the agent
+final_state = app.invoke(
+    {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
+    config={"configurable": {"thread_id": 42}}
+)
+final_state["messages"][-1].content
+```
+```
+"Based on the search results, I can tell you that the current weather in San Francisco is:\n\nTemperature: 60 degrees Fahrenheit\nConditions: Foggy\n\nSan Francisco is known for its microclimates and frequent fog, especially during the summer months. The temperature of 60°F (about 15.5°C) is quite typical for the city, which tends to have mild temperatures year-round. The fog, often referred to as "Karl the Fog" by locals, is a characteristic feature of San Francisco\'s weather, particularly in the mornings and evenings.\n\nIs there anything else you\'d like to know about the weather in San Francisco or any other location?"
+```
+
+Now when we pass the same <code>"thread_id"</code>, the conversation context is retained via the saved state (i.e. stored list of messages)
+
+```python
+final_state = app.invoke(
+    {"messages": [{"role": "user", "content": "what about ny"}]},
+    config={"configurable": {"thread_id": 42}}
+)
+final_state["messages"][-1].content
+```
+
+```
+"Based on the search results, I can tell you that the current weather in New York City is:\n\nTemperature: 90 degrees Fahrenheit (approximately 32.2 degrees Celsius)\nConditions: Sunny\n\nThis weather is quite different from what we just saw in San Francisco. New York is experiencing much warmer temperatures right now. Here are a few points to note:\n\n1. The temperature of 90°F is quite hot, typical of summer weather in New York City.\n2. The sunny conditions suggest clear skies, which is great for outdoor activities but also means it might feel even hotter due to direct sunlight.\n3. This kind of weather in New York often comes with high humidity, which can make it feel even warmer than the actual temperature suggests.\n\nIt's interesting to see the stark contrast between San Francisco's mild, foggy weather and New York's hot, sunny conditions. This difference illustrates how varied weather can be across different parts of the United States, even on the same day.\n\nIs there anything else you'd like to know about the weather in New York or any other location?"
+```
+</details>
+
+> [!TIP]
+> LangGraph is a **low-level** framework that allows you to implement any custom agent
+architectures. Click on the low-level implementation below to see how to implement a
+tool-calling agent from scratch.
+
+<details>
+<summary>Low-level implementation</summary>
+
+```python
+from typing import Literal
 
-from langchain_core.messages import HumanMessage
 from langchain_anthropic import ChatAnthropic
 from langchain_core.tools import tool
 from langgraph.checkpoint.memory import MemorySaver
@@ -77,7 +171,7 @@ tools = [search]
 
 tool_node = ToolNode(tools)
 
-model = ChatAnthropic(model="claude-3-5-sonnet-20240620", temperature=0).bind_tools(tools)
+model = ChatAnthropic(model="claude-3-5-sonnet-latest", temperature=0).bind_tools(tools)
 
 # Define the function that determines whether to continue or not
 def should_continue(state: MessagesState) -> Literal["tools", END]:
@@ -131,100 +225,114 @@ checkpointer = MemorySaver()
 # Note that we're (optionally) passing the memory when compiling the graph
 app = workflow.compile(checkpointer=checkpointer)
 
-# Use the Runnable
+# Use the agent
 final_state = app.invoke(
-    {"messages": [HumanMessage(content="what is the weather in sf")]},
+    {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
     config={"configurable": {"thread_id": 42}}
 )
 final_state["messages"][-1].content
 ```
 
-```
-"Based on the search results, I can tell you that the current weather in San Francisco is:\n\nTemperature: 60 degrees Fahrenheit\nConditions: Foggy\n\nSan Francisco is known for its microclimates and frequent fog, especially during the summer months. The temperature of 60°F (about 15.5°C) is quite typical for the city, which tends to have mild temperatures year-round. The fog, often referred to as "Karl the Fog" by locals, is a characteristic feature of San Francisco\'s weather, particularly in the mornings and evenings.\n\nIs there anything else you\'d like to know about the weather in San Francisco or any other location?"
-```
+<b>Step-by-step Breakdown</b>:
 
-Now when we pass the same `"thread_id"`, the conversation context is retained via the saved state (i.e. stored list of messages)
+<details>
+<summary>Initialize the model and tools.</summary>
+<ul>
+  <li>
+    We use <code>ChatAnthropic</code> as our LLM. <strong>NOTE:</strong> we need to make sure the model knows that it has these tools available to call. We can do this by converting the LangChain tools into the format for OpenAI tool calling using the <code>.bind_tools()</code> method.
+  </li>
+  <li>
+    We define the tools we want to use - a search tool in our case. It is really easy to create your own tools - see documentation here on how to do that <a href="https://python.langchain.com/docs/how_to/custom_tools/">here</a>.
+  </li>
+</ul>
+</details>
 
-```python
-final_state = app.invoke(
-    {"messages": [HumanMessage(content="what about ny")]},
-    config={"configurable": {"thread_id": 42}}
-)
-final_state["messages"][-1].content
-```
+<details>
+<summary>Initialize graph with state.</summary>
 
-```
-"Based on the search results, I can tell you that the current weather in New York City is:\n\nTemperature: 90 degrees Fahrenheit (approximately 32.2 degrees Celsius)\nConditions: Sunny\n\nThis weather is quite different from what we just saw in San Francisco. New York is experiencing much warmer temperatures right now. Here are a few points to note:\n\n1. The temperature of 90°F is quite hot, typical of summer weather in New York City.\n2. The sunny conditions suggest clear skies, which is great for outdoor activities but also means it might feel even hotter due to direct sunlight.\n3. This kind of weather in New York often comes with high humidity, which can make it feel even warmer than the actual temperature suggests.\n\nIt's interesting to see the stark contrast between San Francisco's mild, foggy weather and New York's hot, sunny conditions. This difference illustrates how varied weather can be across different parts of the United States, even on the same day.\n\nIs there anything else you'd like to know about the weather in New York or any other location?"
-```
+<ul>
+    <li>We initialize graph (<code>StateGraph</code>) by passing state schema (in our case <code>MessagesState</code>)</li>
+    <li><code>MessagesState</code> is a prebuilt state schema that has one attribute -- a list of LangChain <code>Message</code> objects, as well as logic for merging the updates from each node into the state.</li>
+</ul>
+</details>
 
-### Step-by-step Breakdown
+<details>
+<summary>Define graph nodes.</summary>
 
-1. <details>
-    <summary>Initialize the model and tools.</summary>
+There are two main nodes we need:
 
-    - we use `ChatAnthropic` as our LLM. **NOTE:** we need make sure the model knows that it has these tools available to call. We can do this by converting the LangChain tools into the format for OpenAI tool calling using the `.bind_tools()` method.
-    - we define the tools we want to use - a search tool in our case. It is really easy to create your own tools - see documentation here on how to do that [here](https://python.langchain.com/docs/modules/agents/tools/custom_tools).
-   </details>
+<ul>
+    <li>The <code>agent</code> node: responsible for deciding what (if any) actions to take.</li>
+    <li>The <code>tools</code> node that invokes tools: if the agent decides to take an action, this node will then execute that action.</li>
+</ul>
+</details>
 
-2. <details>
-    <summary>Initialize graph with state.</summary>
+<details>
+<summary>Define entry point and graph edges.</summary>
 
-    - we initialize graph (`StateGraph`) by passing state schema (in our case `MessagesState`)
-    - `MessagesState` is a prebuilt state schema that has one attribute -- a list of LangChain `Message` objects, as well as logic for merging the updates from each node into the state
-   </details>
+First, we need to set the entry point for graph execution - <code>agent</code> node.
 
-3. <details>
-    <summary>Define graph nodes.</summary>
+Then we define one normal and one conditional edge. Conditional edge means that the destination depends on the contents of the graph's state (<code>MessagesState</code>). In our case, the destination is not known until the agent (LLM) decides.
 
-    There are two main nodes we need:
+<ul>
+  <li>Conditional edge: after the agent is called, we should either:
+    <ul>
+      <li>a. Run tools if the agent said to take an action, OR</li>
+      <li>b. Finish (respond to the user) if the agent did not ask to run tools</li>
+    </ul>
+  </li>
+  <li>Normal edge: after the tools are invoked, the graph should always return to the agent to decide what to do next</li>
+</ul>
+</details>
 
-      - The `agent` node: responsible for deciding what (if any) actions to take.
-      - The `tools` node that invokes tools: if the agent decides to take an action, this node will then execute that action.
-   </details>
+<details>
+<summary>Compile the graph.</summary>
 
-4. <details>
-    <summary>Define entry point and graph edges.</summary>
+<ul>
+  <li>
+    When we compile the graph, we turn it into a LangChain 
+    <a href="https://python.langchain.com/docs/concepts/runnables/">Runnable</a>, 
+    which automatically enables calling <code>.invoke()</code>, <code>.stream()</code> and <code>.batch()</code> 
+    with your inputs
+  </li>
+  <li>
+    We can also optionally pass checkpointer object for persisting state between graph runs, and enabling memory, 
+    human-in-the-loop workflows, time travel and more. In our case we use <code>MemorySaver</code> - 
+    a simple in-memory checkpointer
+  </li>
+</ul>
+</details>
 
-      First, we need to set the entry point for graph execution - `agent` node.
+<details>
+<summary>Execute the graph.</summary>
 
-      Then we define one normal and one conditional edge. Conditional edge means that the destination depends on the contents of the graph's state (`MessageState`). In our case, the destination is not known until the agent (LLM) decides.
-
-      - Conditional edge: after the agent is called, we should either:
-        - a. Run tools if the agent said to take an action, OR
-        - b. Finish (respond to the user) if the agent did not ask to run tools
-      - Normal edge: after the tools are invoked, the graph should always return to the agent to decide what to do next
-   </details>
-
-5. <details>
-    <summary>Compile the graph.</summary>
-
-    - When we compile the graph, we turn it into a LangChain [Runnable](https://python.langchain.com/v0.2/docs/concepts/#runnable-interface), which automatically enables calling `.invoke()`, `.stream()` and `.batch()` with your inputs
-    - We can also optionally pass checkpointer object for persisting state between graph runs, and enabling memory, human-in-the-loop workflows, time travel and more. In our case we use `MemorySaver` - a simple in-memory checkpointer
-    </details>
-
-6. <details>
-   <summary>Execute the graph.</summary>
-
-    1. LangGraph adds the input message to the internal state, then passes the state to the entrypoint node, `"agent"`.
-    2. The `"agent"` node executes, invoking the chat model.
-    3. The chat model returns an `AIMessage`. LangGraph adds this to the state.
-    4. Graph cycles the following steps until there are no more `tool_calls` on `AIMessage`:
-
-        - If `AIMessage` has `tool_calls`, `"tools"` node executes
-        - The `"agent"` node executes again and returns `AIMessage`
-
-    5. Execution progresses to the special `END` value and outputs the final state.
-    And as a result, we get a list of all our chat messages as output.
-   </details>
+<ol>
+  <li>LangGraph adds the input message to the internal state, then passes the state to the entrypoint node, <code>"agent"</code>.</li>
+  <li>The <code>"agent"</code> node executes, invoking the chat model.</li>
+  <li>The chat model returns an <code>AIMessage</code>. LangGraph adds this to the state.</li>
+  <li>Graph cycles the following steps until there are no more <code>tool_calls</code> on <code>AIMessage</code>:
+    <ul>
+      <li>If <code>AIMessage</code> has <code>tool_calls</code>, <code>"tools"</code> node executes</li>
+      <li>The <code>"agent"</code> node executes again and returns <code>AIMessage</code></li>
+    </ul>
+  </li>
+  <li>Execution progresses to the special <code>END</code> value and outputs the final state. And as a result, we get a list of all our chat messages as output.</li>
+</ol>
+</details>
 
+</details>
 
 ## Documentation
 
 * [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.
+
+## Resources
+
+* [Built with LangGraph](https://www.langchain.com/built-with-langgraph): Hear how industry leaders use LangGraph to ship powerful, production-ready AI applications.
 
 ## Contributing
 

docs/.gitignore

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

docs/_scripts/copy_notebooks.py

@@ -1,228 +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",
-        "subgraphs-manage-state.ipynb",
-        "subgraph-transform-state.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/codespell_notebooks.sh

@@ -1,13 +0,0 @@
-ERROR_FOUND=0
-for file in $(find $1 -name "*.ipynb"); do
-    OUTPUT=$(cat "$file" | jupytext --from ipynb --to py:percent | codespell -)
-    if [ -n "$OUTPUT" ]; then
-        echo "Errors found in $file"
-        echo "$OUTPUT"
-        ERROR_FOUND=1
-    fi
-done
-
-if [ "$ERROR_FOUND" -ne 0 ]; then
-    exit 1
-fi

docs/docs/cloud/concepts/api.md

@@ -1,203 +0,0 @@
-# API Concepts
-
-This page describes the high-level concepts of the LangGraph Cloud API. The conceptual guide of LangGraph (Python library) is [here](../../concepts/index.md).
-
-## Data Models
-
-The LangGraph Cloud API consists of a few core data models: [Assistants](#assistants), [Threads](#threads), [Runs](#runs), and [Cron Jobs](#cron-jobs).
-
-### Assistants
-
-An assistant is a configured instance of a [`CompiledGraph`][compiledgraph]. It abstracts the cognitive architecture of the graph and contains instance specific configuration and metadata. Multiple assistants can reference the same graph but can contain different configuration and metadata, which may differentiate the behavior of the assistants. An assistant (i.e. the graph) is invoked as part of a run.
-
-The LangGraph Cloud API provides several endpoints for creating and managing assistants. See the [API reference](../reference/api/api_ref.html#tag/assistantscreate) for more details.
-
-#### Configuring Assistants
-
-You can save custom assistants from the same graph to set different default prompts, models, and other configurations without changing a line of code in your graph. This allows you the ability to quickly test out different configurations without having to rewrite your graph every time, and also give users the flexibility to select different configurations when using your LangGraph application. See <a href="https://langchain-ai.github.io/langgraph/cloud/how-tos/cloud_examples/configuration_cloud/">this</a> how-to for information on how to configure a deployed graph. 
-
-### Threads
-
-A thread contains the accumulated state of a group of runs. If a run is executed on a thread, then the [state][state] of the underlying graph of the assistant will be persisted to the thread. A thread's current and historical state can be retrieved. To persist state, a thread must be created prior to executing a run.
-
-The state of a thread at a particular point in time is called a checkpoint.
-
-For more on threads and checkpoints, see this section of the [LangGraph conceptual guide](../../concepts/low_level.md#checkpointer).
-
-The LangGraph Cloud API provides several endpoints for creating and managing threads and thread state. See the [API reference](../reference/api/api_ref.html#tag/threadscreate) for more details.
-
-### Runs
-
-A run is an invocation of an assistant. Each run may have its own input, configuration, and metadata, which may affect execution and output of the underlying graph. A run can optionally be executed on a thread.
-
-The LangGraph Cloud API provides several endpoints for creating and managing runs. See the [API reference](../reference/api/api_ref.html#tag/runscreate) for more details.
-
-### Cron Jobs
-
-It's often useful to run graphs on some schedule. LangGraph Cloud supports cron jobs, which run on a user defined schedule. The user specifies a schedule, an assistant, and some input. After than, on the specified schedule LangGraph cloud will:
-
-- Create a new thread with the specified assistant
-- Send the specified input to that thread
-
-Note that this sends the same input to the thread every time. See the [how-to guide](../how-tos/cron_jobs.md) for creating cron jobs.
-
-The LangGraph Cloud API provides several endpoints for creating and managing cron jobs. See the [API reference](../reference/api/api_ref.html#tag/runscreate/POST/threads/{thread_id}/runs/crons) for more details.
-
-## Features
-
-The LangGraph Cloud API offers several features to support complex agent architectures.
-
-### Streaming
-
-Streaming is critical for making LLM applications feel responsive to end users. When creating a streaming run, the streaming mode determines what data is streamed back to the API client. The LangGraph Cloud API supports five streaming modes.
-
-- `values`: Stream the full state of the graph after each [super-step](https://langchain-ai.github.io/langgraph/concepts/low_level/#graphs) is executed. See the [how-to guide](../how-tos/stream_values.md) for streaming values.
-- `messages`: Stream complete messages (at the end of node execution) as well as tokens for any messages generated inside a node. This mode is primarily meant for powering chat applications. This is only an option if your graph contains a `messages` key. See the [how-to guide](../how-tos/stream_messages.md) for streaming messages.
-- `updates`: Streams updates to the state of the graph after each node is executed. See the [how-to guide](../how-tos/stream_updates.md) for streaming updates.
-- `events`: Stream all events (including the state of the graph) that occur during graph execution. See the [how-to guide](../how-tos/stream_events.md) for streaming events. This can be used to do token-by-token streaming for LLMs.
-- `debug`: Stream debug events throughout graph execution. See the [how-to guide](../how-tos/stream_debug.md) for streaming debug events.
-
-You can also specify multiple streaming modes at the same time. See the [how-to guide](../how-tos/stream_multiple.md) for configuring multiple streaming modes at the same time.
-
-See the [API reference](../reference/api/api_ref.html#tag/runscreate/POST/threads/{thread_id}/runs/stream) for how to create streaming runs.
-
-Streaming modes `values`, `updates`, and `debug` are very similar to modes available in the LangGraph library - for a deeper conceptual explanation of those, you can see the LangGraph library documentation [here](../../concepts/low_level.md#streaming).
-
-Streaming mode `events` is the same as using `.astream_events` in the LangGraph library - for a deeper conceptual explanation of this, you can see the LangGraph library documentation [here](../../concepts/low_level.md#streaming).
-
-#### `mode="messages"`
-Streaming mode `messages` is a new streaming mode, currently only available in the API. What does this mode enable?
-
-This mode is focused on streaming back messages. It currently assumes that you have a `messages` key in your graph that is a list of messages. Assuming we have a simple react agent deployed, what does this stream look like?
-
-All events emitted have two attributes:
-
-- `event`: This is the name of the event
-- `data`: This is data associated with the event
-
-Let's run it on a question that should trigger a tool call:
-
-```python
-thread = await client.threads.create()
-input = {"messages": [{"role": "user", "content": "what's the weather in sf?"}]}
-
-events = []
-async for event in client.runs.stream(
-    thread["thread_id"],
-    assistant_id="agent",  # This may need to change depending on the graph you deployed
-    input=input,
-    stream_mode="messages",
-):
-    print(event.event)
-```
-```shell
-metadata
-messages/complete
-messages/metadata
-messages/partial
-...
-messages/partial
-messages/complete
-messages/complete
-messages/metadata
-messages/partial
-...
-messages/partial
-messages/complete
-end
-```
-
-We first get some `metadata` - this is metadata about the run. 
-
-```python
-StreamPart(event='metadata', data={'run_id': '1ef657cf-ae55-6f65-97d4-f4ed1dbdabc6'})
-```
-
-We then get a `messages/complete` event - this a fully formed message getting emitted. In this case,
-this was the just the input message we sent in. 
-
-```python
-StreamPart(event='messages/complete', data=[{'content': 'hi!', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '833c09a3-bb19-46c9-81d9-1e5954ec5f92', 'example': False}])
-```
-
-We then get a `messages/metadata` - this is just letting us know that a new message is starting.
-
-```python
-StreamPart(event='messages/metadata', data={'run-985c0f14-9f43-40d4-a505-4637fc58e333': {'metadata': {'created_by': 'system', 'run_id': '1ef657de-7594-66df-8eb2-31518e4a1ee2', 'graph_id': 'agent', 'thread_id': 'c178eab5-e293-423c-8e7d-1d113ffe7cd9', 'model_name': 'openai', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 1, 'langgraph_node': 'agent', 'langgraph_triggers': ['start:agent'], 'langgraph_task_idx': 0, 'ls_provider': 'openai', 'ls_model_name': 'gpt-4o', 'ls_model_type': 'chat', 'ls_temperature': 0.0}}})
-```
-
-We then get a BUNCH of `messages/partial` events - these are the individual tokens from the LLM! In the case below, we can see the START of a tool call.
-
-```python
-StreamPart(event='messages/partial', data=[{'content': '', 'additional_kwargs': {'tool_calls': [{'index': 0, 'id': 'call_w8Hr8dHGuZCPgRfd5FqRBArs', 'function': {'arguments': '', 'name': 'tavily_search_results_json'}, 'type': 'function'}]}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-985c0f14-9f43-40d4-a505-4637fc58e333', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [{'name': 'tavily_search_results_json', 'args': '', 'id': 'call_w8Hr8dHGuZCPgRfd5FqRBArs', 'error': None}], 'usage_metadata': None}])
-```
-
-After that, we get a `messages/complete` event - this is the AIMessage finishing. It's now a complete tool call:
-
-```python
-StreamPart(event='messages/complete', data=[{'content': '', 'additional_kwargs': {'tool_calls': [{'index': 0, 'id': 'call_w8Hr8dHGuZCPgRfd5FqRBArs', 'function': {'arguments': '{"query":"current weather in San Francisco"}', 'name': 'tavily_search_results_json'}, 'type': 'function'}]}, 'response_metadata': {'finish_reason': 'tool_calls', 'model_name': 'gpt-4o-2024-05-13', 'system_fingerprint': 'fp_157b3831f5'}, 'type': 'ai', 'name': None, 'id': 'run-985c0f14-9f43-40d4-a505-4637fc58e333', 'example': False, 'tool_calls': [{'name': 'tavily_search_results_json', 'args': {'query': 'current weather in San Francisco'}, 'id': 'call_w8Hr8dHGuZCPgRfd5FqRBArs'}], 'invalid_tool_calls': [], 'usage_metadata': None}])
-```
-
-After that, we get ANOTHER `messages/complete` event. This is a tool message - our agent has called a tool, gotten a response, and now inserting it into the state in the form of a tool message.
-
-```python
-StreamPart(event='messages/complete', data=[{'content': '[{"url": "https://www.weatherapi.com/", "content": "{\'location\': {\'name\': \'San Francisco\', \'region\': \'California\', \'country\': \'United States of America\', \'lat\': 37.78, \'lon\': -122.42, \'tz_id\': \'America/Los_Angeles\', \'localtime_epoch\': 1724877689, \'localtime\': \'2024-08-28 13:41\'}, \'current\': {\'last_updated_epoch\': 1724877000, \'last_updated\': \'2024-08-28 13:30\', \'temp_c\': 23.3, \'temp_f\': 73.9, \'is_day\': 1, \'condition\': {\'text\': \'Partly cloudy\', \'icon\': \'//cdn.weatherapi.com/weather/64x64/day/116.png\', \'code\': 1003}, \'wind_mph\': 15.0, \'wind_kph\': 24.1, \'wind_degree\': 310, \'wind_dir\': \'NW\', \'pressure_mb\': 1014.0, \'pressure_in\': 29.93, \'precip_mm\': 0.0, \'precip_in\': 0.0, \'humidity\': 57, \'cloud\': 25, \'feelslike_c\': 25.0, \'feelslike_f\': 77.1, \'windchill_c\': 20.9, \'windchill_f\': 69.6, \'heatindex_c\': 23.3, \'heatindex_f\': 74.0, \'dewpoint_c\': 12.9, \'dewpoint_f\': 55.2, \'vis_km\': 16.0, \'vis_miles\': 9.0, \'uv\': 6.0, \'gust_mph\': 19.5, \'gust_kph\': 31.3}}"}]', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': 'tavily_search_results_json', 'id': '0112eba5-7660-4375-9f24-c7a1d6777b97', 'tool_call_id': 'call_w8Hr8dHGuZCPgRfd5FqRBArs'}])
-```
-
-After that, we see the agent doing another LLM call and streaming back a response. We then get an `end` event:
-
-```python
-StreamPart(event='end', data=None)
-```
-
-And that's it! This is more focused streaming mode specifically focused on streaming back messages. See this [how-to guide](../how-tos/stream_messages.md) for more information.
-
-
-### Human-in-the-Loop
-
-There are many occasions where the graph cannot run completely autonomously. For instance, the user might need to input some additional arguments to a function call, or select the next edge for the graph to continue on. In these instances, we need to insert some human in the loop interaction, which you can learn about in the [human in the loop how-tos](../how-tos/index.md#human-in-the-loop).
-
-### Double Texting
-
-Many times users might interact with your graph in unintended ways. For instance, a user may send one message and before the graph has finished running send a second message. To solve this issue of "double-texting" (i.e. prompting the graph a second time before the first run has finished), LangGraph has provided four different solutions, all of which are covered in the [Double Texting how-tos](../how-tos/index.md#double-texting). These options are:
-
-- `reject`: This is the simplest option, this just rejects any follow up runs and does not allow double texting. See the [how-to guide](../how-tos/reject_concurrent.md) for configuring the reject double text option.
-- `enqueue`: This is a relatively simple option which continues the first run until it completes the whole run, then sends the new input as a separate run. See the [how-to guide](../how-tos/enqueue_concurrent.md) for configuring the enqueue double text option.
-- `interrupt`: This option interrupts the current execution but saves all the work done up until that point. It then inserts the user input and continues from there. If you enable this option, your graph should be able to handle weird edge cases that may arise. See the [how-to guide](../how-tos/interrupt_concurrent.md) for configuring the interrupt double text option.
-- `rollback`: This option rolls back all work done up until that point. It then sends the user input in, basically as if it just followed the original run input. See the [how-to guide](../how-tos/rollback_concurrent.md) for configuring the rollback double text option.
-
-### Stateless Runs
-
-All runs use the built-in checkpointer to store checkpoints for runs. However, it can often be useful to just kick off a run without worrying about explicitly creating a thread and without wanting to keep those checkpointers around. Stateless runs allow you to do this by exposing an endpoint that:
-
-- Takes in user input
-- Under the hood, creates a thread
-- Runs the agent but skips all checkpointing steps
-- Cleans up the thread afterwards
-
-Stateless runs are still retried as regular retries are per node, while everything still in memory, so doesn't use checkpoints.
-
-The only difference is in stateless background runs, if the task worker dies halfway (not because the run itself failed, for some external reason) then the whole run will be retried like any background run, but
-
-- whereas a stateful background run would retry from the last successful checkpoint
-- a stateless background run would retry from the beginning
-
-See the [how-to guide](../how-tos/stateless_runs.md) for creating stateless runs.
-
-### Webhooks
-
-For all types of runs, langgraph cloud supports completion webhooks. When you create the run you can pass a webhook URL to be called when the completes (successfully or not). This is especially useful for background runs and cron jobs, as the webhook can give you an indication the run has completed and you can perform further actions for your appilcation.
-
-See this [how-to guide](../how-tos/webhooks.md) to learn about how to use webhooks with LangGraph Cloud.
-
-## Deployment
-
-The LangGraph Cloud offers several features to support secure and robost deployments.
-
-### Authentication
-
-LangGraph applications deployed to LangGraph Cloud are automatically configured with LangSmith authentication. In order to call the API, a valid <a href="https://docs.smith.langchain.com/how_to_guides/setup/create_account_api_key#api-keys" target="_blank">LangSmith API key</a> is required.
-
-### Local Testing
-
-Before deploying your app in production to LangGraph Cloud, you may wish to test out your graph locally in order to ensure that everything is running as expected. Luckily, LangGraph makes this easy for you through use of the LangGraph CLI. Read more in this [how-to guide](../deployment/test_locally.md) or look at the [CLI reference](../reference/cli.md) to learn more.

docs/docs/cloud/concepts/cloud.md

@@ -1,28 +0,0 @@
-# Cloud Concepts
-
-This page describes the high-level concepts of the LangGraph Cloud deployment.
-
-## Deployment
-
-A deployment is an instance of a LangGraph API. A single deployment can have many [revisions](#revision). When a deployment is created, all of the necessary infrastructure (e.g. database, containers, secrets store) are automatically provisioned. See the [architecture diagram](#architecture) below for more details.
-
-See the [how-to guide](../deployment/cloud.md#create-new-deployment) for creating a new deployment.
-
-## Revision
-
-A revision is an iteration of a [deployment](#deployment). When a new deployment is created, an initial revision is automatically created. To deploy new code changes or update environment variable configurations for a deployment, a new revision must be created. When a revision is created, a new container image is built automatically.
-
-See the [how-to guide](../deployment/cloud.md#create-new-revision) for creating a new revision.
-
-## Asynchronous Deployment
-
-Infrastructure for [deployments](#deployment) and [revisions](#revision) are provisioned and deployed asynchronously. They are not deployed immediately after submission. Currently, deployment can take up to several minutes.
-
-## Architecture
-
-!!! warning "Subject to Change"
-    The LangGraph Cloud deployment architecture may change in the future.
-
-A high-level diagram of a LangGraph Cloud deployment.
-
-![diagram](langgraph_cloud_architecture.png)

docs/docs/cloud/deployment/cloud.md

@@ -1,78 +0,0 @@
-# How to Deploy to LangGraph Cloud
-
-LangGraph Cloud is available within <a href="https://www.langchain.com/langsmith" target="_blank">LangSmith</a>. To deploy a LangGraph Cloud API, navigate to the <a href="https://smith.langchain.com/" target="_blank">LangSmith UI</a>.
-
-## Prerequisites
-
-1. LangGraph Cloud applications are deployed from GitHub repositories. Configure and upload a LangGraph Cloud application to a GitHub repository in order to deploy it to LangGraph Cloud.
-1. [Verify that the LangGraph API runs locally](test_locally.md). If the API does not build and run successfully (i.e. `langgraph up`), deploying to LangGraph Cloud will fail as well.
-
-## Create New Deployment
-
-Starting from the <a href="https://smith.langchain.com/" target="_blank">LangSmith UI</a>...
-
-1. In the left-hand navigation panel, select `Deployments`. The `Deployments` view contains a list of existing LangGraph Cloud deployments.
-1. In the top-right corner, select `+ New Deployment` to create a new deployment.
-1. In the `Create New Deployment` panel, fill out the required fields.
-    1. `Deployment details`
-        1. Select `Import from GitHub` and follow the GitHub OAuth workflow to install and authorize LangChain's `hosted-langserve` GitHub app to  access the selected repositories. After installation is complete, return to the `Create New Deployment` panel and select the GitHub repository to deploy from the dropdown menu.
-        1. Specify a name for the deployment.
-        1. Specify the full path to the [LangGraph API config file](../reference/cli.md#configuration-file) including the file name. For example, if the file `langgraph.json` is in the root of the repository, simply specify `langgraph.json`.
-        1. Specify the desired `git` reference (e.g. branch name). For example, different branches of the repository can be deployed.
-    1. Select the desired `Deployment Type`.
-        1. `Development` deployments are meant for non-production use cases and are provisioned with minimal resources.
-        1. `Production` deployments can serve up to 500 requests/second and are provisioned with highly available storage with automatic backups.
-    1. Specify `Environment Variables` and secrets. See the [Environment Variables reference](../reference/env_var.md) to configure additional variables for the deployment.
-        1. Sensitive values such as API keys (e.g. `OPENAI_API_KEY`) should be specified as secrets.
-        1. Additional non-secret environment variables can be specified as well.
-    1. A new LangSmith `Tracing Project` is automatically created with the same name as the deployment.
-1. In the top-right corner, select `Submit`. After a few seconds, the `Deployment` view appears and the new deployment will be queued for provisioning.
-
-## Create New Revision
-
-When [creating a new deployment](#create-new-deployment), a new revision is created by default. Subsequent revisions can be created to deploy new code changes.
-
-Starting from the <a href="https://smith.langchain.com/" target="_blank">LangSmith UI</a>...
-
-1. In the left-hand navigation panel, select `Deployments`. The `Deployments` view contains a list of existing LangGraph Cloud deployments.
-1. Select an existing deployment to create a new revision for.
-1. In the `Deployment` view, in the top-right corner, select `+ New Revision`.
-1. In the `New Revision` modal, fill out the required fields.
-    1. Specify the full path to the [LangGraph API config file](../reference/cli.md#configuration-file) including the file name. For example, if the file `langgraph.json` is in the root of the repository, simply specify `langgraph.json`.
-    1. Specify the desired `git` reference (e.g. branch name). For example, different branches of the repository can be deployed.
-    1. Specify `Environment Variables` and secrets. Existing secrets and environment variables are prepopulated. See the [Environment Variables reference](../reference/env_var.md) to configure additional variables for the revision.
-        1. Add new secrets or environment variables.
-        1. Remove existing secrets or environment variables.
-        1. Update the value of existing secrets or environment variables.
-1. Select `Submit`. After a few seconds, the `New Revision` modal will close and the new revision will be queued for deployment.
-
-## View Build and Deployment Logs
-
-Build and deployment logs are available for each revision.
-
-Starting from the `Deployment` view...
-
-1. Select the desired revision from the `Revisions` table. A panel slides open from the right-hand side and the `Build` tab is selected by default, which displays build logs for the revision.
-1. In the panel, select the `Deploy` tab to view deployment logs for the revision.
-1. Within the `Deploy` tab, adjust the date/time range picker as needed. By default, the date/time range picker is set to the `Last 15 minutes`.
-
-## Interrupt Revision
-
-Interrupting a revision will stop deployment of the revision.
-
-!!! warning "Undefined Behavior"
-    Interrupted revisions have undefined behavior. This is only useful if you need to deploy a new revision and you already have a revision "stuck" in progress. In the future, this feature may be removed.
-
-Starting from the `Deployment` view...
-
-1. Select the menu icon (three dots) on the right-hand side of the row for the desired revision from the `Revisions` table.
-1. Select `Interrupt` from the menu.
-1. A modal will appear. Review the confirmation message. Select `Interrupt revision`.
-
-## Delete Deployment
-
-Starting from the <a href="https://smith.langchain.com/" target="_blank">LangSmith UI</a>...
-
-1. In the left-hand navigation panel, select `Deployments`. The `Deployments` view contains a list of existing LangGraph Cloud deployments.
-1. Select the menu icon (three dots) on the right-hand side of the row for the desired deployment and select `Delete`.
-1. A `Confirmation` modal will appear. Select `Delete`.

docs/docs/cloud/deployment/graph_rebuild.md

@@ -1,146 +0,0 @@
-# Rebuild Graph at Runtime
-
-You might need to rebuild your graph with a different configuration for a new run. For example, you might need to use a different graph state or graph structure depending on the config. This guide shows how you can do this.
-
-!!! note "Note"
-    In most cases, customizing behavior based on the config should be handled by a single graph where each node can read a config and change its behavior based on it
-
-## Prerequisites
-
-Make sure to check out [this how-to guide](./setup.md) on setting up your app for deployment first.
-
-## Define graphs
-
-Let's say you have an app with a simple graph that calls an LLM and returns the response to the user. The app file directory looks like the following:
-
-```
-my-app/
-|-- requirements.txt
-|-- .env
-|-- openai_agent.py     # code for your graph
-```
-
-where the graph is defined in `openai_agent.py`. 
-
-### No rebuild
-
-In the standard LangGraph API configuration, the server uses the compiled graph instance that's defined at the top level of `openai_agent.py`, which looks like the following:
-
-```python
-from langchain_openai import ChatOpenAI
-from langgraph.graph import END, START, MessageGraph
-
-model = ChatOpenAI(temperature=0)
-
-graph_workflow = MessageGraph()
-
-graph_workflow.add_node("agent", model)
-graph_workflow.add_edge("agent", END)
-graph_workflow.add_edge(START, "agent")
-
-agent = graph_workflow.compile()
-```
-
-To make the server aware of your graph, you need to specify a path to the variable that contains the `CompiledStateGraph` instance in your LangGraph API configuration (`langgraph.json`), e.g.:
-
-```
-{
-    "dependencies": ["."],
-    "graphs": {
-        "openai_agent": "./openai_agent.py:agent",
-    },
-    "env": "./.env"
-}
-```
-
-### Rebuild
-
-To make your graph rebuild on each new run with custom configuration, you need to rewrite `openai_agent.py` to instead provide a _function_ that takes a config and returns a graph (or compiled graph) instance. Let's say we want to return our existing graph for user ID '1', and a tool-calling agent for other users. We can modify `openai_agent.py` as follows:
-
-```python
-from typing import Annotated, TypedDict
-from langchain_openai import ChatOpenAI
-from langgraph.graph import END, START, MessageGraph
-from langgraph.graph.state import StateGraph
-from langgraph.graph.message import add_messages
-from langgraph.prebuilt import ToolNode
-from langchain_core.tools import tool
-from langchain_core.messages import BaseMessage
-from langchain_core.runnables import RunnableConfig
-
-
-class State(TypedDict):
-    messages: Annotated[list[BaseMessage], add_messages]
-
-
-model = ChatOpenAI(temperature=0)
-
-def make_default_graph():
-    """Make a simple LLM agent"""
-    graph_workflow = StateGraph(State)
-    def call_model(state):
-        return {"messages": [model.invoke(state["messages"])]}
-
-    graph_workflow.add_node("agent", call_model)
-    graph_workflow.add_edge("agent", END)
-    graph_workflow.add_edge(START, "agent")
-
-    agent = graph_workflow.compile()
-    return agent
-
-
-def make_alternative_graph():
-    """Make a tool-calling agent"""
-
-    @tool
-    def add(a: float, b: float):
-        """Adds two numbers."""
-        return a + b
-
-    tool_node = ToolNode([add])
-    model_with_tools = model.bind_tools([add])
-    def call_model(state):
-        return {"messages": [model_with_tools.invoke(state["messages"])]}
-
-    def should_continue(state: State):
-        if state["messages"][-1].tool_calls:
-            return "tools"
-        else:
-            return END
-
-    graph_workflow = StateGraph(State)
-
-    graph_workflow.add_node("agent", call_model)
-    graph_workflow.add_node("tools", tool_node)
-    graph_workflow.add_edge("tools", "agent")
-    graph_workflow.add_edge(START, "agent")
-    graph_workflow.add_conditional_edges("agent", should_continue)
-
-    agent = graph_workflow.compile()
-    return agent
-
-
-# this is the graph making function that will decide which graph to
-# build based on the provided config
-def make_graph(config: RunnableConfig):
-    user_id = config.get("configurable", {}).get("user_id")
-    # route to different graph state / structure based on the user ID
-    if user_id == "1":
-        return make_default_graph()
-    else:
-        return make_alternative_graph()
-```
-
-Finally, you need to specify the path to your graph-making function (`make_graph`) in `langgraph.json`:
-
-```
-{
-    "dependencies": ["."],
-    "graphs": {
-        "openai_agent": "./openai_agent.py:make_graph",
-    },
-    "env": "./.env"
-}
-```
-
-See more info on LangGraph API configuration file [here](../reference/cli.md#configuration-file)

docs/docs/cloud/deployment/setup.md

@@ -1,190 +0,0 @@
-# How to Set Up a LangGraph Application for Deployment
-
-A LangGraph application must be configured with a [LangGraph API configuration file](../reference/cli.md#configuration-file) in order to be deployed to LangGraph Cloud (or to be self-hosted). This how-to guide discusses the basic steps to setup a LangGraph application for deployment using `requirements.txt` to specify project dependencies.
-
-This walkthrough is based on [this repository](https://github.com/langchain-ai/langgraph-example), which you can play around with to learn more about how to setup your LangGraph application for deployment.
-
-!!! tip "Setup with pyproject.toml"
-If you prefer using poetry for dependency management, check out [this how-to guide](./setup_pyproject.md) on using `pyproject.toml` for LangGraph Cloud.
-
-!!! tip "Setup with a Monorepo"
-If you are interested in deploying a graph located inside a monorepo, take a look at [this](https://github.com/langchain-ai/langgraph-example-monorepo) repository for an example of how to do so.
-
-The final repo structure will look something like this:
-
-```bash
-my-app/
-├── my_agent # all project code lies within here
-│   ├── utils # utilities for your graph
-│   │   ├── __init__.py
-│   │   ├── tools.py # tools for your graph
-│   │   ├── nodes.py # node functions for you graph
-│   │   └── state.py # state definition of your graph
-│   ├── requirements.txt # package dependencies
-│   ├── __init__.py
-│   └── agent.py # code for constructing your graph
-├── .env # environment variables
-└── langgraph.json # configuration file for LangGraph
-```
-
-After each step, an example file directory is provided to demonstrate how code can be organized.
-
-## Specify Dependencies
-
-Dependencies can optionally be specified in one of the following files: `pyproject.toml`, `setup.py`, or `requirements.txt`. If none of these files is created, then dependencies can be specified later in the [LangGraph API configuration file](#create-langgraph-api-config).
-
-The dependencies below will be included in the image, you can also use them in your code, as long as with a compatible version range:
-
-```
-langgraph>=0.2.7,<0.3.0
-langgraph-checkpoint>=1.0.4
-langchain-core>=0.2.27,<0.3.0
-langsmith>=0.1.63
-orjson>=3.9.7
-httpx>=0.25.0
-tenacity>=8.0.0
-uvicorn>=0.26.0
-sse-starlette>=2.1.0
-uvloop>=0.18.0
-httptools>=0.5.0
-jsonschema-rs>=0.16.3
-croniter>=1.0.1
-structlog>=23.1.0
-redis>=5.0.0,<6.0.0
-```
-
-Example `requirements.txt` file:
-
-```
-langgraph
-langchain_anthropic
-tavily-python
-langchain_community
-langchain_openai
-
-```
-
-Example file directory:
-
-```bash
-my-app/
-├── my_agent # all project code lies within here
-│   └── requirements.txt # package dependencies
-```
-
-## Specify Environment Variables
-
-Environment variables can optionally be specified in a file (e.g. `.env`). See the [Environment Variables reference](../reference/env_var.md) to configure additional variables for a deployment.
-
-Example `.env` file:
-
-```
-MY_ENV_VAR_1=foo
-MY_ENV_VAR_2=bar
-OPENAI_API_KEY=key
-```
-
-Example file directory:
-
-```bash
-my-app/
-├── my_agent # all project code lies within here
-│   └── requirements.txt # package dependencies
-└── .env # environment variables
-```
-
-## Define Graphs
-
-Implement your graphs! Graphs can be defined in a single file or multiple files. Make note of the variable names of each [CompiledGraph][compiledgraph] to be included in the LangGraph application. The variable names will be used later when creating the [LangGraph API configuration file](../reference/cli.md#configuration-file).
-
-Example `agent.py` file, which shows how to import from other modules you define (code for the modules is not shown here, please see [this repo](https://github.com/langchain-ai/langgraph-example) to see their implementation):
-
-```python
-# my_agent/agent.py
-from typing import TypedDict, Literal
-
-from langgraph.graph import StateGraph, END, START
-from my_agent.utils.nodes import call_model, should_continue, tool_node # import nodes
-from my_agent.utils.state import AgentState # import state
-
-# Define the config
-class GraphConfig(TypedDict):
-    model_name: Literal["anthropic", "openai"]
-
-workflow = StateGraph(AgentState, config_schema=GraphConfig)
-workflow.add_node("agent", call_model)
-workflow.add_node("action", tool_node)
-workflow.add_edge(START, "agent")
-workflow.add_conditional_edges(
-    "agent",
-    should_continue,
-    {
-        "continue": "action",
-        "end": END,
-    },
-)
-workflow.add_edge("action", "agent")
-
-graph = workflow.compile()
-```
-
-!!! warning "Assign `CompiledGraph` to Variable"
-The build process for LangGraph Cloud requires that the `CompiledGraph` object be assigned to a variable at the top-level of a Python module (alternatively, you can provide [a function that creates a graph](./graph_rebuild.md)).
-
-Example file directory:
-
-```bash
-my-app/
-├── my_agent # all project code lies within here
-│   ├── utils # utilities for your graph
-│   │   ├── __init__.py
-│   │   ├── tools.py # tools for your graph
-│   │   ├── nodes.py # node functions for you graph
-│   │   └── state.py # state definition of your graph
-│   ├── requirements.txt # package dependencies
-│   ├── __init__.py
-│   └── agent.py # code for constructing your graph
-└── .env # environment variables
-```
-
-## Create LangGraph API Config
-
-Create a [LangGraph API configuration file](../reference/cli.md#configuration-file) called `langgraph.json`. See the [LangGraph CLI reference](../reference/cli.md#configuration-file) for detailed explanations of each key in the JSON object of the configuration file.
-
-Example `langgraph.json` file:
-
-```json
-{
-  "dependencies": ["./my_agent"],
-  "graphs": {
-    "agent": "./my_agent/agent.py:graph"
-  },
-  "env": ".env"
-}
-```
-
-Note that the variable name of the `CompiledGraph` appears at the end of the value of each subkey in the top-level `graphs` key (i.e. `:<variable_name>`).
-
-!!! warning "Configuration Location"
-The LangGraph API configuration file must be placed in a directory that is at the same level or higher than the Python files that contain compiled graphs and associated dependencies.
-
-Example file directory:
-
-```bash
-my-app/
-├── my_agent # all project code lies within here
-│   ├── utils # utilities for your graph
-│   │   ├── __init__.py
-│   │   ├── tools.py # tools for your graph
-│   │   ├── nodes.py # node functions for you graph
-│   │   └── state.py # state definition of your graph
-│   ├── requirements.txt # package dependencies
-│   ├── __init__.py
-│   └── agent.py # code for constructing your graph
-├── .env # environment variables
-└── langgraph.json # configuration file for LangGraph
-```
-
-## Next
-
-After you setup your project and place it in a github repo, it's time to [deploy your app](./cloud.md).

docs/docs/cloud/deployment/setup_javascript.md

@@ -1,200 +0,0 @@
-# How to Set Up a LangGraph.js Application for Deployment
-
-A [LangGraph.js](https://langchain-ai.github.io/langgraphjs/) application must be configured with a [LangGraph API configuration file](../reference/cli.md#configuration-file) in order to be deployed to LangGraph Cloud (or to be self-hosted). This how-to guide discusses the basic steps to setup a LangGraph.js application for deployment using `package.json` to specify project dependencies.
-
-This walkthrough is based on [this repository](https://github.com/langchain-ai/langgraphjs-studio-starter), which you can play around with to learn more about how to setup your LangGraph application for deployment.
-
-The final repo structure will look something like this:
-
-```bash
-my-app/
-├── src # all project code lies within here
-│   ├── utils # optional utilities for your graph
-│   │   ├── tools.ts # tools for your graph
-│   │   ├── nodes.ts # node functions for you graph
-│   │   └── state.ts # state definition of your graph
-│   └── agent.ts # code for constructing your graph
-├── package.json # package dependencies
-├── .env # environment variables
-└── langgraph.json # configuration file for LangGraph
-```
-
-After each step, an example file directory is provided to demonstrate how code can be organized.
-
-## Specify Dependencies
-
-Dependencies can be specified in a `package.json`. If none of these files is created, then dependencies can be specified later in the [LangGraph API configuration file](#create-langgraph-api-config).
-
-Example `package.json` file:
-
-```json
-{
-  "name": "langgraphjs-studio-starter",
-  "packageManager": "yarn@1.22.22",
-  "dependencies": {
-    "@langchain/community": "^0.2.31",
-    "@langchain/core": "^0.2.31",
-    "@langchain/langgraph": "^0.2.0",
-    "@langchain/openai": "^0.2.8"
-  }
-}
-```
-
-Example file directory:
-
-```bash
-my-app/
-└── package.json # package dependencies
-```
-
-## Specify Environment Variables
-
-Environment variables can optionally be specified in a file (e.g. `.env`). See the [Environment Variables reference](../reference/env_var.md) to configure additional variables for a deployment.
-
-Example `.env` file:
-
-```
-MY_ENV_VAR_1=foo
-MY_ENV_VAR_2=bar
-OPENAI_API_KEY=key
-TAVILY_API_KEY=key_2
-```
-
-Example file directory:
-
-```bash
-my-app/
-├── package.json
-└── .env # environment variables
-```
-
-## Define Graphs
-
-Implement your graphs! Graphs can be defined in a single file or multiple files. Make note of the variable names of each compiled graph to be included in the LangGraph application. The variable names will be used later when creating the [LangGraph API configuration file](../reference/cli.md#configuration-file).
-
-Here is an example `agent.ts`:
-
-```ts
-import type { AIMessage } from "@langchain/core/messages";
-import { TavilySearchResults } from "@langchain/community/tools/tavily_search";
-import { ChatOpenAI } from "@langchain/openai";
-
-import { MessagesAnnotation, StateGraph } from "@langchain/langgraph";
-import { ToolNode } from "@langchain/langgraph/prebuilt";
-
-const tools = [
-  new TavilySearchResults({ maxResults: 3, }),
-];
-
-// Define the function that calls the model
-async function callModel(
-  state: typeof MessagesAnnotation.State,
-) {
-  /**
-   * Call the LLM powering our agent.
-   * Feel free to customize the prompt, model, and other logic!
-   */
-  const model = new ChatOpenAI({
-    model: "gpt-4o",
-  }).bindTools(tools);
-
-  const response = await model.invoke([
-    {
-      role: "system",
-      content: `You are a helpful assistant. The current date is ${new Date().getTime()}.`
-    },
-    ...state.messages
-  ]);
-
-  // MessagesAnnotation supports returning a single message or array of messages
-  return { messages: response };
-}
-
-// Define the function that determines whether to continue or not
-function routeModelOutput(state: typeof MessagesAnnotation.State) {
-  const messages = state.messages;
-  const lastMessage: AIMessage = messages[messages.length - 1];
-  // If the LLM is invoking tools, route there.
-  if ((lastMessage?.tool_calls?.length ?? 0) > 0) {
-    return "tools";
-  }
-  // Otherwise end the graph.
-  return "__end__";
-}
-
-// Define a new graph.
-// See https://langchain-ai.github.io/langgraphjs/how-tos/define-state/#getting-started for
-// more on defining custom graph states.
-const workflow = new StateGraph(MessagesAnnotation)
-  // Define the two nodes we will cycle between
-  .addNode("callModel", callModel)
-  .addNode("tools", new ToolNode(tools))
-  // Set the entrypoint as `callModel`
-  // This means that this node is the first one called
-  .addEdge("__start__", "callModel")
-  .addConditionalEdges(
-    // First, we define the edges' source node. We use `callModel`.
-    // This means these are the edges taken after the `callModel` node is called.
-    "callModel",
-    // Next, we pass in the function that will determine the sink node(s), which
-    // will be called after the source node is called.
-    routeModelOutput,
-    // List of the possible destinations the conditional edge can route to.
-    // Required for conditional edges to properly render the graph in Studio
-    [
-      "tools",
-      "__end__"
-    ],
-  )
-  // This means that after `tools` is called, `callModel` node is called next.
-  .addEdge("tools", "callModel");
-
-// Finally, we compile it!
-// This compiles it into a graph you can invoke and deploy.
-export const graph = workflow.compile();
-```
-
-!!! info "Assign `CompiledGraph` to Variable"
-    The build process for LangGraph Cloud requires that the `CompiledGraph` object be assigned to a variable at the top-level of a JavaScript module (alternatively, you can provide [a function that creates a graph](./graph_rebuild.md)).
-
-Example file directory:
-
-```bash
-my-app/
-├── src # all project code lies within here
-│   ├── utils # optional utilities for your graph
-│   │   ├── tools.ts # tools for your graph
-│   │   ├── nodes.ts # node functions for you graph
-│   │   └── state.ts # state definition of your graph
-│   └── agent.ts # code for constructing your graph
-├── package.json # package dependencies
-├── .env # environment variables
-└── langgraph.json # configuration file for LangGraph
-```
-
-## Create LangGraph API Config
-
-Create a [LangGraph API configuration file](../reference/cli.md#configuration-file) called `langgraph.json`. See the [LangGraph CLI reference](../reference/cli.md#configuration-file) for detailed explanations of each key in the JSON object of the configuration file.
-
-Example `langgraph.json` file:
-
-```json
-{
-  "node_version": "20",
-  "dockerfile_lines": [],
-  "dependencies": ["."],
-  "graphs": {
-    "agent": "./src/agent.ts:graph"
-  },
-  "env": ".env"
-}
-```
-
-Note that the variable name of the `CompiledGraph` appears at the end of the value of each subkey in the top-level `graphs` key (i.e. `:<variable_name>`).
-
-!!! info "Configuration Location"
-    The LangGraph API configuration file must be placed in a directory that is at the same level or higher than the TypeScript files that contain compiled graphs and associated dependencies.
-
-## Next
-
-After you setup your project and place it in a github repo, it's time to [deploy your app](./cloud.md).

docs/docs/cloud/deployment/setup_pyproject.md

@@ -1,199 +0,0 @@
-# How to Set Up a LangGraph Application for Deployment
-
-A LangGraph application must be configured with a [LangGraph API configuration file](../reference/cli.md#configuration-file) in order to be deployed to LangGraph Cloud (or to be self-hosted). This how-to guide discusses the basic steps to setup a LangGraph application for deployment using `pyproject.toml` to define your package's dependencies.
-
-This walkthrough is based on [this repository](https://github.com/langchain-ai/langgraph-example-pyproject), which you can play around with to learn more about how to setup your LangGraph application for deployment.
-
-!!! tip "Setup with requirements.txt"
-  If you prefer using `requirements.txt` for dependency management, check out [this how-to guide](./setup.md).
-
-!!! tip "Setup with a Monorepo"
-    If you are interested in deploying a graph located inside a monorepo, take a look at [this](https://github.com/langchain-ai/langgraph-example-monorepo) repository for an example of how to do so.
-
-The final repo structure will look something like this:
-
-```bash
-my-app/
-├── my_agent # all project code lies within here
-│   ├── utils # utilities for your graph
-│   │   ├── __init__.py
-│   │   ├── tools.py # tools for your graph
-│   │   ├── nodes.py # node functions for you graph
-│   │   └── state.py # state definition of your graph
-│   ├── __init__.py
-│   └── agent.py # code for constructing your graph
-├── .env # environment variables
-├── langgraph.json  # configuration file for LangGraph
-└── pyproject.toml # dependencies for your project
-```
-
-After each step, an example file directory is provided to demonstrate how code can be organized.
-
-## Specify Dependencies
-
-Dependencies can optionally be specified in one of the following files: `pyproject.toml`, `setup.py`, or `requirements.txt`. If none of these files is created, then dependencies can be specified later in the [LangGraph API configuration file](#create-langgraph-api-config).
-
-The dependencies below will be included in the image, you can also use them in your code, as long as with a compatible version range:
-
-```
-langgraph>=0.2.7,<0.3.0
-langgraph-checkpoint>=1.0.4
-langchain-core>=0.2.27,<0.3.0
-langsmith>=0.1.63
-orjson>=3.9.7
-httpx>=0.25.0
-tenacity>=8.0.0
-uvicorn>=0.26.0
-sse-starlette>=2.1.0
-uvloop>=0.18.0
-httptools>=0.5.0
-jsonschema-rs>=0.16.3
-croniter>=1.0.1
-structlog>=24.4.0
-redis>=5.0.8,<6.0.0
-```
-
-Example `pyproject.toml` file:
-
-```toml
-[tool.poetry]
-name = "my-agent"
-version = "0.0.1"
-description = "An excellent agent build for LangGraph cloud."
-authors = ["Polly the parrot <1223+polly@users.noreply.github.com>"]
-license = "MIT"
-readme = "README.md"
-
-[tool.poetry.dependencies]
-python = ">=3.9.0,<3.13"
-langgraph = "^0.2.0"
-langchain-fireworks = "^0.1.3"
-
-
-[build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"
-```
-
-Example file directory:
-
-```bash
-my-app/
-└── pyproject.toml   # Python packages required for your graph
-```
-
-## Specify Environment Variables
-
-Environment variables can optionally be specified in a file (e.g. `.env`). See the [Environment Variables reference](../reference/env_var.md) to configure additional variables for a deployment.
-
-Example `.env` file:
-
-```
-MY_ENV_VAR_1=foo
-MY_ENV_VAR_2=bar
-FIREWORKS_API_KEY=key
-```
-
-Example file directory:
-
-```bash
-my-app/
-├── .env             # file with environment variables
-└── pyproject.toml
-```
-
-## Define Graphs
-
-Implement your graphs! Graphs can be defined in a single file or multiple files. Make note of the variable names of each [CompiledGraph][compiledgraph] to be included in the LangGraph application. The variable names will be used later when creating the [LangGraph API configuration file](../reference/cli.md#configuration-file).
-
-Example `agent.py` file, which shows how to import from other modules you define (code for the modules is not shown here, please see [this repo](https://github.com/langchain-ai/langgraph-example-pyproject) to see their implementation):
-
-```python
-# my_agent/agent.py
-from typing import TypedDict, Literal
-
-from langgraph.graph import StateGraph, END, START
-from my_agent.utils.nodes import call_model, should_continue, tool_node # import nodes
-from my_agent.utils.state import AgentState # import state
-
-# Define the config
-class GraphConfig(TypedDict):
-    model_name: Literal["anthropic", "openai"]
-
-workflow = StateGraph(AgentState, config_schema=GraphConfig)
-workflow.add_node("agent", call_model)
-workflow.add_node("action", tool_node)
-workflow.add_edge(START, "agent")
-workflow.add_conditional_edges(
-    "agent",
-    should_continue,
-    {
-        "continue": "action",
-        "end": END,
-    },
-)
-workflow.add_edge("action", "agent")
-
-graph = workflow.compile()
-```
-
-!!! warning "Assign `CompiledGraph` to Variable"
-    The build process for LangGraph Cloud requires that the `CompiledGraph` object be assigned to a variable at the top-level of a Python module.
-
-Example file directory:
-
-```bash
-my-app/
-├── my_agent # all project code lies within here
-│   ├── utils # utilities for your graph
-│   │   ├── __init__.py
-│   │   ├── tools.py # tools for your graph
-│   │   ├── nodes.py # node functions for you graph
-│   │   └── state.py # state definition of your graph
-│   ├── __init__.py
-│   └── agent.py # code for constructing your graph
-├── .env
-└── pyproject.toml
-```
-
-## Create LangGraph API Config
-
-Create a [LangGraph API configuration file](../reference/cli.md#configuration-file) called `langgraph.json`. See the [LangGraph CLI reference](../reference/cli.md#configuration-file) for detailed explanations of each key in the JSON object of the configuration file.
-
-Example `langgraph.json` file:
-
-```json
-{
-  "dependencies": ["."],
-  "graphs": {
-    "agent": "./my_agent/agent.py:graph"
-  },
-  "env": ".env"
-}
-```
-
-Note that the variable name of the `CompiledGraph` appears at the end of the value of each subkey in the top-level `graphs` key (i.e. `:<variable_name>`).
-
-!!! warning "Configuration Location"
-    The LangGraph API configuration file must be placed in a directory that is at the same level or higher than the Python files that contain compiled graphs and associated dependencies.
-
-Example file directory:
-
-```bash
-my-app/
-├── my_agent # all project code lies within here
-│   ├── utils # utilities for your graph
-│   │   ├── __init__.py
-│   │   ├── tools.py # tools for your graph
-│   │   ├── nodes.py # node functions for you graph
-│   │   └── state.py # state definition of your graph
-│   ├── __init__.py
-│   └── agent.py # code for constructing your graph
-├── .env # environment variables
-├── langgraph.json  # configuration file for LangGraph
-└── pyproject.toml # dependencies for your project
-```
-
-## Next
-
-After you setup your project and place it in a github repo, it's time to [deploy your app](./cloud.md).

docs/docs/cloud/deployment/test_locally.md

@@ -1,186 +0,0 @@
-# How to test a LangGraph app locally
-
-This guide assumes you have a LangGraph app correctly set up with a proper configuration file and a corresponding compiled graph, and that you have a proper LangChain API key.
-
-Testing locally ensures that there are no errors or conflicts with Python dependencies and confirms that the configuration file is specified correctly.
-
-## Setup
-
-Install the proper packages:
-
-```shell
-pip install langgraph-cli
-```
-
-Ensure you have an API key, which you can create from the LangSmith UI (Settings > API Keys). This is required to authenticate that you have LangGraph Cloud access. After you have saved the key to a safe place, place the following line in your `.env` file:
-
-```python
-LANGCHAIN_API_KEY = *********
-```
-
-## Start the API server
-
-Once you have downloaded the CLI, you can run the following command to start the API server for local testing:
-
-```shell
-langgraph up
-```
-
-This will start up the LangGraph API server locally. If this runs successfully, you should see something like:
-
-```shell
-Ready!
-- API: http://localhost:8123
-2024-06-26 19:20:41,056:INFO:uvicorn.access 127.0.0.1:44138 - "GET /ok HTTP/1.1" 200
-```
-
-### Interact with the server
-
-We can now interact with the API server using the LangGraph SDK. First, we need to start our client, select our assistant (in this case a graph we called "agent", make sure to select the proper assistant you wish to test).
-
-You can either initialize by passing authentication or by setting an environment variable.
-
-#### Initialize with authentication
-
-=== "Python"
-
-    ```python
-    from langgraph_sdk import get_client
-
-    # only pass the url argument to get_client() if you changed the default port when calling langgraph up
-    client = get_client(url=<DEPLOYMENT_URL>,api_key=<LANGCHAIN_API_KEY>)
-    # Using the graph deployed with the name "agent"
-    assistant_id = "agent"
-    thread = await client.threads.create()
-    ```
-
-=== "Javascript"
-
-    ```js
-    import { Client } from "@langchain/langgraph-sdk";
-
-    // only set the apiUrl if you changed the default port when calling langgraph up
-    const client = new Client({ apiUrl: <DEPLOYMENT_URL>, apiKey: <LANGCHAIN_API_KEY> });
-    // Using the graph deployed with the name "agent"
-    const assistantId = "agent";
-    const thread = await client.threads.create();
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-      --url <DEPLOYMENT_URL>/threads \
-      --header 'Content-Type: application/json'
-      --header 'x-api-key: <LANGCHAIN_API_KEY>'
-    ```
-  
-
-#### Initialize with environment variables
-
-If you have a `LANGCHAIN_API_KEY` set in your environment, you do not need to explicitly pass authentication to the client
-
-=== "Python"
-
-    ```python
-    from langgraph_sdk import get_client
-
-    # only pass the url argument to get_client() if you changed the default port when calling langgraph up
-    client = get_client()
-    # Using the graph deployed with the name "agent"
-    assistant_id = "agent"
-    thread = await client.threads.create()
-    ```
-
-=== "Javascript"
-
-    ```js
-    import { Client } from "@langchain/langgraph-sdk";
-
-    // only set the apiUrl if you changed the default port when calling langgraph up
-    const client = new Client();
-    // Using the graph deployed with the name "agent"
-    const assistantId = "agent";
-    const thread = await client.threads.create();
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-      --url <DEPLOYMENT_URL>/threads \
-      --header 'Content-Type: application/json'
-    ```
-
-Now we can invoke our graph to ensure it is working. Make sure to change the input to match the proper schema for your graph. 
-
-=== "Python"
-
-    ```python
-    input = {"messages": [{"role": "human", "content": "what's the weather in sf"}]}
-    async for chunk in client.runs.stream(
-        thread["thread_id"],
-        assistant_id,
-        input=input,
-        stream_mode="updates",
-    ):
-        print(f"Receiving new event of type: {chunk.event}...")
-        print(chunk.data)
-        print("\n\n")
-    ```
-=== "Javascript"
-
-    ```js
-    const input = { "messages": [{ "role": "human", "content": "what's the weather in sf"}] }
-
-    const streamResponse = client.runs.stream(
-      thread["thread_id"],
-      assistantId,
-      {
-        input: input,
-        streamMode: "updates",
-      }
-    );
-    for await (const chunk of streamResponse) {
-      console.log(`Receiving new event of type: ${chunk.event}...`);
-      console.log(chunk.data);
-      console.log("\n\n");
-    }
-    ```
-
-  === "CURL"
-
-    ```bash
-    curl --request POST \
-     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-     --header 'Content-Type: application/json' \
-     --data "{
-       \"assistant_id\": \"agent\",
-       \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"what's the weather in sf\"}]},
-       \"stream_mode\": [
-         \"events\"
-       ]
-     }" | \
-     sed 's/\r$//' | \
-     awk '
-     /^event:/ {
-         if (data_content != "") {
-             print data_content "\n"
-         }
-         sub(/^event: /, "Receiving event of type: ", $0)
-         printf "%s...\n", $0
-         data_content = ""
-     }
-     /^data:/ {
-         sub(/^data: /, "", $0)
-         data_content = $0
-     }
-     END {
-         if (data_content != "") {
-             print data_content "\n"
-         }
-     }
-     ' 
-    ```
-
-If your graph works correctly, you should see your graph output displayed in the console. Of course, there are many more ways you might need to test your graph, for a full list of commands you can send with the SDK, see the [Python](https://langchain-ai.github.io/langgraph/cloud/reference/sdk/python_sdk_ref/) and [JS/TS](https://langchain-ai.github.io/langgraph/cloud/reference/sdk/js_ts_sdk_ref/) references.

docs/docs/cloud/faq/studio.md

@@ -1,73 +0,0 @@
-# Studio FAQs
-
-## Why is my project failing to start?
-
-There are a few reasons that your project might fail to start, here are some of the most common ones.
-
-### Docker issues
-
-LangGraph Studio requires Docker Desktop version 4.24 or higher. Please make sure you have a version of Docker installed that satisfies that requirement and also make sure you have the Docker Desktop app up and running before trying to use LangGraph Studio. In addition, make sure you have docker-compose updated to version 2.22.0 or higher.
-
-### Configuration or environment issues
-
-Another reason your project might fail to start is because your configuration file is defined incorrectly, or you are missing required environment variables. 
-
-## How does interrupt work?
-
-When you select the `Interrupts` dropdown and select a node to interrupt the graph will pause execution before and after (unless the node goes straight to `END`) that node has run. This means that you will be able to both edit the state before the node is ran and the state after the node has ran. This is intended to allow developers more fine-grained control over the behavior of a node and make it easier to observe how the node is behaving. You will not be able to edit the state after the node has ran if the node is the final node in the graph.
-
-## How do I reload the app?
-
-If you would like to reload the app, don't use Command+R as you might normally do. Instead, close and reopen the app for a full refresh.
-
-## How does automatic rebuilding work?
-
-One of the key features of LangGraph Studio is that it automatically rebuilds your image when you change the source code. This allows for a super fast development and testing cycle which makes it easy to iterate on your graph. There are two different ways that LangGraph rebuilds your image: either by editing the image or completely rebuilding it.
-
-### Rebuilds from source code changes
-
-If you modified the source code only (no configuration or dependency changes!) then the image does not require a full rebuild, and LangGraph Studio will only update the relevant parts. The UI status in the bottom left will switch from `Online` to `Stopping` temporarily while the image gets edited. The logs will be shown as this process is happening, and after the image has been edited the status will change back to `Online` and you will be able to run your graph with the modified code!
-
-
-### Rebuilds from configuration or dependency changes
-
-If you edit your graph configuration file (`langgraph.json`) or the dependencies (either `pyproject.toml` or `requirements.txt`) then the entire image will be rebuilt. This will cause the UI to switch away from the graph view and start showing the logs of the new image building process. This can take a minute or two, and once it is done your updated image will be ready to use!
-
-## Why is my graph taking so long to startup?
-
-The LangGraph Studio interacts with a local LangGraph API server. To stay aligned with ongoing updates, the LangGraph API requires regular rebuilding. As a result, you may occasionally experience slight delays when starting up your project.
-
-## Why are extra edges showing up in my graph?
-
-If you don't define your conditional edges carefully, you might notice extra edges appearing in your graph. This is because without proper definition, LangGraph Studio assumes the conditional edge could access all other nodes. In order for this to not be the case, you need to be explicit about how you define the nodes the conditional edge routes to. There are two ways you can do this:
-
-### Solution 1: Include a path map
-
-The first way to solve this is to add path maps to your conditional edges. A path map is just a dictionary or array that maps the possible outputs of your router function with the names of the nodes that each output corresponds to. The path map is passed as the third argument to the `add_conditional_edges` function like so:
-
-=== "Python"
-
-    ```python
-    graph.add_conditional_edges("node_a", routing_function, {True: "node_b", False: "node_c"})
-    ```
-
-=== "Javascript"
-
-    ```ts
-    graph.addConditionalEdges("node_a", routingFunction, ["node_b", "node_c"]);
-    ```
-
-In this case, the routing function returns either True or False, which map to `node_b` and `node_c` respectively.
-
-### Solution 2: Update the typing of the router (Python only)
-
-Instead of passing a path map, you can also be explicit about the typing of your routing function by specifying the nodes it can map to using the `Literal` python definition. Here is an example of how to define a routing function in that way:
-
-```python
-def routing_function(state: GraphState) -> Literal["node_b","node_c"]:
-    if state['some_condition'] == True:
-        return "node_a"
-    else:
-        return "node_b"
-```
-

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

@@ -1,443 +0,0 @@
-# How to kick off background runs
-
-This guide covers how to kick off background runs for your agent.
-This can be useful for long running jobs.
-
-First let's set up our client and thread:
-
-=== "Python"
-
-    ```python
-    from langgraph_sdk import get_client
-
-    client = get_client(url=<DEPLOYMENT_URL>)
-    # Using the graph deployed with the name "agent"
-    assistant_id = "agent"
-    # create thread
-    thread = await client.threads.create()
-    print(thread)
-    ```
-
-=== "Javascript"
-
-    ```js
-    import { Client } from "@langchain/langgraph-sdk";
-
-    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
-    // Using the graph deployed with the name "agent"
-    const assistantID = "agent";
-    // create thread
-    const thread = await client.threads.create();
-    console.log(thread);
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-      --url <DEPLOYMENT_URL>/threads \
-      --header 'Content-Type: application/json'
-    ```
-
-Output:
-
-    {
-        'thread_id': '5cb1e8a1-34b3-4a61-a34e-71a9799bd00d',
-        'created_at': '2024-08-30T20:35:52.062934+00:00',
-        'updated_at': '2024-08-30T20:35:52.062934+00:00',
-        'metadata': {},
-        'status': 'idle',
-        'config': {},
-        'values': None
-    }
-
-If we list the current runs on this thread, we will see that it's empty:
-
-=== "Python"
-
-    ```python
-    runs = await client.runs.list(thread["thread_id"])
-    print(runs)
-    ```
-
-=== "Javascript"
-
-    ```js
-    let runs = await client.runs.list(thread['thread_id']);
-    console.log(runs);
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request GET \
-        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs
-    ```
-
-Output:
-
-    []
-
-Now let's kick off a run:
-
-=== "Python"
-
-    ```python
-    input = {"messages": [{"role": "human", "content": "what's the weather in sf"}]}
-    run = await client.runs.create(thread["thread_id"], assistant_id, input=input)
-    ```
-
-=== "Javascript"
-
-    ```js
-    let input = {"messages": [{"role": "human", "content": "what's the weather in sf"}]};
-    let run = await client.runs.create(thread["thread_id"], assistantID, { input });
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs \
-        --header 'Content-Type: application/json' \
-        --data '{
-            "assistant_id": <ASSISTANT_ID>
-        }'
-    ```
-
-The first time we poll it, we can see `status=pending`:
-
-=== "Python"
-
-    ```python
-    print(await client.runs.get(thread["thread_id"], run["run_id"]))
-    ```
-
-=== "Javascript"
-
-    ```js
-    console.log(await client.runs.get(thread["thread_id"], run["run_id"]));
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request GET \
-        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/<RUN_ID>
-    ```
-
-Output:
-
-        {
-            "run_id": "1ef6a5f8-bd86-6763-bbd6-bff042db7b1b",
-            "thread_id": "7885f0cf-94ad-4040-91d7-73f7ba007c8a",
-            "assistant_id": "fe096781-5601-53d2-b2f6-0d3403f7e9ca",
-            "created_at": "2024-09-04T01:46:47.244887+00:00",
-            "updated_at": "2024-09-04T01:46:47.244887+00:00",
-            "metadata": {},
-            "status": "pending",
-            "kwargs": {
-                "input": {
-                    "messages": [
-                        {
-                            "role": "human",
-                            "content": "what's the weather in sf"
-                        }
-                    ]
-                },
-                "config": {
-                    "metadata": {
-                        "created_by": "system"
-                    },
-                    "configurable": {
-                        "run_id": "1ef6a5f8-bd86-6763-bbd6-bff042db7b1b",
-                        "user_id": "",
-                        "graph_id": "agent",
-                        "thread_id": "7885f0cf-94ad-4040-91d7-73f7ba007c8a",
-                        "assistant_id": "fe096781-5601-53d2-b2f6-0d3403f7e9ca",
-                        "checkpoint_id": null
-                    }
-                },
-                "webhook": null,
-                "temporary": false,
-                "stream_mode": [
-                    "values"
-                ],
-                "feedback_keys": null,
-                "interrupt_after": null,
-                "interrupt_before": null
-            },
-            "multitask_strategy": "reject"
-        }
-
-
-
-Now we can join the run, wait for it to finish and check that status again:
-
-=== "Python"
-
-    ```python
-    await client.runs.join(thread["thread_id"], run["run_id"])
-    print(await client.runs.get(thread["thread_id"], run["run_id"]))
-    ```
-
-=== "Javascript"
-
-    ```js
-    await client.runs.join(thread["thread_id"], run["run_id"]);
-    console.log(await client.runs.get(thread["thread_id"], run["run_id"]));
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request GET \
-        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/<RUN_ID>/join &&
-    curl --request GET \
-        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/<RUN_ID>
-    ```
-
-Output:
-
-    {
-        "run_id": "1ef6a5f8-bd86-6763-bbd6-bff042db7b1b",
-        "thread_id": "7885f0cf-94ad-4040-91d7-73f7ba007c8a",
-        "assistant_id": "fe096781-5601-53d2-b2f6-0d3403f7e9ca",
-        "created_at": "2024-09-04T01:46:47.244887+00:00",
-        "updated_at": "2024-09-04T01:46:47.244887+00:00",
-        "metadata": {},
-        "status": "success",
-        "kwargs": {
-            "input": {
-                "messages": [
-                    {
-                        "role": "human",
-                        "content": "what's the weather in sf"
-                    }
-                ]
-            },
-            "config": {
-                "metadata": {
-                    "created_by": "system"
-                },
-                "configurable": {
-                    "run_id": "1ef6a5f8-bd86-6763-bbd6-bff042db7b1b",
-                    "user_id": "",
-                    "graph_id": "agent",
-                    "thread_id": "7885f0cf-94ad-4040-91d7-73f7ba007c8a",
-                    "assistant_id": "fe096781-5601-53d2-b2f6-0d3403f7e9ca",
-                    "checkpoint_id": null
-                }
-            },
-            "webhook": null,
-            "temporary": false,
-            "stream_mode": [
-                "values"
-            ],
-            "feedback_keys": null,
-            "interrupt_after": null,
-            "interrupt_before": null
-        },
-        "multitask_strategy": "reject"
-    }
-
-
-Perfect! The run succeeded as we would expect. We can double check that the run worked as expected by printing out the final state:
-
-=== "Python"
-
-    ```python
-    final_result = await client.threads.get_state(thread["thread_id"])
-    print(final_result)
-    ```
-
-=== "Javascript"
-
-    ```js
-    let finalResult = await client.threads.getState(thread["thread_id"]);
-    console.log(finalResult);
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request GET \
-        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state
-    ```
-
-Output:
-
-    {
-        "values": {
-            "messages": [
-                {
-                    "content": "what's the weather in sf",
-                    "additional_kwargs": {},
-                    "response_metadata": {},
-                    "type": "human",
-                    "name": null,
-                    "id": "beba31bf-320d-4125-9c37-cadf526ac47a",
-                    "example": false
-                },
-                {
-                    "content": [
-                        {
-                            "id": "toolu_01AaNPSPzqia21v7aAKwbKYm",
-                            "input": {},
-                            "name": "tavily_search_results_json",
-                            "type": "tool_use",
-                            "index": 0,
-                            "partial_json": "{\"query\": \"weather in san francisco\"}"
-                        }
-                    ],
-                    "additional_kwargs": {},
-                    "response_metadata": {
-                        "stop_reason": "tool_use",
-                        "stop_sequence": null
-                    },
-                    "type": "ai",
-                    "name": null,
-                    "id": "run-f220faf8-1d27-4f73-ad91-6bb3f47e8639",
-                    "example": false,
-                    "tool_calls": [
-                        {
-                            "name": "tavily_search_results_json",
-                            "args": {
-                                "query": "weather in san francisco"
-                            },
-                            "id": "toolu_01AaNPSPzqia21v7aAKwbKYm",
-                            "type": "tool_call"
-                        }
-                    ],
-                    "invalid_tool_calls": [],
-                    "usage_metadata": {
-                        "input_tokens": 273,
-                        "output_tokens": 61,
-                        "total_tokens": 334
-                    }
-                },
-                {
-                    "content": "[{\"url\": \"https://www.weatherapi.com/\", \"content\": \"{'location': {'name': 'San Francisco', 'region': 'California', 'country': 'United States of America', 'lat': 37.78, 'lon': -122.42, 'tz_id': 'America/Los_Angeles', 'localtime_epoch': 1725052131, 'localtime': '2024-08-30 14:08'}, 'current': {'last_updated_epoch': 1725051600, 'last_updated': '2024-08-30 14:00', 'temp_c': 21.1, 'temp_f': 70.0, 'is_day': 1, 'condition': {'text': 'Partly cloudy', 'icon': '//cdn.weatherapi.com/weather/64x64/day/116.png', 'code': 1003}, 'wind_mph': 11.9, 'wind_kph': 19.1, 'wind_degree': 290, 'wind_dir': 'WNW', 'pressure_mb': 1018.0, 'pressure_in': 30.07, 'precip_mm': 0.0, 'precip_in': 0.0, 'humidity': 59, 'cloud': 25, 'feelslike_c': 21.1, 'feelslike_f': 70.0, 'windchill_c': 18.6, 'windchill_f': 65.5, 'heatindex_c': 18.6, 'heatindex_f': 65.5, 'dewpoint_c': 12.2, 'dewpoint_f': 54.0, 'vis_km': 16.0, 'vis_miles': 9.0, 'uv': 5.0, 'gust_mph': 15.0, 'gust_kph': 24.2}}\"}]",
-                    "additional_kwargs": {},
-                    "response_metadata": {},
-                    "type": "tool",
-                    "name": "tavily_search_results_json",
-                    "id": "686b2487-f332-4e58-9508-89b3a814cd81",
-                    "tool_call_id": "toolu_01AaNPSPzqia21v7aAKwbKYm",
-                    "artifact": {
-                        "query": "weather in san francisco",
-                        "follow_up_questions": null,
-                        "answer": null,
-                        "images": [],
-                        "results": [
-                            {
-                                "title": "Weather in San Francisco",
-                                "url": "https://www.weatherapi.com/",
-                                "content": "{'location': {'name': 'San Francisco', 'region': 'California', 'country': 'United States of America', 'lat': 37.78, 'lon': -122.42, 'tz_id': 'America/Los_Angeles', 'localtime_epoch': 1725052131, 'localtime': '2024-08-30 14:08'}, 'current': {'last_updated_epoch': 1725051600, 'last_updated': '2024-08-30 14:00', 'temp_c': 21.1, 'temp_f': 70.0, 'is_day': 1, 'condition': {'text': 'Partly cloudy', 'icon': '//cdn.weatherapi.com/weather/64x64/day/116.png', 'code': 1003}, 'wind_mph': 11.9, 'wind_kph': 19.1, 'wind_degree': 290, 'wind_dir': 'WNW', 'pressure_mb': 1018.0, 'pressure_in': 30.07, 'precip_mm': 0.0, 'precip_in': 0.0, 'humidity': 59, 'cloud': 25, 'feelslike_c': 21.1, 'feelslike_f': 70.0, 'windchill_c': 18.6, 'windchill_f': 65.5, 'heatindex_c': 18.6, 'heatindex_f': 65.5, 'dewpoint_c': 12.2, 'dewpoint_f': 54.0, 'vis_km': 16.0, 'vis_miles': 9.0, 'uv': 5.0, 'gust_mph': 15.0, 'gust_kph': 24.2}}",
-                                "score": 0.976148,
-                                "raw_content": null
-                            }
-                        ],
-                        "response_time": 3.07
-                    },
-                    "status": "success"
-                },
-                {
-                    "content": [
-                        {
-                            "text": "\n\nThe search results provide the current weather conditions in San Francisco. According to the data, as of 2:00 PM on August 30, 2024, the temperature in San Francisco is 70\u00b0F (21.1\u00b0C) with partly cloudy skies. The wind is blowing from the west-northwest at around 12 mph (19 km/h). The humidity is 59% and visibility is 9 miles (16 km). Overall, it looks like a nice late summer day in San Francisco with comfortable temperatures and partly sunny conditions.",
-                            "type": "text",
-                            "index": 0
-                        }
-                    ],
-                    "additional_kwargs": {},
-                    "response_metadata": {
-                        "stop_reason": "end_turn",
-                        "stop_sequence": null
-                    },
-                    "type": "ai",
-                    "name": null,
-                    "id": "run-8fecc61d-3d9f-4e16-8e8a-92f702be498a",
-                    "example": false,
-                    "tool_calls": [],
-                    "invalid_tool_calls": [],
-                    "usage_metadata": {
-                        "input_tokens": 837,
-                        "output_tokens": 124,
-                        "total_tokens": 961
-                    }
-                }
-            ]
-        },
-        "next": [],
-        "tasks": [],
-        "metadata": {
-            "step": 3,
-            "run_id": "1ef67140-eb23-684b-8253-91d4c90bb05e",
-            "source": "loop",
-            "writes": {
-                "agent": {
-                    "messages": [
-                        {
-                            "id": "run-8fecc61d-3d9f-4e16-8e8a-92f702be498a",
-                            "name": null,
-                            "type": "ai",
-                            "content": [
-                                {
-                                    "text": "\n\nThe search results provide the current weather conditions in San Francisco. According to the data, as of 2:00 PM on August 30, 2024, the temperature in San Francisco is 70\u00b0F (21.1\u00b0C) with partly cloudy skies. The wind is blowing from the west-northwest at around 12 mph (19 km/h). The humidity is 59% and visibility is 9 miles (16 km). Overall, it looks like a nice late summer day in San Francisco with comfortable temperatures and partly sunny conditions.",
-                                    "type": "text",
-                                    "index": 0
-                                }
-                            ],
-                            "example": false,
-                            "tool_calls": [],
-                            "usage_metadata": {
-                                "input_tokens": 837,
-                                "total_tokens": 961,
-                                "output_tokens": 124
-                            },
-                            "additional_kwargs": {},
-                            "response_metadata": {
-                                "stop_reason": "end_turn",
-                                "stop_sequence": null
-                            },
-                            "invalid_tool_calls": []
-                        }
-                    ]
-                }
-            },
-            "user_id": "",
-            "graph_id": "agent",
-            "thread_id": "5cb1e8a1-34b3-4a61-a34e-71a9799bd00d",
-            "created_by": "system",
-            "assistant_id": "fe096781-5601-53d2-b2f6-0d3403f7e9ca"
-        },
-        "created_at": "2024-08-30T21:09:00.079909+00:00",
-        "checkpoint_id": "1ef67141-3ca2-6fae-8003-fe96832e57d6",
-        "parent_checkpoint_id": "1ef67141-2129-6b37-8002-61fc3bf69cb5"
-    }
-
-We can also just print the content of the last AIMessage:
-
-=== "Python"
-
-    ```python
-    print(final_result['values']['messages'][-1]['content'][0]['text'])
-    ```
-
-=== "Javascript"
-
-    ```js
-    console.log(finalResult['values']['messages'][finalResult['values']['messages'].length-1]['content'][0]['text']);
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request GET \
-        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state | jq -r '.values.messages[-1].content.[0].text'
-    ```
-
-Output:
-
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 2:00 PM on August 30, 2024, the temperature in San Francisco is 70°F (21.1°C) with partly cloudy skies. The wind is blowing from the west-northwest at around 12 mph (19 km/h). The humidity is 59% and visibility is 9 miles (16 km). Overall, it looks like a nice late summer day in San Francisco with comfortable temperatures and partly sunny conditions.

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

@@ -1,202 +0,0 @@
-# Check the Status of your Threads
-
-## Setup
-
-To start, we can setup our client with whatever URL you are hosting your graph from:
-
-### SDK initialization
-
-First, we need to setup our client so that we can communicate with our hosted graph:
-
-=== "Python"
-
-    ```python
-    from langgraph_sdk import get_client
-    client = get_client(url=<DEPLOYMENT_URL>)
-    # Using the graph deployed with the name "agent"
-    assistant_id = "agent"
-    thread = await client.threads.create()
-    ```
-
-=== "Javascript"
-
-    ```js
-    import { Client } from "@langchain/langgraph-sdk";
-
-    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
-    // Using the graph deployed with the name "agent"
-    const assistantId = "agent";
-    const thread = await client.threads.create();
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-      --url <DEPLOYMENT_URL>/threads \
-      --header 'Content-Type: application/json'
-    ```
-
-## Find idle threads
-
-We can use the following commands to find threads that are idle, which means that all runs executed on the thread have finished running:
-
-=== "Python"
-
-    ```python
-    print(await client.threads.search(status="idle",limit=1))
-    ```
-
-=== "Javascript"
-
-    ```js
-    console.log(await client.threads.search({ status: "idle", limit: 1 }));
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \  
-    --url <DEPLOYMENT_URL>/threads/search \
-    --header 'Content-Type: application/json' \
-    --data '{"status": "idle", "limit": 1}'
-    ```
-
-Output:
-
-    [{'thread_id': 'cacf79bb-4248-4d01-aabc-938dbd60ed2c',
-    'created_at': '2024-08-14T17:36:38.921660+00:00',
-    'updated_at': '2024-08-14T17:36:38.921660+00:00',
-    'metadata': {'graph_id': 'agent'},
-    'status': 'idle',
-    'config': {'configurable': {}}}]
-
-
-## Find interrupted threads
-
-We can use the following commands to find threads that have been interrupted in the middle of a run, which could either mean an error occurred before the run finished or a human-in-the-loop breakpoint was reached and the run is waiting to continue: 
-
-=== "Python"
-
-    ```python
-    print(await client.threads.search(status="interrupted",limit=1))
-    ```
-
-=== "Javascript"
-
-    ```js
-    console.log(await client.threads.search({ status: "interrupted", limit: 1 }));
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \  
-    --url <DEPLOYMENT_URL>/threads/search \
-    --header 'Content-Type: application/json' \
-    --data '{"status": "interrupted", "limit": 1}'
-    ```
-
-Output:
-
-    [{'thread_id': '0d282b22-bbd5-4d95-9c61-04dcc2e302a5',
-    'created_at': '2024-08-14T17:41:50.235455+00:00',
-    'updated_at': '2024-08-14T17:41:50.235455+00:00',
-    'metadata': {'graph_id': 'agent'},
-    'status': 'interrupted',
-    'config': {'configurable': {}}}]
-    
-## Find busy threads
-
-We can use the following commands to find threads that are busy, meaning they are currently handling the execution of a run:
-
-=== "Python"
-
-    ```python
-    print(await client.threads.search(status="busy",limit=1))
-    ```
-
-=== "Javascript"
-
-    ```js
-    console.log(await client.threads.search({ status: "busy", limit: 1 }));
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \  
-    --url <DEPLOYMENT_URL>/threads/search \
-    --header 'Content-Type: application/json' \
-    --data '{"status": "busy", "limit": 1}'
-    ```
-
-Output:
-
-    [{'thread_id': '0d282b22-bbd5-4d95-9c61-04dcc2e302a5',
-    'created_at': '2024-08-14T17:41:50.235455+00:00',
-    'updated_at': '2024-08-14T17:41:50.235455+00:00',
-    'metadata': {'graph_id': 'agent'},
-    'status': 'busy',
-    'config': {'configurable': {}}}]
-
-## Find specific threads
-
-You may also want to check the status of specific threads, which you can do in a few ways:
-
-### Find by ID
-
-You can use the `get` function to find the status of a specific thread, as long as you have the ID saved
-
-=== "Python"
-
-    ```python
-    print((await client.threads.get(<THREAD_ID>))['status'])
-    ```
-
-=== "Javascript"
-
-    ```js
-    console.log((await client.threads.get(<THREAD_ID>)).status);
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request GET \ 
-    --url <DEPLOYMENT_URL>/threads/<THREAD_ID> \
-    --header 'Content-Type: application/json' | jq -r '.status'
-    ```
-
-Output:
-
-    'idle'
-
-### Find by metadata
-
-The search endpoint for threads also allows you to filter on metadata, which can be helpful if you use metadata to tag threads in order to keep them organized:
-
-=== "Python"
-
-    ```python
-    print((await client.threads.search(metadata={"foo":"bar"},limit=1))[0]['status'])
-    ```
-
-=== "Javascript"
-
-    ```js
-    console.log((await client.threads.search({ metadata: { "foo": "bar" }, limit: 1 }))[0].status);
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \  
-    --url <DEPLOYMENT_URL>/threads/search \
-    --header 'Content-Type: application/json' \
-    --data '{"metadata": {"foo":"bar"}, "limit": 1}' | jq -r '.[0].status'
-    ```
-
-Output:
-
-    'idle'

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

@@ -1,264 +0,0 @@
-# How to create agents with configuration
-
-One of the benefits of LangGraph API is that it lets you create agents with different configurations.
-This is useful when you want to:
-
-- Define a cognitive architecture once as a LangGraph
-- Let that LangGraph be configurable across some attributes (for example, system message or LLM to use)
-- Let users create agents with arbitrary configurations, save them, and then use them in the future
-
-In this guide we will show how to do that for the default agent we have built in.
-
-If you look at the agent we defined, you can see that inside the `call_model` node we have created the model based on some configuration. That node looks like:
-
-=== "Python"
-
-    ```python
-    def call_model(state, config):
-        messages = state["messages"]
-        model_name = config.get('configurable', {}).get("model_name", "anthropic")
-        model = _get_model(model_name)
-        response = model.invoke(messages)
-        # We return a list, because this will get added to the existing list
-        return {"messages": [response]}
-    ```
-
-=== "Javascript"
-
-    ```js
-    function callModel(state: State, config: RunnableConfig) {
-      const messages = state.messages;
-      const modelName = config.configurable?.model_name ?? "anthropic";
-      const model = _getModel(modelName);
-      const response = model.invoke(messages);
-      // We return a list, because this will get added to the existing list
-      return { messages: [response] };
-    }
-    ```
-
-We are looking inside the config for a `model_name` parameter (which defaults to `anthropic` if none is found). That means that by default we are using Anthropic as our model provider. In this example we will see an example of how to create an example agent that is configured to use OpenAI.
-
-First let's set up our client and thread:
-
-=== "Python"
-
-    ```python
-    from langgraph_sdk import get_client
-
-    client = get_client(url=<DEPLOYMENT_URL>)
-    # Select an assistant that is not configured
-    assistants = await client.assistants.search()
-    assistant = [a for a in assistants if not a["config"]][0]
-    ```
-
-=== "Javascript"
-
-    ```js
-    import { Client } from "@langchain/langgraph-sdk";
-
-    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
-    // Select an assistant that is not configured
-    const assistants = await client.assistants.search();
-    const assistant = assistants.find(a => !a.config);
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-        --url <DEPLOYMENT_URL>/assistants/search \
-        --header 'Content-Type: application/json' \
-        --data '{
-            "limit": 10,
-            "offset": 0
-        }' | jq -c 'map(select(.config == null or .config == {})) | .[0]'
-    ```
-
-We can now call `.get_schemas` to get schemas associated with this graph:
-
-=== "Python"
-
-    ```python
-    schemas = await client.assistants.get_schemas(
-        assistant_id=assistant["assistant_id"]
-    )
-    # There are multiple types of schemas
-    # We can get the `config_schema` to look at the the configurable parameters
-    print(schemas["config_schema"])
-    ```
-
-=== "Javascript"
-
-    ```js
-    const schemas = await client.assistants.getSchemas(
-      assistant["assistant_id"]
-    );
-    // There are multiple types of schemas
-    // We can get the `config_schema` to look at the the configurable parameters
-    console.log(schemas.config_schema);
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request GET \
-        --url <DEPLOYMENT_URL>/assistants/<ASSISTANT_ID>/schemas | jq -r '.config_schema'
-    ```
-
-Output:
-
-    {
-        'model_name': 
-            {
-                'title': 'Model Name',
-                'enum': ['anthropic', 'openai'],
-                'type': 'string'
-            }
-    }
-
-Now we can initialize an assistant with config:
-
-=== "Python"
-
-    ```python
-    openai_assistant = await client.assistants.create(
-        # "agent" is the name of a graph we deployed
-        "agent", config={"configurable": {"model_name": "openai"}}
-    )
-
-    print(openai_assistant)
-    ```
-
-=== "Javascript"
-
-    ```js
-    let openAIAssistant = await client.assistants.create(
-      // "agent" is the name of a graph we deployed
-      "agent", { "configurable": { "model_name": "openai" } }
-    );
-
-    console.log(openAIAssistant);
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-        --url <DEPLOYMENT_URL>/assistants \
-        --header 'Content-Type: application/json' \
-        --data '{"graph_id":"agent","config":{"configurable":{"model_name":"open_ai"}}}'
-    ```
-
-Output:
-
-    {
-        "assistant_id": "62e209ca-9154-432a-b9e9-2d75c7a9219b",
-        "graph_id": "agent",
-        "created_at": "2024-08-31T03:09:10.230718+00:00",
-        "updated_at": "2024-08-31T03:09:10.230718+00:00",
-        "config": {
-            "configurable": {
-                "model_name": "open_ai"
-            }
-        },
-        "metadata": {}
-    }
-
-We can verify the config is indeed taking effect:
-
-=== "Python"
-
-    ```python
-    thread = await client.threads.create()
-    input = {"messages": [{"role": "user", "content": "who made you?"}]}
-    async for event in client.runs.stream(
-        thread["thread_id"],
-        openai_assistant["assistant_id"],
-        input=input,
-        stream_mode="updates",
-    ):
-        print(f"Receiving event of type: {event.event}")
-        print(event.data)
-        print("\n\n")
-    ```
-
-=== "Javascript"
-
-    ```js
-    const thread = await client.threads.create();
-    let input = { "messages": [{ "role": "user", "content": "who made you?" }] };
-
-    const streamResponse = client.runs.stream(
-      thread["thread_id"],
-      openAIAssistant["assistant_id"],
-      {
-        input,
-        streamMode: "updates"
-      }
-    );
-
-    for await (const event of streamResponse) {
-      console.log(`Receiving event of type: ${event.event}`);
-      console.log(event.data);
-      console.log("\n\n");
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    thread_id=$(curl --request POST \
-        --url <DEPLOYMENT_URL>/threads \
-        --header 'Content-Type: application/json' \
-        --data '{}' | jq -r '.thread_id') && \
-    curl --request POST \
-        --url "<DEPLOYMENT_URL>/threads/${thread_id}/runs/stream" \
-        --header 'Content-Type: application/json' \
-        --data '{
-            "assistant_id": <OPENAI_ASSISTANT_ID>,
-            "input": {
-                "messages": [
-                    {
-                        "role": "human",
-                        "content": "who made you?"
-                    }
-                ]
-            },
-            "stream_mode": [
-                "updates"
-            ]
-        }' | \
-        sed 's/\r$//' | \
-        awk '
-        /^event:/ {
-            if (data_content != "") {
-                print data_content "\n"
-            }
-            sub(/^event: /, "Receiving event of type: ", $0)
-            printf "%s...\n", $0
-            data_content = ""
-        }
-        /^data:/ {
-            sub(/^data: /, "", $0)
-            data_content = $0
-        }
-        END {
-            if (data_content != "") {
-                print data_content "\n\n"
-            }
-        }
-    '
-    ```
-
-Output:
-
-    Receiving event of type: metadata
-    {'run_id': '1ef6746e-5893-67b1-978a-0f1cd4060e16'}
-
-
-
-    Receiving event of type: updates
-    {'agent': {'messages': [{'content': 'I was created by OpenAI, a research organization focused on developing and advancing artificial intelligence technology.', 'additional_kwargs': {}, 'response_metadata': {'finish_reason': 'stop', 'model_name': 'gpt-4o-2024-05-13', 'system_fingerprint': 'fp_157b3831f5'}, 'type': 'ai', 'name': None, 'id': 'run-e1a6b25c-8416-41f2-9981-f9cfe043f414', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}}
-
-
-

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

@@ -1,132 +0,0 @@
-# Copying Threads
-
-You may wish to copy (i.e. "fork") an existing thread in order to keep the existing thread's history and create independent runs that do not affect the original thread. This guide shows how you can do that.
-
-## Setup
-
-This code assumes you already have a thread to copy. You can read about what a thread is [here](https://langchain-ai.github.io/langgraph/cloud/concepts/api/#threads) and learn how to stream a run on a thread in [these how-to guides](https://langchain-ai.github.io/langgraph/cloud/how-tos/#streaming).
-
-### SDK initialization
-
-First, we need to setup our client so that we can communicate with our hosted graph:
-
-=== "Python"
-
-    ```python
-    from langgraph_sdk import get_client
-    client = get_client(url="<DEPLOYMENT_URL>")
-    assistant_id = "agent"
-    thread = await client.threads.create()
-    ```
-
-=== "Javascript"
-
-    ```js
-    import { Client } from "@langchain/langgraph-sdk";
-
-    const client = new Client({ apiUrl: "<DEPLOYMENT_URL>" });
-    const assistantId = "agent";
-    const thread = await client.threads.create();
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-      --url <DEPLOYMENT_URL>/threads \
-      --header 'Content-Type: application/json' \
-      --data '{
-        "metadata": {}
-      }'
-    ```
-
-## Copying a thread
-
-The code below assumes that a thread you'd like to copy already exists.
-
-Copying a thread will create a new thread with the same history as the existing thread, and then allow you to continue executing runs.
-
-### Create copy
-
-=== "Python"
-
-    ```python
-    copied_thread = await client.threads.copy(<THREAD_ID>)
-    ```
-
-=== "Javascript"
-
-    ```js
-    let copiedThread = await client.threads.copy(<THREAD_ID>);
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/copy \
-    --header 'Content-Type: application/json'
-    ```
-
-### Verify copy
-
-We can verify that the history from the prior thread did indeed copy over correctly:
-
-=== "Python"
-
-    ```python
-    def remove_thread_id(d):
-      if 'metadata' in d and 'thread_id' in d['metadata']:
-          del d['metadata']['thread_id']
-      return d
-
-    original_thread_history = list(map(remove_thread_id,await client.threads.get_history(<THREAD_ID>)))
-    copied_thread_history = list(map(remove_thread_id,await client.threads.get_history(copied_thread['thread_id'])))
-
-    # Compare the two histories
-    assert original_thread_history == copied_thread_history
-    # if we made it here the assertion passed!
-    print("The histories are the same.")
-    ```
-
-=== "Javascript"
-
-    ```js
-    function removeThreadId(d) {
-      if (d.metadata && d.metadata.thread_id) {
-        delete d.metadata.thread_id;
-      }
-      return d;
-    }
-
-    // Assuming `client.threads.getHistory(threadId)` is an async function that returns a list of dicts
-    async function compareThreadHistories(threadId, copiedThreadId) {
-      const originalThreadHistory = (await client.threads.getHistory(threadId)).map(removeThreadId);
-      const copiedThreadHistory = (await client.threads.getHistory(copiedThreadId)).map(removeThreadId);
-
-      // Compare the two histories
-      console.assert(JSON.stringify(originalThreadHistory) === JSON.stringify(copiedThreadHistory));
-      // if we made it here the assertion passed!
-      console.log("The histories are the same.");
-    }
-
-    // Example usage
-    compareThreadHistories(<THREAD_ID>, copiedThread.thread_id);
-    ```
-
-=== "CURL"
-
-    ```bash
-    if diff <(
-        curl --request GET --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/history | jq -S 'map(del(.metadata.thread_id))'
-    ) <(
-        curl --request GET --url <DEPLOYMENT_URL>/threads/<COPIED_THREAD_ID>/history | jq -S 'map(del(.metadata.thread_id))'
-    ) >/dev/null; then
-        echo "The histories are the same."
-    else
-        echo "The histories are different."
-    fi
-    ```
-
-Output:
-
-    The histories are the same.

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

@@ -1,184 +0,0 @@
-# Cron Jobs
-
-Sometimes you don't want to run your graph based on user interaction, but rather you would like to schedule your graph to run on a schedule - for example if you wish for your graph to compose and send out a weekly email of to-dos for your team. LangGraph Cloud allows you to do this without having to write your own script by using the `Crons` client. To schedule a graph job, you need to pass a [cron expression](https://crontab.cronhub.io/) to inform the client when you want to run the graph. `Cron` jobs are run in the background and do not interfere with normal invocations of the graph.
-
-## Setup
-
-First, let's setup our SDK client, assistant, and thread:
-
-=== "Python"
-
-    ```python
-    from langgraph_sdk import get_client
-
-    client = get_client(url=<DEPLOYMENT_URL>)
-    # Using the graph deployed with the name "agent"
-    assistant_id = "agent"
-    # create thread
-    thread = await client.threads.create()
-    print(thread)
-    ```
-
-=== "Javascript"
-
-    ```js
-    import { Client } from "@langchain/langgraph-sdk";
-
-    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
-    // Using the graph deployed with the name "agent"
-    const assistantId = "agent";
-    // create thread
-    const thread = await client.threads.create();
-    console.log(thread);
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-        --url <DEPLOYMENT_URL>/assistants/search \
-        --header 'Content-Type: application/json' \
-        --data '{
-            "limit": 10,
-            "offset": 0
-        }' | jq -c 'map(select(.config == null or .config == {})) | .[0].graph_id' && \
-    curl --request POST \
-        --url <DEPLOYMENT_URL>/threads \
-        --header 'Content-Type: application/json' \
-        --data '{}'
-    ```
-
-Output:
-
-    {
-        'thread_id': '9dde5490-2b67-47c8-aa14-4bfec88af217', 
-        'created_at': '2024-08-30T23:07:38.242730+00:00', 
-        'updated_at': '2024-08-30T23:07:38.242730+00:00', 
-        'metadata': {}, 
-        'status': 'idle', 
-        'config': {}, 
-        'values': None
-    }
-
-## Cron job on a thread 
-
-To create a cron job associated with a specific thread, you can write:
-
-
-=== "Python"
-
-    ```python
-    # This schedules a job to run at 15:27 (3:27PM) every day
-    cron_job = await client.crons.create_for_thread(
-        thread["thread_id"],
-        assistant_id,
-        schedule="27 15 * * *",
-        input={"messages": [{"role": "user", "content": "What time is it?"}]},
-    )
-    ```
-
-=== "Javascript"
-
-    ```js
-    // This schedules a job to run at 15:27 (3:27PM) every day
-    const cronJob = await client.crons.create_for_thread(
-      thread["thread_id"],
-      assistantId,
-      {
-        schedule: "27 15 * * *",
-        input: { messages: [{ role: "user", content: "What time is it?" }] }
-      }
-    );
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/crons \
-        --header 'Content-Type: application/json' \
-        --data '{
-            "assistant_id": <ASSISTANT_ID>,
-        }'
-    ```
-
-Note that it is **very** important to delete `Cron` jobs that are no longer useful. Otherwise you could rack up unwanted API charges to the LLM! You can delete a `Cron` job using the following code:
-
-=== "Python"
-
-    ```python
-    await client.crons.delete(cron_job["cron_id"])
-    ```
-
-=== "Javascript"
-
-    ```js
-    await client.crons.delete(cronJob["cron_id"]);
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request DELETE \
-        --url <DEPLOYMENT_URL>/runs/crons/<CRON_ID>
-    ```
-
-## Cron job stateless
-
-You can also create stateless cron jobs by using the following code:
-
-=== "Python"
-
-    ```python
-    # This schedules a job to run at 15:27 (3:27PM) every day
-    cron_job_stateless = await client.crons.create(
-        assistant_id,
-        schedule="27 15 * * *",
-        input={"messages": [{"role": "user", "content": "What time is it?"}]},
-    )
-    ```
-
-=== "Javascript"
-
-    ```js
-    // This schedules a job to run at 15:27 (3:27PM) every day
-    const cronJobStateless = await client.crons.create(
-      assistantId,
-      {
-        schedule: "27 15 * * *",
-        input: { messages: [{ role: "user", content: "What time is it?" }] }
-      }
-    );
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-        --url <DEPLOYMENT_URL>/runs/crons \
-        --header 'Content-Type: application/json' \
-        --data '{
-            "assistant_id": <ASSISTANT_ID>,
-        }'
-    ```
-
-Again, remember to delete your job once you are done with it!
-
-=== "Python"
-
-    ```python
-    await client.crons.delete(cron_job_stateless["cron_id"])
-    ```
-
-=== "Javascript"
-
-    ```js
-    await client.crons.delete(cronJobStateless["cron_id"]);
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request DELETE \
-        --url <DEPLOYMENT_URL>/runs/crons/<CRON_ID>
-    ```

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

@@ -1,249 +0,0 @@
-## Enqueue
-
-This guide assumes knowledge of what double-texting is, which you can learn about in the [double-texting conceptual guide](../concepts/api.md#double-texting).
-
-The guide covers the `enqueue` option for double texting, which adds the interruptions to a queue and executes them in the order they are received by the client. Below is a quick example of using the `enqueue` option.
-
-
-First, we will define a quick helper function for printing out JS and CURL model outputs (you can skip this if using Python):
-
-=== "Javascript"
-
-    ```js
-    function prettyPrint(m) {
-      const padded = " " + m['type'] + " ";
-      const sepLen = Math.floor((80 - padded.length) / 2);
-      const sep = "=".repeat(sepLen);
-      const secondSep = sep + (padded.length % 2 ? "=" : "");
-      
-      console.log(`${sep}${padded}${secondSep}`);
-      console.log("\n\n");
-      console.log(m.content);
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    # PLACE THIS IN A FILE CALLED pretty_print.sh
-    pretty_print() {
-      local type="$1"
-      local content="$2"
-      local padded=" $type "
-      local total_width=80
-      local sep_len=$(( (total_width - ${#padded}) / 2 ))
-      local sep=$(printf '=%.0s' $(eval "echo {1.."${sep_len}"}"))
-      local second_sep=$sep
-      if (( (total_width - ${#padded}) % 2 )); then
-        second_sep="${second_sep}="
-      fi
-
-      echo "${sep}${padded}${second_sep}"
-      echo
-      echo "$content"
-    }
-    ```
-
-Then, let's import our required packages and instantiate our client, assistant, and thread.
-
-=== "Python"
-
-    ```python
-    import asyncio
-
-    import httpx
-    from langchain_core.messages import convert_to_messages
-    from langgraph_sdk import get_client
-
-    client = get_client(url=<DEPLOYMENT_URL>)
-    # Using the graph deployed with the name "agent"
-    assistant_id = "agent"
-    thread = await client.threads.create()
-    ```
-
-=== "Javascript"
-
-    ```js
-    import { Client } from "@langchain/langgraph-sdk";
-    
-
-    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
-    // Using the graph deployed with the name "agent"
-    const assistantId = "agent";
-    const thread = await client.threads.create();
-    ```
-  
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-      --url <DEPLOYMENT_URL>/threads \
-      --header 'Content-Type: application/json'
-    ```
-
-Now let's start two runs, with the second interrupting the first one with a multitask strategy of "enqueue":
-
-=== "Python"
-
-    ```python
-    first_run = await client.runs.create(
-        thread["thread_id"],
-        assistant_id,
-        input={"messages": [{"role": "human", "content": "what's the weather in sf?"}]},
-    )
-    second_run = await client.runs.create(
-        thread["thread_id"],
-        assistant_id,
-        input={"messages": [{"role": "human", "content": "what's the weather in nyc?"}]},
-        multitask_strategy="enqueue",
-    )
-    ```
-
-=== "Javascript"
-
-    ```js
-    const firstRun = await client.runs.create(
-      thread["thread_id"],
-      assistantId,
-      input={"messages": [{"role": "human", "content": "what's the weather in sf?"}]},
-    )
-
-    const secondRun = await client.runs.create(
-      thread["thread_id"],
-      assistantId,
-      input={"messages": [{"role": "human", "content": "what's the weather in nyc?"}]},
-      multitask_strategy="enqueue",
-    )
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-    --url <DEPLOY<ENT_URL>>/threads/<THREAD_ID>/runs \
-    --header 'Content-Type: application/json' \
-    --data "{
-      \"assistant_id\": \"agent\",
-      \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"what\'s the weather in sf?\"}]},
-    }" && curl --request POST \
-    --url <DEPLOY<ENT_URL>>/threads/<THREAD_ID>/runs \
-    --header 'Content-Type: application/json' \
-    --data "{
-      \"assistant_id\": \"agent\",
-      \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"what\'s the weather in nyc?\"}]},
-      \"multitask_strategy\": \"enqueue\"
-    }"
-    ```
-
-Verify that the thread has data from both runs:
-
-=== "Python"
-
-    ```python
-    # wait until the second run completes
-    await client.runs.join(thread["thread_id"], second_run["run_id"])
-
-    state = await client.threads.get_state(thread["thread_id"])
-
-    for m in convert_to_messages(state["values"]["messages"]):
-        m.pretty_print()
-    ```
-
-=== "Javascript"
-
-    ```js
-    await client.runs.join(thread["thread_id"], secondRun["run_id"]);
-
-    const state = await client.threads.getState(thread["thread_id"]);
-
-    for (const m of state["values"]["messages"]) {
-      prettyPrint(m);
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    source pretty_print.sh && curl --request GET \
-    --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/<RUN_ID>/join && \
-    curl --request GET --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state | \
-    jq -c '.values.messages[]' | while read -r element; do
-        type=$(echo "$element" | jq -r '.type')
-        content=$(echo "$element" | jq -r '.content | if type == "array" then tostring else . end')
-        pretty_print "$type" "$content"
-    done
-    ```
-
-Output:
-
-    ================================ Human Message =================================
-    
-    what's the weather in sf?
-    ================================== Ai Message ==================================
-    
-    [{'id': 'toolu_01Dez1sJre4oA2Y7NsKJV6VT', 'input': {'query': 'weather in san francisco'}, 'name': 'tavily_search_results_json', 'type': 'tool_use'}]
-    Tool Calls:
-      tavily_search_results_json (toolu_01Dez1sJre4oA2Y7NsKJV6VT)
-     Call ID: toolu_01Dez1sJre4oA2Y7NsKJV6VT
-      Args:
-        query: weather in san francisco
-    ================================= Tool Message =================================
-    Name: tavily_search_results_json
-    
-    [{"url": "https://www.accuweather.com/en/us/san-francisco/94103/weather-forecast/347629", "content": "Get the current and future weather conditions for San Francisco, CA, including temperature, precipitation, wind, air quality and more. See the hourly and 10-day outlook, radar maps, alerts and allergy information."}]
-    ================================== Ai Message ==================================
-    
-    According to AccuWeather, the current weather conditions in San Francisco are:
-    
-    Temperature: 57°F (14°C)
-    Conditions: Mostly Sunny
-    Wind: WSW 10 mph
-    Humidity: 72%
-    
-    The forecast for the next few days shows partly sunny skies with highs in the upper 50s to mid 60s F (14-18°C) and lows in the upper 40s to low 50s F (9-11°C). Typical mild, dry weather for San Francisco this time of year.
-    
-    Some key details from the AccuWeather forecast:
-    
-    Today: Mostly sunny, high of 62°F (17°C)
-    Tonight: Partly cloudy, low of 49°F (9°C) 
-    Tomorrow: Partly sunny, high of 59°F (15°C)
-    Saturday: Mostly sunny, high of 64°F (18°C)
-    Sunday: Partly sunny, high of 61°F (16°C)
-    
-    So in summary, expect seasonable spring weather in San Francisco over the next several days, with a mix of sun and clouds and temperatures ranging from the upper 40s at night to the low 60s during the days. Typical dry conditions with no rain in the forecast.
-    ================================ Human Message =================================
-    
-    what's the weather in nyc?
-    ================================== Ai Message ==================================
-    
-    [{'text': 'Here are the current weather conditions and forecast for New York City:', 'type': 'text'}, {'id': 'toolu_01FFft5Sx9oS6AdVJuRWWcGp', 'input': {'query': 'weather in new york city'}, 'name': 'tavily_search_results_json', 'type': 'tool_use'}]
-    Tool Calls:
-      tavily_search_results_json (toolu_01FFft5Sx9oS6AdVJuRWWcGp)
-     Call ID: toolu_01FFft5Sx9oS6AdVJuRWWcGp
-      Args:
-        query: weather in new york city
-    ================================= Tool Message =================================
-    Name: tavily_search_results_json
-    
-    [{"url": "https://www.weatherapi.com/", "content": "{'location': {'name': 'New York', 'region': 'New York', 'country': 'United States of America', 'lat': 40.71, 'lon': -74.01, 'tz_id': 'America/New_York', 'localtime_epoch': 1718734479, 'localtime': '2024-06-18 14:14'}, 'current': {'last_updated_epoch': 1718733600, 'last_updated': '2024-06-18 14:00', 'temp_c': 29.4, 'temp_f': 84.9, 'is_day': 1, 'condition': {'text': 'Sunny', 'icon': '//cdn.weatherapi.com/weather/64x64/day/113.png', 'code': 1000}, 'wind_mph': 2.2, 'wind_kph': 3.6, 'wind_degree': 158, 'wind_dir': 'SSE', 'pressure_mb': 1025.0, 'pressure_in': 30.26, 'precip_mm': 0.0, 'precip_in': 0.0, 'humidity': 63, 'cloud': 0, 'feelslike_c': 31.3, 'feelslike_f': 88.3, 'windchill_c': 28.3, 'windchill_f': 82.9, 'heatindex_c': 29.6, 'heatindex_f': 85.3, 'dewpoint_c': 18.4, 'dewpoint_f': 65.2, 'vis_km': 16.0, 'vis_miles': 9.0, 'uv': 7.0, 'gust_mph': 16.5, 'gust_kph': 26.5}}"}]
-    ================================== Ai Message ==================================
-    
-    According to the weather data from WeatherAPI:
-    
-    Current Conditions in New York City (as of 2:00 PM local time):
-    - Temperature: 85°F (29°C)
-    - Conditions: Sunny
-    - Wind: 2 mph (4 km/h) from the SSE
-    - Humidity: 63%
-    - Heat Index: 85°F (30°C)
-    
-    The forecast shows sunny and warm conditions persisting over the next few days:
-    
-    Today: Sunny, high of 85°F (29°C)
-    Tonight: Clear, low of 68°F (20°C)
-    Tomorrow: Sunny, high of 88°F (31°C) 
-    Thursday: Mostly sunny, high of 90°F (32°C)
-    Friday: Partly cloudy, high of 87°F (31°C)
-    
-    So New York City is experiencing beautiful sunny weather with seasonably warm temperatures in the mid-to-upper 80s Fahrenheit (around 30°C). Humidity is moderate in the 60% range. Overall, ideal late spring/early summer conditions for being outdoors in the city over the next several days.
-

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

@@ -1,150 +0,0 @@
-# How to Add Breakpoints
-
-When creating LangGraph agents, it is often nice to add a human-in-the-loop component.
-This can be helpful when giving them access to tools.
-Often in these situations you may want to manually approve an action before taking.
-
-This can be in several ways, but the primary supported way is to add an "interrupt" before a node is executed.
-This interrupts execution at that node.
-You can then resume from that spot to continue.  
-
-## Setup
-
-### Code for your graph
-
-In this how-to we use a simple ReAct style hosted graph (you can see the full code for defining it [here](../../how-tos/human_in_the_loop/breakpoints.ipynb)). The important thing is that there are two nodes (one named `agent` that calls the LLM, and one named `action` that calls the tool), and a routing function from `agent` that determines whether to call `action` next or just end the graph run (the `action` node always calls the `agent` node after execution).
-
-### SDK Initialization
-
-
-=== "Python"
-
-    ```python
-    from langgraph_sdk import get_client
-    client = get_client(url=<DEPLOYMENT_URL>)
-    # Using the graph deployed with the name "agent"
-    assistant_id = "agent"
-    thread = await client.threads.create()
-    ```
-
-=== "Javascript"
-
-    ```js
-    import { Client } from "@langchain/langgraph-sdk";
-
-    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
-    // Using the graph deployed with the name "agent"
-    const assistantId = "agent";
-    const thread = await client.threads.create();
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-      --url <DEPLOYMENT_URL>/threads \
-      --header 'Content-Type: application/json'
-    ```
-
-## Adding a breakpoint
-
-We now want to add a breakpoint in our graph run, which we will do before a tool is called.
-We can do this by adding `interrupt_before=["action"]`, which tells us to interrupt before calling the action node.
-We can do this either when compiling the graph or when kicking off a run.
-Here we will do it when kicking of a run, if you would like to to do it at compile time you need to edit the python file where your graph is defined and add the `interrupt_before` parameter when you call `.compile`.
-
-First let's access our hosted LangGraph instance through the SDK:
-
-And, now let's compile it with a breakpoint before the tool node:
-
-=== "Python"
-
-    ```python
-    input = {"messages": [{"role": "human", "content": "what's the weather in sf"}]}
-    async for chunk in client.runs.stream(
-        thread["thread_id"],
-        assistant_id,
-        input=input,
-        stream_mode="updates",
-        interrupt_before=["action"],
-    ):
-        print(f"Receiving new event of type: {chunk.event}...")
-        print(chunk.data)
-        print("\n\n")
-    ```
-=== "Javascript"
-
-    ```js
-    const input = { messages: [{ role: "human", content: "what's the weather in sf" }] };
-
-    const streamResponse = client.runs.stream(
-      thread["thread_id"],
-      assistantId,
-      {
-        input: input,
-        streamMode: "updates",
-        interruptBefore: ["action"]
-      }
-    );
-
-    for await (const chunk of streamResponse) {
-      console.log(`Receiving new event of type: ${chunk.event}...`);
-      console.log(chunk.data);
-      console.log("\n\n");
-    }
-    ```
-    
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-     --header 'Content-Type: application/json' \
-     --data "{
-       \"assistant_id\": \"agent\",
-       \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"what's the weather in sf\"}]},
-       \"interrupt_before\": [\"action\"],
-       \"stream_mode\": [
-         \"messages\"
-       ]
-     }" | \
-     sed 's/\r$//' | \
-     awk '
-     /^event:/ {
-         if (data_content != "") {
-             print data_content "\n"
-         }
-         sub(/^event: /, "Receiving event of type: ", $0)
-         printf "%s...\n", $0
-         data_content = ""
-     }
-     /^data:/ {
-         sub(/^data: /, "", $0)
-         data_content = $0
-     }
-     END {
-         if (data_content != "") {
-             print data_content "\n"
-         }
-     }
-     '
-    ```
-
-Output:
-
-    Receiving new event of type: metadata...
-    {'run_id': '3b77ef83-687a-4840-8858-0371f91a92c3'}
-    
-    
-    
-    Receiving new event of type: data...
-    {'agent': {'messages': [{'content': [{'id': 'toolu_01HwZqM1ptX6E15A5LAmyZTB', 'input': {'query': 'weather in san francisco'}, 'name': 'tavily_search_results_json', 'type': 'tool_use'}], 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-e5d17791-4d37-4ad2-815f-a0c4cba62585', 'example': False, 'tool_calls': [{'name': 'tavily_search_results_json', 'args': {'query': 'weather in san francisco'}, 'id': 'toolu_01HwZqM1ptX6E15A5LAmyZTB'}], 'invalid_tool_calls': []}]}}
-    
-    
-    
-    Receiving new event of type: end...
-    None
-    
-    
-    
-

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

@@ -1,276 +0,0 @@
-# How to Edit State of a Deployed Graph
-
-When creating LangGraph agents, it is often nice to add a human-in-the-loop component. This can be helpful when giving them access to tools. Often in these situations you may want to edit the graph state before continuing (for example, to edit what tool is being called, or how it is being called).
-
-This can be in several ways, but the primary supported way is to add an "interrupt" before a node is executed. This interrupts execution at that node. You can then use update_state to update the state, and then resume from that spot to continue.
-
-## Setup
-
-We are not going to show the full code for the graph we are hosting, but you can see it [here](../../how-tos/human_in_the_loop/edit-graph-state.ipynb#build-the-agent) if you want to. Once this graph is hosted, we are ready to invoke it and wait for user input. 
-
-### SDK initialization
-
-First, we need to setup our client so that we can communicate with our hosted graph:
-
-
-=== "Python"
-
-    ```python
-    from langgraph_sdk import get_client
-    client = get_client(url=<DEPLOYMENT_URL>)
-    # Using the graph deployed with the name "agent"
-    assistant_id = "agent"
-    thread = await client.threads.create()
-    ```
-
-=== "Javascript"
-
-    ```js
-    import { Client } from "@langchain/langgraph-sdk";
-
-    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
-    // Using the graph deployed with the name "agent"
-    const assistantId = "agent";
-    const thread = await client.threads.create();
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-      --url <DEPLOYMENT_URL>/threads \
-      --header 'Content-Type: application/json'
-    ```
-
-## Editing state
-
-### Initial invocation
-
-Now let's invoke our graph, making sure to interrupt before the `action` node.
-
-=== "Python"
-
-    ```python
-    input = { 'messages':[{ "role":"user", "content":"search for weather in SF" }] }
-
-    async for chunk in client.runs.stream(
-        thread["thread_id"],
-        assistant_id,
-        input=input,
-        stream_mode="updates",
-        interrupt_before=["action"],
-    ):
-        if chunk.data and chunk.event != "metadata": 
-            print(chunk.data)
-    ```
-
-=== "Javascript"
-
-    ```js
-    const input = { messages: [{ role: "human", content: "search for weather in SF" }] };
-
-    const streamResponse = client.runs.stream(
-      thread["thread_id"],
-      assistantId,
-      {
-        input: input,
-        streamMode: "updates",
-        interruptBefore: ["action"],
-      }
-    );
-
-    for await (const chunk of streamResponse) {
-      if (chunk.data && chunk.event !== "metadata") {
-        console.log(chunk.data);
-      }
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-     --header 'Content-Type: application/json' \
-     --data "{
-       \"assistant_id\": \"agent\",
-       \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"search for weather in SF\"}]},
-       \"interrupt_before\": [\"action\"],
-       \"stream_mode\": [
-         \"updates\"
-       ]
-     }" | \
-     sed 's/\r$//' | \
-     awk '
-     /^event:/ {
-         if (data_content != "" && event_type != "metadata") {
-             print data_content "\n"
-         }
-         sub(/^event: /, "", $0)
-         event_type = $0
-         data_content = ""
-     }
-     /^data:/ {
-         sub(/^data: /, "", $0)
-         data_content = $0
-     }
-     END {
-         if (data_content != "" && event_type != "metadata") {
-             print data_content "\n"
-         }
-     }
-     '
-    ```
-
-Output:
-
-    {'agent': {'messages': [{'content': [{'text': "Certainly! I'll search for the current weather in San Francisco for you using the search function. Here's how I'll do that:", 'type': 'text'}, {'id': 'toolu_01KEJMBFozSiZoS4mAcPZeqQ', 'input': {'query': 'current weather in San Francisco'}, 'name': 'search', 'type': 'tool_use'}], 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-6dbb0167-f8f6-4e2a-ab68-229b2d1fbb64', 'example': False, 'tool_calls': [{'name': 'search', 'args': {'query': 'current weather in San Francisco'}, 'id': 'toolu_01KEJMBFozSiZoS4mAcPZeqQ'}], 'invalid_tool_calls': [], 'usage_metadata': None}]}}
-
-
-### Edit the state
-
-Now, let's assume we actually meant to search for the weather in Sidi Frej (another city with the initials SF). We can edit the state to properly reflect that:
-
-
-=== "Python"
-
-    ```python
-    # First, lets get the current state
-    current_state = await client.threads.get_state(thread['thread_id'])
-
-    # Let's now get the last message in the state
-    # This is the one with the tool calls that we want to update
-    last_message = current_state['values']['messages'][-1]
-
-    # Let's now update the args for that tool call
-    last_message['tool_calls'][0]['args'] = {'query': 'current weather in Sidi Frej'}
-
-    # Let's now call `update_state` to pass in this message in the `messages` key
-    # This will get treated as any other update to the state
-    # It will get passed to the reducer function for the `messages` key
-    # That reducer function will use the ID of the message to update it
-    # It's important that it has the right ID! Otherwise it would get appended
-    # as a new message
-    await client.threads.update_state(thread['thread_id'], {"messages": last_message})
-    ```
-
-=== "Javascript"
-
-    ```js
-    // First, let's get the current state
-    const currentState = await client.threads.getState(thread["thread_id"]);
-
-    // Let's now get the last message in the state
-    // This is the one with the tool calls that we want to update
-    let lastMessage = currentState.values.messages.slice(-1)[0];
-
-    // Let's now update the args for that tool call
-    lastMessage.tool_calls[0].args = { query: "current weather in Sidi Frej" };
-
-    // Let's now call `update_state` to pass in this message in the `messages` key
-    // This will get treated as any other update to the state
-    // It will get passed to the reducer function for the `messages` key
-    // That reducer function will use the ID of the message to update it
-    // It's important that it has the right ID! Otherwise it would get appended
-    // as a new message
-    await client.threads.updateState(thread["thread_id"], { values: { messages: lastMessage } });
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request GET --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state | \                                                                                      
-    jq '.values.messages[-1] | (.tool_calls[0].args = {"query": "current weather in Sidi Frej"})' | \
-    curl --request POST \
-      --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state \
-      --header 'Content-Type: application/json' \
-      --data @-
-    ```
-
-Output:
-
-    {'configurable': {'thread_id': '9c8f1a43-9dd8-4017-9271-2c53e57cf66a',
-      'checkpoint_ns': '',
-      'checkpoint_id': '1ef58e7e-3641-649f-8002-8b4305a64858'}}
-
-
-
-### Resume invocation
-
-Now we can resume our graph run but with the updated state:
-
-
-=== "Python"
-
-    ```python
-    async for chunk in client.runs.stream(
-        thread["thread_id"],
-        assistant_id,
-        input=None,
-        stream_mode="updates",
-    ):
-        if chunk.data and chunk.event != "metadata": 
-            print(chunk.data)
-    ```
-=== "Javascript"
-
-    ```js
-    const streamResponse = client.runs.stream(
-      thread["thread_id"],
-      assistantId,
-      {
-        input: null,
-        streamMode: "updates",
-      }
-    );
-
-    for await (const chunk of streamResponse) {
-      if (chunk.data && chunk.event !== "metadata") {
-        console.log(chunk.data);
-      }
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \                                                                             
-     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-     --header 'Content-Type: application/json' \
-     --data "{
-       \"assistant_id\": \"agent\",
-       \"stream_mode\": [
-         \"updates\"
-       ]
-     }"| \ 
-     sed 's/\r$//' | \
-     awk '
-     /^event:/ {
-         if (data_content != "" && event_type != "metadata") {
-             print data_content "\n"
-         }
-         sub(/^event: /, "", $0)
-         event_type = $0
-         data_content = ""
-     }
-     /^data:/ {
-         sub(/^data: /, "", $0)
-         data_content = $0
-     }
-     END {
-         if (data_content != "" && event_type != "metadata") {
-             print data_content "\n"
-         }
-     }
-     '
-    ```
-
-Output:
-
-    {'action': {'messages': [{'content': '["I looked up: current weather in Sidi Frej. Result: It\'s sunny in San Francisco, but you better look out if you\'re a Gemini 😈."]', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': 'search', 'id': '1161b8d1-bee4-4188-9be8-698aecb69f10', 'tool_call_id': 'toolu_01KEJMBFozSiZoS4mAcPZeqQ'}]}}
-    {'agent': {'messages': [{'content': [{'text': 'I apologize for the confusion in my search query. It seems the search function interpreted "SF" as "Sidi Frej" instead of "San Francisco" as we intended. Let me search again with the full city name to get the correct information:', 'type': 'text'}, {'id': 'toolu_0111rrwgfAcmurHZn55qjqTR', 'input': {'query': 'current weather in San Francisco'}, 'name': 'search', 'type': 'tool_use'}], 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-b8c25779-cfb4-46fc-a421-48553551242f', 'example': False, 'tool_calls': [{'name': 'search', 'args': {'query': 'current weather in San Francisco'}, 'id': 'toolu_0111rrwgfAcmurHZn55qjqTR'}], 'invalid_tool_calls': [], 'usage_metadata': None}]}}
-    {'action': {'messages': [{'content': '["I looked up: current weather in San Francisco. Result: It\'s sunny in San Francisco, but you better look out if you\'re a Gemini 😈."]', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': 'search', 'id': '6bc632ae-5ee6-4d01-9532-79c524a2d443', 'tool_call_id': 'toolu_0111rrwgfAcmurHZn55qjqTR'}]}}
-    {'agent': {'messages': [{'content': "Now, based on the search results, I can provide you with information about the current weather in San Francisco:\n\nThe weather in San Francisco is currently sunny. \n\nIt's worth noting that the search result included an unusual comment about Gemini, which doesn't seem directly related to the weather. This might be due to the search engine including some astrological information or a joke in its results. However, for the purpose of weather information, we can focus on the fact that it's sunny in San Francisco right now.\n\nIs there anything else you'd like to know about the weather in San Francisco or any other location?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-227a042b-dd97-476e-af32-76a3703af5d8', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}}
-
-
-As you can see it now looks up the current weather in Sidi Frej (although our dummy search node still returns results for SF because we don't actually do a search in this example, we just return the same "It's sunny in San Francisco ..." result every time).

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

@@ -1,889 +0,0 @@
-# Review Tool Calls
-
-Human-in-the-loop (HIL) interactions are crucial for [agentic systems](https://langchain-ai.github.io/langgraph/concepts/agentic_concepts/#human-in-the-loop). A common pattern is to add some human in the loop step after certain tool calls. These tool calls often lead to either a function call or saving of some information. Examples include:
-
-- A tool call to execute SQL, which will then be run by the tool
-- A tool call to generate a summary, which will then be saved to the State of the graph
-
-Note that using tool calls is common **whether actually calling tools or not**.
-
-There are typically a few different interactions you may want to do here:
-
-1. Approve the tool call and continue
-2. Modify the tool call manually and then continue
-3. Give natural language feedback, and then pass that back to the agent instead of continuing
-
-We can implement this in LangGraph using a [breakpoint](https://langchain-ai.github.io/langgraph/how-tos/human_in_the_loop/breakpoints/): breakpoints allow us to interrupt graph execution before a specific step. At this breakpoint, we can manually update the graph state taking one of the three options above
-
-## Setup
-
-We are not going to show the full code for the graph we are hosting, but you can see it [here](../../how-tos/human_in_the_loop/review-tool-calls.ipynb#simple-usage) if you want to. Once this graph is hosted, we are ready to invoke it and wait for user input. 
-
-### SDK initialization
-
-First, we need to setup our client so that we can communicate with our hosted graph:
-
-
-=== "Python"
-
-    ```python
-    from langgraph_sdk import get_client
-    client = get_client(url=<DEPLOYMENT_URL>)
-    # Using the graph deployed with the name "agent"
-    assistant_id = "agent"
-    thread = await client.threads.create()
-    ```
-
-=== "Javascript"
-
-    ```js
-    import { Client } from "@langchain/langgraph-sdk";
-
-    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
-    // Using the graph deployed with the name "agent"
-    const assistantId = "agent";
-    const thread = await client.threads.create();
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-      --url <DEPLOYMENT_URL>/threads \
-      --header 'Content-Type: application/json'
-    ```
-
-## Example with no review
-
-Let's look at an example when no review is required (because no tools are called)
-
-=== "Python"
-
-    ```python
-    input = { 'messages':[{ "role":"user", "content":"hi!" }] }
-
-    async for chunk in client.runs.stream(
-        thread["thread_id"],
-        assistant_id,
-        input=input,
-        stream_mode="updates",
-        interrupt_before=["action"],
-    ):
-        if chunk.data and chunk.event != "metadata": 
-            print(chunk.data)
-    ```
-
-=== "Javascript"
-
-    ```js
-    const input = { "messages": [{ "role": "human", "content": "hi!" }] };
-
-    const streamResponse = client.runs.stream(
-      thread["thread_id"],
-      assistantId,
-      {
-        input: input,
-        streamMode: "updates",
-        interruptBefore: ["action"],
-      }
-    );
-
-    for await (const chunk of streamResponse) {
-      if (chunk.data && chunk.event !== "metadata") {
-        console.log(chunk.data);
-      }
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-     --header 'Content-Type: application/json' \
-     --data "{
-       \"assistant_id\": \"agent\",
-       \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"hi!\"}]},
-       \"stream_mode\": [
-         \"updates\"
-       ],
-       \"interrupt_before\": [\"action\"]
-     }" | \
-     sed 's/\r$//' | \
-     awk '
-     /^event:/ {
-         if (data_content != "" && event_type != "metadata") {
-             print data_content "\n"
-         }
-         sub(/^event: /, "", $0)
-         event_type = $0
-         data_content = ""
-     }
-     /^data:/ {
-         sub(/^data: /, "", $0)
-         data_content = $0
-     }
-     END {
-         if (data_content != "" && event_type != "metadata") {
-             print data_content "\n"
-         }
-     }
-     '
-    ```
-
-Output:
-
-    {'messages': [{'content': 'hi!', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '39c51f14-2d5c-4690-883a-d940854b1845', 'example': False}]}
-    {'messages': [{'content': 'hi!', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '39c51f14-2d5c-4690-883a-d940854b1845', 'example': False}, {'content': [{'text': "Hello! Welcome. How can I assist you today? Is there anything specific you'd like to know or any information you're looking for?", 'type': 'text', 'index': 0}], 'additional_kwargs': {}, 'response_metadata': {'stop_reason': 'end_turn', 'stop_sequence': None}, 'type': 'ai', 'name': None, 'id': 'run-d65e07fb-43ff-4d98-ab6b-6316191b9c8b', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': {'input_tokens': 355, 'output_tokens': 31, 'total_tokens': 386}}]}
-
-
-If we check the state, we can see that it is finished
-
-=== "Python"
-
-    ```python
-    state = await client.threads.get_state(thread["thread_id"])
-
-    print(state['next'])
-    ```
-
-=== "Javascript"
-
-    ```js
-    const state = await client.threads.getState(thread["thread_id"]);
-
-    console.log(state.next);
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request GET \
-        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state | jq -c '.next'
-    ```
-
-Output:
-
-    []
-
-## Example of approving tool
-
-Let's now look at what it looks like to approve a tool call. Note that we don't need to pass an interrupt to our streaming calls because the graph (defined [here](../../how-tos/human_in_the_loop/review-tool-calls.ipynb#simple-usage)) was already compiled with an interrupt before the `human_review_node`.
-
-=== "Python"
-
-    ```python
-    input = {"messages": [{"role": "user", "content": "what's the weather in sf?"}]}
-
-    async for chunk in client.runs.stream(
-        thread["thread_id"],
-        "agent",
-        input=input,
-    ):
-        if chunk.data and chunk.event != "metadata": 
-            print(chunk.data)
-    ```
-
-=== "Javascript"
-
-    ```js
-    const input = { "messages": [{ "role": "user", "content": "what's the weather in sf?" }] };
-
-    const streamResponse = client.runs.stream(
-      thread["thread_id"],
-      assistantId,
-      {
-        input: input,
-      }
-    );
-
-    for await (const chunk of streamResponse) {
-      if (chunk.data && chunk.event !== "metadata") {
-        console.log(chunk.data);
-      }
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-     --header 'Content-Type: application/json' \
-     --data "{
-       \"assistant_id\": \"agent\",
-       \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"what's the weather in sf?\"}]}
-     }" | \
-     sed 's/\r$//' | \
-     awk '
-     /^event:/ {
-         if (data_content != "" && event_type != "metadata") {
-             print data_content "\n"
-         }
-         sub(/^event: /, "", $0)
-         event_type = $0
-         data_content = ""
-     }
-     /^data:/ {
-         sub(/^data: /, "", $0)
-         data_content = $0
-     }
-     END {
-         if (data_content != "" && event_type != "metadata") {
-             print data_content "\n"
-         }
-     }
-     '
-    ```
-
-Output:
-
-    {'messages': [{'content': "what's the weather in sf?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '54e19d6e-89fa-44fb-b92c-12e7dd4ddf08', 'example': False}]}
-    {'messages': [{'content': "what's the weather in sf?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '54e19d6e-89fa-44fb-b92c-12e7dd4ddf08', 'example': False}, {'content': [{'text': "Certainly! I can help you check the weather in San Francisco. To get this information, I'll use the weather search function. Let me do that for you right away.", 'type': 'text', 'index': 0}, {'id': 'toolu_015yrR3GMDXe6X8m2p9CsEDN', 'input': {}, 'name': 'weather_search', 'type': 'tool_use', 'index': 1, 'partial_json': '{"city": "San Francisco"}'}], 'additional_kwargs': {}, 'response_metadata': {'stop_reason': 'tool_use', 'stop_sequence': None}, 'type': 'ai', 'name': None, 'id': 'run-45a6b6c3-ac69-42a4-8957-d982203d6392', 'example': False, 'tool_calls': [{'name': 'weather_search', 'args': {'city': 'San Francisco'}, 'id': 'toolu_015yrR3GMDXe6X8m2p9CsEDN', 'type': 'tool_call'}], 'invalid_tool_calls': [], 'usage_metadata': {'input_tokens': 360, 'output_tokens': 90, 'total_tokens': 450}}]}
-
-
-If we now check, we can see that it is waiting on human review:
-
-=== "Python"
-
-    ```python
-    state = await client.threads.get_state(thread["thread_id"])
-
-    print(state['next'])
-    ```
-
-=== "Javascript"
-
-    ```js
-    const state = await client.threads.getState(thread["thread_id"]);
-
-    console.log(state.next);
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request GET \
-        --url <DELPOYMENT_URL>/threads/<THREAD_ID>/state | jq -c '.next'
-    ```
-
-Output:
-
-    ['human_review_node']
-
-To approve the tool call, we can just continue the thread with no edits. To do this, we just create a new run with no inputs.
-
-=== "Python"
-
-    ```python
-    async for chunk in client.runs.stream(
-        thread["thread_id"],
-        "agent",
-        input=None,
-        stream_mode="values",
-    ):
-        if chunk.data and chunk.event != "metadata": 
-            print(chunk.data)
-    ```
-
-=== "Javascript"
-
-    ```js
-    const streamResponse = client.runs.stream(
-      thread["thread_id"],
-      assistantId,
-      {
-        input: null,
-        streamMode: "values",
-      }
-    );
-
-    for await (const chunk of streamResponse) {
-      if (chunk.data && chunk.event !== "metadata") {
-        console.log(chunk.data);
-      }
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-     --header 'Content-Type: application/json' \
-     --data "{
-       \"assistant_id\": \"agent\"
-     }" | \
-     sed 's/\r$//' | \
-     awk '
-     /^event:/ {
-         if (data_content != "" && event_type != "metadata") {
-             print data_content "\n"
-         }
-         sub(/^event: /, "", $0)
-         event_type = $0
-         data_content = ""
-     }
-     /^data:/ {
-         sub(/^data: /, "", $0)
-         data_content = $0
-     }
-     END {
-         if (data_content != "" && event_type != "metadata") {
-             print data_content "\n"
-         }
-     }
-     '
-    ```
-
-Output:
-
-    {'messages': [{'content': "what's the weather in sf?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '54e19d6e-89fa-44fb-b92c-12e7dd4ddf08', 'example': False}, {'content': [{'text': "Certainly! I can help you check the weather in San Francisco. To get this information, I'll use the weather search function. Let me do that for you right away.", 'type': 'text', 'index': 0}, {'id': 'toolu_015yrR3GMDXe6X8m2p9CsEDN', 'input': {}, 'name': 'weather_search', 'type': 'tool_use', 'index': 1, 'partial_json': '{"city": "San Francisco"}'}], 'additional_kwargs': {}, 'response_metadata': {'stop_reason': 'tool_use', 'stop_sequence': None}, 'type': 'ai', 'name': None, 'id': 'run-45a6b6c3-ac69-42a4-8957-d982203d6392', 'example': False, 'tool_calls': [{'name': 'weather_search', 'args': {'city': 'San Francisco'}, 'id': 'toolu_015yrR3GMDXe6X8m2p9CsEDN', 'type': 'tool_call'}], 'invalid_tool_calls': [], 'usage_metadata': {'input_tokens': 360, 'output_tokens': 90, 'total_tokens': 450}}, {'content': 'Sunny!', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': 'weather_search', 'id': '826cd0f2-9cc6-46f0-b7df-daa6a05d13d2', 'tool_call_id': 'toolu_015yrR3GMDXe6X8m2p9CsEDN', 'artifact': None, 'status': 'success'}]}
-    {'messages': [{'content': "what's the weather in sf?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '54e19d6e-89fa-44fb-b92c-12e7dd4ddf08', 'example': False}, {'content': [{'text': "Certainly! I can help you check the weather in San Francisco. To get this information, I'll use the weather search function. Let me do that for you right away.", 'type': 'text', 'index': 0}, {'id': 'toolu_015yrR3GMDXe6X8m2p9CsEDN', 'input': {}, 'name': 'weather_search', 'type': 'tool_use', 'index': 1, 'partial_json': '{"city": "San Francisco"}'}], 'additional_kwargs': {}, 'response_metadata': {'stop_reason': 'tool_use', 'stop_sequence': None}, 'type': 'ai', 'name': None, 'id': 'run-45a6b6c3-ac69-42a4-8957-d982203d6392', 'example': False, 'tool_calls': [{'name': 'weather_search', 'args': {'city': 'San Francisco'}, 'id': 'toolu_015yrR3GMDXe6X8m2p9CsEDN', 'type': 'tool_call'}], 'invalid_tool_calls': [], 'usage_metadata': {'input_tokens': 360, 'output_tokens': 90, 'total_tokens': 450}}, {'content': 'Sunny!', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': 'weather_search', 'id': '826cd0f2-9cc6-46f0-b7df-daa6a05d13d2', 'tool_call_id': 'toolu_015yrR3GMDXe6X8m2p9CsEDN', 'artifact': None, 'status': 'success'}, {'content': [{'text': "\n\nGreat news! The weather in San Francisco is sunny today. It's a beautiful day in the city by the bay. Is there anything else you'd like to know about the weather or any other information I can help you with?", 'type': 'text', 'index': 0}], 'additional_kwargs': {}, 'response_metadata': {'stop_reason': 'end_turn', 'stop_sequence': None}, 'type': 'ai', 'name': None, 'id': 'run-5d5fd0f1-a939-447e-801a-9aaa812322d3', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': {'input_tokens': 464, 'output_tokens': 50, 'total_tokens': 514}}]}
-
-## Edit Tool Call
-
-Let's now say we want to edit the tool call. E.g. change some of the parameters (or even the tool called!) but then execute that tool.
-
-=== "Python"
-
-    ```python
-    input = {"messages": [{"role": "user", "content": "what's the weather in sf?"}]}
-
-    async for chunk in client.runs.stream(
-        thread["thread_id"],
-        "agent",
-        input=input,
-        stream_mode="values",
-    ):
-        if chunk.data and chunk.event != "metadata": 
-            print(chunk.data)
-    ```
-
-=== "Javascript"
-
-    ```js
-    const input = { "messages": [{ "role": "user", "content": "what's the weather in sf?" }] };
-
-    const streamResponse = client.runs.stream(
-      thread["thread_id"],
-      assistantId,
-      {
-        input: input,
-        streamMode: "values",
-      }
-    );
-
-    for await (const chunk of streamResponse) {
-      if (chunk.data && chunk.event !== "metadata") {
-        console.log(chunk.data);
-      }
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-     --header 'Content-Type: application/json' \
-     --data "{
-       \"assistant_id\": \"agent\",
-       \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"what's the weather in sf?\"}]}
-     }" | \
-     sed 's/\r$//' | \
-     awk '
-     /^event:/ {
-         if (data_content != "" && event_type != "metadata") {
-             print data_content "\n"
-         }
-         sub(/^event: /, "", $0)
-         event_type = $0
-         data_content = ""
-     }
-     /^data:/ {
-         sub(/^data: /, "", $0)
-         data_content = $0
-     }
-     END {
-         if (data_content != "" && event_type != "metadata") {
-             print data_content "\n"
-         }
-     }
-     '
-    ```
-
-Output:
-
-    {'messages': [{'content': "what's the weather in sf?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'cec11391-84da-464b-bd2a-bd4f0d93b9ee', 'example': False}]}
-    {'messages': [{'content': "what's the weather in sf?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'cec11391-84da-464b-bd2a-bd4f0d93b9ee', 'example': False}, {'content': [{'text': 'To get the weather information for San Francisco, I can use the weather_search function. Let me do that for you.', 'type': 'text', 'index': 0}, {'id': 'toolu_01SunSpDurNfcnXppWLPrtjC', 'input': {}, 'name': 'weather_search', 'type': 'tool_use', 'index': 1, 'partial_json': '{"city": "San Francisco"}'}], 'additional_kwargs': {}, 'response_metadata': {'stop_reason': 'tool_use', 'stop_sequence': None}, 'type': 'ai', 'name': None, 'id': 'run-6326da9f-6061-4e12-8586-482e32ab4cab', 'example': False, 'tool_calls': [{'name': 'weather_search', 'args': {'city': 'San Francisco'}, 'id': 'toolu_01SunSpDurNfcnXppWLPrtjC', 'type': 'tool_call'}], 'invalid_tool_calls': [], 'usage_metadata': {'input_tokens': 360, 'output_tokens': 80, 'total_tokens': 440}}]}
-
-
-To do this, we first need to update the state. We can do this by passing a message in with the **same** id of the message we want to overwrite. This will have the effect of **replacing** that old message. Note that this is only possible because of the **reducer** we are using that replaces messages with the same ID - read more about that [here](https://langchain-ai.github.io/langgraph/concepts/low_level/#working-with-messages-in-graph-state).
-
-
-=== "Python"
-
-    ```python
-    # To get the ID of the message we want to replace, we need to fetch the current state and find it there.
-    state = await client.threads.get_state(thread['thread_id'])
-    print("Current State:")
-    print(state['values'])
-    print("\nCurrent Tool Call ID:")
-    current_content = state['values']['messages'][-1]['content']
-    current_id = state['values']['messages'][-1]['id']
-    tool_call_id = state['values']['messages'][-1]['tool_calls'][0]['id']
-    print(tool_call_id)
-
-    # We now need to construct a replacement tool call.
-    # We will change the argument to be `San Francisco, USA`
-    # Note that we could change any number of arguments or tool names - it just has to be a valid one
-    new_message = {
-        "role": "assistant", 
-        "content": current_content,
-        "tool_calls": [
-            {
-                "id": tool_call_id,
-                "name": "weather_search",
-                "args": {"city": "San Francisco, USA"}
-            }
-        ],
-        # This is important - this needs to be the same as the message you replacing!
-        # Otherwise, it will show up as a separate message
-        "id": current_id
-    }
-    await client.threads.update_state(
-        # This is the config which represents this thread
-        thread['thread_id'], 
-        # This is the updated value we want to push
-        {"messages": [new_message]}, 
-        # We push this update acting as our human_review_node
-        as_node="human_review_node"
-    )
-
-    print("\nResuming Execution")
-    # Let's now continue executing from here
-    async for chunk in client.runs.stream(
-        thread["thread_id"],
-        "agent",
-        input=None,
-    ):
-        if chunk.data and chunk.event != "metadata": 
-            print(chunk.data)
-    ```
-
-=== "Javascript"
-
-    ```js
-    const state = await client.threads.getState(thread.thread_id);
-    console.log("Current State:");
-    console.log(state.values);
-
-    console.log("\nCurrent Tool Call ID:");
-    const lastMessage = state.values.messages[state.values.messages.length - 1];
-    const currentContent = lastMessage.content;
-    const currentId = lastMessage.id;
-    const toolCallId = lastMessage.tool_calls[0].id;
-    console.log(toolCallId);
-
-    // Construct a replacement tool call
-    const newMessage = {
-      role: "assistant",
-      content: currentContent,
-      tool_calls: [
-        {
-          id: toolCallId,
-          name: "weather_search",
-          args: { city: "San Francisco, USA" }
-        }
-      ],
-      // Ensure the ID is the same as the message you're replacing
-      id: currentId
-    };
-
-    await client.threads.updateState(
-      thread.thread_id,  // Thread ID
-      {
-        values: { "messages": [newMessage] },  // Updated message
-        asNode: "human_review_node"
-      }  // Acting as human_review_node
-    );
-
-    console.log("\nResuming Execution");
-    // Continue executing from here
-    const streamResponseResumed = client.runs.stream(
-      thread["thread_id"],
-      assistantId,
-      {
-        input: null,
-      }
-    );
-
-    for await (const chunk of streamResponseResumed) {
-      if (chunk.data && chunk.event !== "metadata") {
-        console.log(chunk.data);
-      }
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-    --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state \
-    --header 'Content-Type: application/json' \
-    --data "{
-        \"values\": { \"messages\": [$(curl --request GET \
-            --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state |
-            jq -c '{
-            role: "assistant",
-            content: .values.messages[-1].content,
-            tool_calls: [
-                {
-                id: .values.messages[-1].tool_calls[0].id,
-                name: "weather_search",
-                args: { city: "San Francisco, USA" }
-                }
-            ],
-            id: .values.messages[-1].id
-            }')
-        ]},
-        \"as_node\": \"human_review_node\"
-    }" && echo "Resuming Execution" && curl --request POST \
-    --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-    --header 'Content-Type: application/json' \
-    --data '{
-    "assistant_id": "agent"
-    }' | \
-    sed 's/\r$//' | \
-    awk '
-    /^event:/ {
-        if (data_content != "" && event_type != "metadata") {
-            print data_content "\n"
-        }
-        sub(/^event: /, "", $0)
-        event_type = $0
-        data_content = ""
-    }
-    /^data:/ {
-        sub(/^data: /, "", $0)
-        data_content = $0
-    }
-    END {
-        if (data_content != "" && event_type != "metadata") {
-            print data_content "\n"
-        }
-    }
-    '
-    ```
-
-Output:
-
-    Current State:
-    {'messages': [{'content': "what's the weather in sf?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '8713d1fa-9b26-4eab-b768-dafdaac70590', 'example': False}, {'content': [{'text': 'To get the weather information for San Francisco, I can use the weather_search function. Let me do that for you.', 'type': 'text', 'index': 0}, {'id': 'toolu_01VzagzsUGZsNMwW1wHkcw7h', 'input': {}, 'name': 'weather_search', 'type': 'tool_use', 'index': 1, 'partial_json': '{"city": "San Francisco"}'}], 'additional_kwargs': {}, 'response_metadata': {'stop_reason': 'tool_use', 'stop_sequence': None}, 'type': 'ai', 'name': None, 'id': 'run-ede13f26-daf5-4d8f-817a-7611075bbcf1', 'example': False, 'tool_calls': [{'name': 'weather_search', 'args': {'city': 'San Francisco'}, 'id': 'toolu_01VzagzsUGZsNMwW1wHkcw7h', 'type': 'tool_call'}], 'invalid_tool_calls': [], 'usage_metadata': {'input_tokens': 360, 'output_tokens': 80, 'total_tokens': 440}}]}
-
-    Current Tool Call ID:
-    toolu_01VzagzsUGZsNMwW1wHkcw7h
-
-    Resuming Execution
-    {'messages': [{'content': "what's the weather in sf?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '8713d1fa-9b26-4eab-b768-dafdaac70590', 'example': False}, {'content': [{'text': 'To get the weather information for San Francisco, I can use the weather_search function. Let me do that for you.', 'type': 'text', 'index': 0}, {'id': 'toolu_01VzagzsUGZsNMwW1wHkcw7h', 'input': {}, 'name': 'weather_search', 'type': 'tool_use', 'index': 1, 'partial_json': '{"city": "San Francisco"}'}], 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-ede13f26-daf5-4d8f-817a-7611075bbcf1', 'example': False, 'tool_calls': [{'name': 'weather_search', 'args': {'city': 'San Francisco, USA'}, 'id': 'toolu_01VzagzsUGZsNMwW1wHkcw7h', 'type': 'tool_call'}], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'Sunny!', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': 'weather_search', 'id': '7fc7d463-66bf-4555-9929-6af483de169b', 'tool_call_id': 'toolu_01VzagzsUGZsNMwW1wHkcw7h', 'artifact': None, 'status': 'success'}]}
-    {'messages': [{'content': "what's the weather in sf?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '8713d1fa-9b26-4eab-b768-dafdaac70590', 'example': False}, {'content': [{'text': 'To get the weather information for San Francisco, I can use the weather_search function. Let me do that for you.', 'type': 'text', 'index': 0}, {'id': 'toolu_01VzagzsUGZsNMwW1wHkcw7h', 'input': {}, 'name': 'weather_search', 'type': 'tool_use', 'index': 1, 'partial_json': '{"city": "San Francisco"}'}], 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-ede13f26-daf5-4d8f-817a-7611075bbcf1', 'example': False, 'tool_calls': [{'name': 'weather_search', 'args': {'city': 'San Francisco, USA'}, 'id': 'toolu_01VzagzsUGZsNMwW1wHkcw7h', 'type': 'tool_call'}], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'Sunny!', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': 'weather_search', 'id': '7fc7d463-66bf-4555-9929-6af483de169b', 'tool_call_id': 'toolu_01VzagzsUGZsNMwW1wHkcw7h', 'artifact': None, 'status': 'success'}, {'content': [{'text': "\n\nBased on the search result, the weather in San Francisco is sunny! It's a beautiful day in the city by the bay. Is there anything else you'd like to know about the weather or any other information I can help you with?", 'type': 'text', 'index': 0}], 'additional_kwargs': {}, 'response_metadata': {'stop_reason': 'end_turn', 'stop_sequence': None}, 'type': 'ai', 'name': None, 'id': 'run-d90ce97a-39f9-4330-985e-67c5f351a0c5', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': {'input_tokens': 455, 'output_tokens': 52, 'total_tokens': 507}}]}
-
-## Give feedback to a tool call
-
-Sometimes, you may not want to execute a tool call, but you also may not want to ask the user to manually modify the tool call. In that case it may be better to get natural language feedback from the user. You can then insert these feedback as a mock **RESULT** of the tool call.
-
-There are multiple ways to do this:
-
-You could add a new message to the state (representing the "result" of a tool call)
-You could add TWO new messages to the state - one representing an "error" from the tool call, other HumanMessage representing the feedback
-Both are similar in that they involve adding messages to the state. The main difference lies in the logic AFTER the `human_node` and how it handles different types of messages.
-
-For this example we will just add a single tool call representing the feedback. Let's see this in action!
-
-=== "Python"
-
-    ```python
-    input = {"messages": [{"role": "user", "content": "what's the weather in sf?"}]}
-
-    async for chunk in client.runs.stream(
-        thread["thread_id"],
-        "agent",
-        input=input,
-    ):
-        if chunk.data and chunk.event != "metadata": 
-            print(chunk.data)
-    ```
-
-=== "Javascript"
-
-    ```js
-    const input = { "messages": [{ "role": "user", "content": "what's the weather in sf?" }] };
-
-    const streamResponse = client.runs.stream(
-      thread["thread_id"],
-      assistantId,
-      {
-        input: input,
-      }
-    );
-
-    for await (const chunk of streamResponse) {
-      if (chunk.data && chunk.event !== "metadata") {
-        console.log(chunk.data);
-      }
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-     --header 'Content-Type: application/json' \
-     --data "{
-       \"assistant_id\": \"agent\",
-       \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"what's the weather in sf?\"}]}
-     }" | \
-     sed 's/\r$//' | \
-     awk '
-     /^event:/ {
-         if (data_content != "" && event_type != "metadata") {
-             print data_content "\n"
-         }
-         sub(/^event: /, "", $0)
-         event_type = $0
-         data_content = ""
-     }
-     /^data:/ {
-         sub(/^data: /, "", $0)
-         data_content = $0
-     }
-     END {
-         if (data_content != "" && event_type != "metadata") {
-             print data_content "\n"
-         }
-     }
-     '
-    ```
-
-Output:
-
-    {'messages': [{'content': "what's the weather in sf?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'c80f13d0-674d-4233-b6a0-3940509d3cf3', 'example': False}]}
-    {'messages': [{'content': "what's the weather in sf?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'c80f13d0-674d-4233-b6a0-3940509d3cf3', 'example': False}, {'content': [{'text': 'To get the weather information for San Francisco, I can use the weather_search function. Let me do that for you.', 'type': 'text', 'index': 0}, {'id': 'toolu_016XyTdFA8NuPWeLyZPSzoM3', 'input': {}, 'name': 'weather_search', 'type': 'tool_use', 'index': 1, 'partial_json': '{"city": "San Francisco"}'}], 'additional_kwargs': {}, 'response_metadata': {'stop_reason': 'tool_use', 'stop_sequence': None}, 'type': 'ai', 'name': None, 'id': 'run-4911ac27-3d7c-4edf-a3ca-c2908e3922eb', 'example': False, 'tool_calls': [{'name': 'weather_search', 'args': {'city': 'San Francisco'}, 'id': 'toolu_016XyTdFA8NuPWeLyZPSzoM3', 'type': 'tool_call'}], 'invalid_tool_calls': [], 'usage_metadata': {'input_tokens': 360, 'output_tokens': 80, 'total_tokens': 440}}]}
-
-To do this, we first need to update the state. We can do this by passing a message in with the same **tool call id** of the tool call we want to respond to. Note that this is a **different*** ID from above
-
-=== "Python"
-
-    ```python
-    # To get the ID of the message we want to replace, we need to fetch the current state and find it there.
-    state = await client.threads.get_state(thread['thread_id'])
-    print("Current State:")
-    print(state['values'])
-    print("\nCurrent Tool Call ID:")
-    tool_call_id = state['values']['messages'][-1]['tool_calls'][0]['id']
-    print(tool_call_id)
-
-    # We now need to construct a replacement tool call.
-    # We will change the argument to be `San Francisco, USA`
-    # Note that we could change any number of arguments or tool names - it just has to be a valid one
-    new_message = {
-        "role": "tool", 
-        # This is our natural language feedback
-        "content": "User requested changes: pass in the country as well",
-        "name": "weather_search",
-        "tool_call_id": tool_call_id
-    }
-    await client.threads.update_state(
-        # This is the config which represents this thread
-        thread['thread_id'], 
-        # This is the updated value we want to push
-        {"messages": [new_message]}, 
-        # We push this update acting as our human_review_node
-        as_node="human_review_node"
-    )
-
-    print("\nResuming execution")
-    # Let's now continue executing from here
-    async for chunk in client.runs.stream(
-        thread["thread_id"],
-        "agent",
-        input=None,
-        stream_mode="values",
-    ):
-        if chunk.data and chunk.event != "metadata": 
-            print(chunk.data)
-    ```
-
-=== "Javascript"
-
-    ```js
-    const state = await client.threads.getState(thread.thread_id);
-    console.log("Current State:");
-    console.log(state.values);
-
-    console.log("\nCurrent Tool Call ID:");
-    const lastMessage = state.values.messages[state.values.messages.length - 1];
-    const toolCallId = lastMessage.tool_calls[0].id;
-    console.log(toolCallId);
-
-    // Construct a replacement tool call
-    const newMessage = {
-      role: "tool",
-      content: "User requested changes: pass in the country as well",
-      name: "weather_search",
-      tool_call_id: toolCallId,
-    };
-
-    await client.threads.updateState(
-      thread.thread_id,  // Thread ID
-      {
-        values: { "messages": [newMessage] },  // Updated message
-        asNode: "human_review_node"
-      }  // Acting as human_review_node
-    );
-
-    console.log("\nResuming Execution");
-    // Continue executing from here
-    const streamResponseEdited = client.runs.stream(
-      thread["thread_id"],
-      assistantId,
-      {
-        input: null,
-        streamMode: "values",
-        interruptBefore: ["action"],
-      }
-    );
-
-    for await (const chunk of streamResponseEdited) {
-      if (chunk.data && chunk.event !== "metadata") {
-        console.log(chunk.data);
-      }
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-    --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state \
-    --header 'Content-Type: application/json' \
-    --data "{
-        \"values\": { \"messages\": [$(curl --request GET \
-            --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state |
-            jq -c '{
-            role: "tool",
-            content: "User requested changes: pass in the country as well",
-            name: "get_weather",
-            tool_call_id: .values.messages[-1].id.tool_calls[0].id
-            }')
-        ]},
-        \"as_node\": \"human_review_node\"
-    }" && echo "Resuming Execution" && curl --request POST \
-    --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-    --header 'Content-Type: application/json' \
-    --data '{
-    "assistant_id": "agent"
-    }' | \
-    sed 's/\r$//' | \
-    awk '
-    /^event:/ {
-        if (data_content != "" && event_type != "metadata") {
-            print data_content "\n"
-        }
-        sub(/^event: /, "", $0)
-        event_type = $0
-        data_content = ""
-    }
-    /^data:/ {
-        sub(/^data: /, "", $0)
-        data_content = $0
-    }
-    END {
-        if (data_content != "" && event_type != "metadata") {
-            print data_content "\n"
-        }
-    }
-    '
-    ```
-
-
-Output:
-
-    Current State:
-    {'messages': [{'content': "what's the weather in sf?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '3b2bbc38-d11b-49eb-80c0-c24a40dab5a8', 'example': False}, {'content': [{'text': 'To get the weather information for San Francisco, I can use the weather_search function. Let me do that for you.', 'type': 'text', 'index': 0}, {'id': 'toolu_01NNw18j57GEGPZvsa9f1wvX', 'input': {}, 'name': 'weather_search', 'type': 'tool_use', 'index': 1, 'partial_json': '{"city": "San Francisco"}'}], 'additional_kwargs': {}, 'response_metadata': {'stop_reason': 'tool_use', 'stop_sequence': None}, 'type': 'ai', 'name': None, 'id': 'run-c5a50900-abf5-4885-9cdb-da2bf0d892ac', 'example': False, 'tool_calls': [{'name': 'weather_search', 'args': {'city': 'San Francisco'}, 'id': 'toolu_01NNw18j57GEGPZvsa9f1wvX', 'type': 'tool_call'}], 'invalid_tool_calls': [], 'usage_metadata': {'input_tokens': 360, 'output_tokens': 80, 'total_tokens': 440}}]}
-
-    Current Tool Call ID:
-    toolu_01NNw18j57GEGPZvsa9f1wvX
-
-    Resuming execution
-    {'messages': [{'content': "what's the weather in sf?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '3b2bbc38-d11b-49eb-80c0-c24a40dab5a8', 'example': False}, {'content': [{'text': 'To get the weather information for San Francisco, I can use the weather_search function. Let me do that for you.', 'type': 'text', 'index': 0}, {'id': 'toolu_01NNw18j57GEGPZvsa9f1wvX', 'input': {}, 'name': 'weather_search', 'type': 'tool_use', 'index': 1, 'partial_json': '{"city": "San Francisco"}'}], 'additional_kwargs': {}, 'response_metadata': {'stop_reason': 'tool_use', 'stop_sequence': None}, 'type': 'ai', 'name': None, 'id': 'run-c5a50900-abf5-4885-9cdb-da2bf0d892ac', 'example': False, 'tool_calls': [{'name': 'weather_search', 'args': {'city': 'San Francisco'}, 'id': 'toolu_01NNw18j57GEGPZvsa9f1wvX', 'type': 'tool_call'}], 'invalid_tool_calls': [], 'usage_metadata': {'input_tokens': 360, 'output_tokens': 80, 'total_tokens': 440}}, {'content': 'User requested changes: pass in the country as well', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': 'weather_search', 'id': '787288be-213c-4fd3-8503-4a009bdb1b00', 'tool_call_id': 'toolu_01NNw18j57GEGPZvsa9f1wvX', 'artifact': None, 'status': 'success'}, {'content': [{'text': '\n\nI apologize for the oversight. It seems the function requires additional information. Let me try again with a more specific request.', 'type': 'text', 'index': 0}, {'id': 'toolu_01YAbLBoKozJyRQnB8LUMpXC', 'input': {}, 'name': 'weather_search', 'type': 'tool_use', 'index': 1, 'partial_json': '{"city": "San Francisco, USA"}'}], 'additional_kwargs': {}, 'response_metadata': {'stop_reason': 'tool_use', 'stop_sequence': None}, 'type': 'ai', 'name': None, 'id': 'run-5c355a56-cfe3-4046-b49f-f5b09fc397ef', 'example': False, 'tool_calls': [{'name': 'weather_search', 'args': {'city': 'San Francisco, USA'}, 'id': 'toolu_01YAbLBoKozJyRQnB8LUMpXC', 'type': 'tool_call'}], 'invalid_tool_calls': [], 'usage_metadata': {'input_tokens': 461, 'output_tokens': 83, 'total_tokens': 544}}]}
-
-We can see that we now get to another breakpoint - because it went back to the model and got an entirely new prediction of what to call. Let's now approve this one and continue
-
-=== "Python"
-
-    ```python
-    async for chunk in client.runs.stream(
-        thread["thread_id"],
-        "agent",
-        input=None,
-    ):
-        if chunk.data and chunk.event != "metadata": 
-            print(chunk.data)
-    ```
-
-=== "Javascript"
-
-    ```js
-    const streamResponseResumed = client.runs.stream(
-      thread["thread_id"],
-      assistantId,
-      {
-        input: null,
-      }
-    );
-
-    for await (const chunk of streamResponseResumed) {
-      if (chunk.data && chunk.event !== "metadata") {
-        console.log(chunk.data);
-      }
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-     --header 'Content-Type: application/json' \
-     --data "{
-       \"assistant_id\": \"agent\"
-     }" | \
-     sed 's/\r$//' | \
-     awk '
-     /^event:/ {
-         if (data_content != "" && event_type != "metadata") {
-             print data_content "\n"
-         }
-         sub(/^event: /, "", $0)
-         event_type = $0
-         data_content = ""
-     }
-     /^data:/ {
-         sub(/^data: /, "", $0)
-         data_content = $0
-     }
-     END {
-         if (data_content != "" && event_type != "metadata") {
-             print data_content "\n"
-         }
-     }
-     '
-    ```
-
-Output:
-
-    {'messages': [{'content': "what's the weather in sf?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '3b2bbc38-d11b-49eb-80c0-c24a40dab5a8', 'example': False}, {'content': [{'text': 'To get the weather information for San Francisco, I can use the weather_search function. Let me do that for you.', 'type': 'text', 'index': 0}, {'id': 'toolu_01NNw18j57GEGPZvsa9f1wvX', 'input': {}, 'name': 'weather_search', 'type': 'tool_use', 'index': 1, 'partial_json': '{"city": "San Francisco"}'}], 'additional_kwargs': {}, 'response_metadata': {'stop_reason': 'tool_use', 'stop_sequence': None}, 'type': 'ai', 'name': None, 'id': 'run-c5a50900-abf5-4885-9cdb-da2bf0d892ac', 'example': False, 'tool_calls': [{'name': 'weather_search', 'args': {'city': 'San Francisco'}, 'id': 'toolu_01NNw18j57GEGPZvsa9f1wvX', 'type': 'tool_call'}], 'invalid_tool_calls': [], 'usage_metadata': {'input_tokens': 360, 'output_tokens': 80, 'total_tokens': 440}}, {'content': 'User requested changes: pass in the country as well', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': 'weather_search', 'id': '787288be-213c-4fd3-8503-4a009bdb1b00', 'tool_call_id': 'toolu_01NNw18j57GEGPZvsa9f1wvX', 'artifact': None, 'status': 'success'}, {'content': [{'text': '\n\nI apologize for the oversight. It seems the function requires additional information. Let me try again with a more specific request.', 'type': 'text', 'index': 0}, {'id': 'toolu_01YAbLBoKozJyRQnB8LUMpXC', 'input': {}, 'name': 'weather_search', 'type': 'tool_use', 'index': 1, 'partial_json': '{"city": "San Francisco, USA"}'}], 'additional_kwargs': {}, 'response_metadata': {'stop_reason': 'tool_use', 'stop_sequence': None}, 'type': 'ai', 'name': None, 'id': 'run-5c355a56-cfe3-4046-b49f-f5b09fc397ef', 'example': False, 'tool_calls': [{'name': 'weather_search', 'args': {'city': 'San Francisco, USA'}, 'id': 'toolu_01YAbLBoKozJyRQnB8LUMpXC', 'type': 'tool_call'}], 'invalid_tool_calls': [], 'usage_metadata': {'input_tokens': 461, 'output_tokens': 83, 'total_tokens': 544}}, {'content': 'Sunny!', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': 'weather_search', 'id': '3b857482-bca2-4a73-a9ab-1f35a3e43e5f', 'tool_call_id': 'toolu_01YAbLBoKozJyRQnB8LUMpXC', 'artifact': None, 'status': 'success'}]}
-    {'messages': [{'content': "what's the weather in sf?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '3b2bbc38-d11b-49eb-80c0-c24a40dab5a8', 'example': False}, {'content': [{'text': 'To get the weather information for San Francisco, I can use the weather_search function. Let me do that for you.', 'type': 'text', 'index': 0}, {'id': 'toolu_01NNw18j57GEGPZvsa9f1wvX', 'input': {}, 'name': 'weather_search', 'type': 'tool_use', 'index': 1, 'partial_json': '{"city": "San Francisco"}'}], 'additional_kwargs': {}, 'response_metadata': {'stop_reason': 'tool_use', 'stop_sequence': None}, 'type': 'ai', 'name': None, 'id': 'run-c5a50900-abf5-4885-9cdb-da2bf0d892ac', 'example': False, 'tool_calls': [{'name': 'weather_search', 'args': {'city': 'San Francisco'}, 'id': 'toolu_01NNw18j57GEGPZvsa9f1wvX', 'type': 'tool_call'}], 'invalid_tool_calls': [], 'usage_metadata': {'input_tokens': 360, 'output_tokens': 80, 'total_tokens': 440}}, {'content': 'User requested changes: pass in the country as well', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': 'weather_search', 'id': '787288be-213c-4fd3-8503-4a009bdb1b00', 'tool_call_id': 'toolu_01NNw18j57GEGPZvsa9f1wvX', 'artifact': None, 'status': 'success'}, {'content': [{'text': '\n\nI apologize for the oversight. It seems the function requires additional information. Let me try again with a more specific request.', 'type': 'text', 'index': 0}, {'id': 'toolu_01YAbLBoKozJyRQnB8LUMpXC', 'input': {}, 'name': 'weather_search', 'type': 'tool_use', 'index': 1, 'partial_json': '{"city": "San Francisco, USA"}'}], 'additional_kwargs': {}, 'response_metadata': {'stop_reason': 'tool_use', 'stop_sequence': None}, 'type': 'ai', 'name': None, 'id': 'run-5c355a56-cfe3-4046-b49f-f5b09fc397ef', 'example': False, 'tool_calls': [{'name': 'weather_search', 'args': {'city': 'San Francisco, USA'}, 'id': 'toolu_01YAbLBoKozJyRQnB8LUMpXC', 'type': 'tool_call'}], 'invalid_tool_calls': [], 'usage_metadata': {'input_tokens': 461, 'output_tokens': 83, 'total_tokens': 544}}, {'content': 'Sunny!', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': 'weather_search', 'id': '3b857482-bca2-4a73-a9ab-1f35a3e43e5f', 'tool_call_id': 'toolu_01YAbLBoKozJyRQnB8LUMpXC', 'artifact': None, 'status': 'success'}, {'content': [{'text': "\n\nGreat news! The weather in San Francisco is sunny today. Is there anything else you'd like to know about the weather or any other information I can help you with?", 'type': 'text', 'index': 0}], 'additional_kwargs': {}, 'response_metadata': {'stop_reason': 'end_turn', 'stop_sequence': None}, 'type': 'ai', 'name': None, 'id': 'run-6a857bb1-f65b-4b86-93d6-c025e003c777', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': {'input_tokens': 557, 'output_tokens': 38, 'total_tokens': 595}}]}

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

@@ -1,384 +0,0 @@
-# How to Replay and Branch from Prior States
-
-With LangGraph Cloud you have the ability to return to any of your prior states and either re-run the graph to reproduce issues noticed during testing, or branch out in a different way from what was originally done in the prior states. In this guide we will show a quick example of how to rerun past states and how to branch off from previous states as well.
-
-## Setup
-
-We are not going to show the full code for the graph we are hosting, but you can see it [here](../../how-tos/human_in_the_loop/time-travel.ipynb#build-the-agent) if you want to. Once this graph is hosted, we are ready to invoke it and wait for user input. 
-
-### SDK initialization
-
-First, we need to setup our client so that we can communicate with our hosted graph:
-
-=== "Python"
-
-    ```python
-    from langgraph_sdk import get_client
-    client = get_client(url=<DEPLOYMENT_URL>)
-    # Using the graph deployed with the name "agent"
-    assistant_id = "agent"
-    thread = await client.threads.create()
-    ```
-
-=== "Javascript"
-
-    ```js
-    import { Client } from "@langchain/langgraph-sdk";
-
-    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
-    // Using the graph deployed with the name "agent"
-    const assistantId = "agent";
-    const thread = await client.threads.create();
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-      --url <DEPLOYMENT_URL>/threads \
-      --header 'Content-Type: application/json'
-    ```
-
-## Replay a state
-
-### Initial invocation
-
-Before replaying a state - we need to create states to replay from! In order to do this, let's invoke our graph with a simple message:
-
-=== "Python"
-
-    ```python
-    input = {"messages": [{"role": "user", "content": "Please search the weather in SF"}]}
-
-    async for chunk in client.runs.stream(
-        thread["thread_id"],
-        assistant_id,
-        input=input,
-        stream_mode="updates",
-    ):
-        if chunk.data and chunk.event != "metadata": 
-            print(chunk.data)
-    ```
-
-=== "Javascript"
-
-    ```js
-    const input = { "messages": [{ "role": "human", "content": "Please search the weather in SF" }] }
-
-    const streamResponse = client.runs.stream(
-      thread["thread_id"],
-      assistantId,
-      {
-        input: input,
-        streamMode: "updates",
-      }
-    );
-    for await (const chunk of streamResponse) {
-      if (chunk.data && chunk.event !== "metadata") {
-        console.log(chunk.data);
-      }
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-     --header 'Content-Type: application/json' \
-     --data "{
-       \"assistant_id\": \"agent\",
-       \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"Please search the weather in SF\"}]},
-       \"stream_mode\": [
-         \"updates\"
-       ]
-     }" | \
-     sed 's/\r$//' | \
-     awk '
-     /^event:/ {
-         if (data_content != "" && event_type != "metadata") {
-             print data_content "\n"
-         }
-         sub(/^event: /, "", $0)
-         event_type = $0
-         data_content = ""
-     }
-     /^data:/ {
-         sub(/^data: /, "", $0)
-         data_content = $0
-     }
-     END {
-         if (data_content != "" && event_type != "metadata") {
-             print data_content "\n"
-         }
-     }
-     '
-    ```
-    
-Output:
-
-    {'agent': {'messages': [{'content': [{'text': "Certainly! I'll use the search function to look up the current weather in San Francisco for you. Let me do that now.", 'type': 'text'}, {'id': 'toolu_011vroKUtWU7SBdrngpgpFMn', 'input': {'query': 'current weather in San Francisco'}, 'name': 'search', 'type': 'tool_use'}], 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-ee639877-d97d-40f8-96dc-d0d1ae22d203', 'example': False, 'tool_calls': [{'name': 'search', 'args': {'query': 'current weather in San Francisco'}, 'id': 'toolu_011vroKUtWU7SBdrngpgpFMn'}], 'invalid_tool_calls': [], 'usage_metadata': None}]}}
-    {'action': {'messages': [{'content': '["I looked up: current weather in San Francisco. Result: It\'s sunny in San Francisco, but you better look out if you\'re a Gemini 😈."]', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': 'search', 'id': '7bad0e72-5ebe-4b08-9b8a-b99b0fe22fb7', 'tool_call_id': 'toolu_011vroKUtWU7SBdrngpgpFMn'}]}}
-    {'agent': {'messages': [{'content': "Based on the search results, I can provide you with information about the current weather in San Francisco:\n\nThe weather in San Francisco is currently sunny. This is great news for outdoor activities and enjoying the city's beautiful sights.\n\nIt's worth noting that the search result included an unusual comment about Geminis, which isn't typically part of a weather report. This might be due to the search engine including some astrological information or a joke in its results. However, for the purpose of answering your question about the weather, we can focus on the fact that it's sunny in San Francisco.\n\nIf you need any more specific information about the weather in San Francisco, such as temperature, wind speed, or forecast for the coming days, please let me know, and I'd be happy to search for that information for you.", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-dbac539a-33c8-4f0c-9e20-91f318371e7c', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}}
-
-
-Now let's get our list of states, and invoke from the third state (right before the tool get called):
-
-
-=== "Python"
-
-    ```python
-    states = await client.threads.get_history(thread['thread_id'])
-
-    # We can confirm that this state is correct by checking the 'next' attribute and seeing that it is the tool call node
-    state_to_replay = states[2]
-    print(state_to_replay['next'])
-    ```
-
-=== "Javascript"
-
-    ```js
-    const states = await client.threads.getHistory(thread['thread_id']);
-
-    // We can confirm that this state is correct by checking the 'next' attribute and seeing that it is the tool call node
-    const stateToReplay = states[2];
-    console.log(stateToReplay['next']);
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request GET --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/history | jq -r '.[2].next'
-    ```
-
-Output:
-
-    ['action']
-
-
-
-To rerun from a state, we need first issue an empty update to the thread state. Then we need to pass in the resulting `checkpoint_id` as follows:
-
-=== "Python"
-
-    ```python
-    state_to_replay = states[2]
-    updated_config = await client.threads.update_state(
-        thread["thread_id"],
-        {"messages": []},
-        checkpoint_id=state_to_replay["checkpoint_id"]
-    )
-    async for chunk in client.runs.stream(
-        thread["thread_id"],
-        assistant_id, # graph_id
-        input=None,
-        stream_mode="updates",
-        checkpoint_id=updated_config["checkpoint_id"]
-    ):
-        if chunk.data and chunk.event != "metadata": 
-            print(chunk.data)
-    ```
-
-=== "Javascript"
-
-    ```js
-    const stateToReplay = states[2];
-    const config = await client.threads.updateState(thread["thread_id"], { values: {"messages": [] }, checkpointId: stateToReplay["checkpoint_id"] });
-    const streamResponse = client.runs.stream(
-      thread["thread_id"],
-      assistantId,
-      {
-        input: null,
-        streamMode: "updates",
-        checkpointId: config["checkpoint_id"]
-      }
-    );
-    for await (const chunk of streamResponse) {
-      if (chunk.data && chunk.event !== "metadata") {
-        console.log(chunk.data);
-      }
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request GET --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/history | jq -c '
-        .[2] as $state_to_replay |
-        {
-            values: { messages: .[2].values.messages[-1] },
-            checkpoint_id: $state_to_replay.checkpoint_id
-        }' | \
-    curl --request POST \
-        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state \
-        --header 'Content-Type: application/json' \
-        --data @- | jq .checkpoint_id | \
-    curl --request POST \
-     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-     --header 'Content-Type: application/json' \
-     --data "{
-       \"assistant_id\": \"agent\",
-       \"checkpoint_id\": \"$1\",
-       \"stream_mode\": [
-         \"updates\"
-       ]
-     }" | \
-     sed 's/\r$//' | \
-     awk '
-     /^event:/ {
-         if (data_content != "" && event_type != "metadata") {
-             print data_content "\n"
-         }
-         sub(/^event: /, "", $0)
-         event_type = $0
-         data_content = ""
-     }
-     /^data:/ {
-         sub(/^data: /, "", $0)
-         data_content = $0
-     }
-     END {
-         if (data_content != "" && event_type != "metadata") {
-             print data_content "\n"
-         }
-     }
-     '
-    ```
-
-Output:
-
-    {'action': {'messages': [{'content': '["I looked up: current weather in San Francisco. Result: It\'s sunny in San Francisco, but you better look out if you\'re a Gemini 😈."]', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': 'search', 'id': 'eba650e5-400e-4938-8508-f878dcbcc532', 'tool_call_id': 'toolu_011vroKUtWU7SBdrngpgpFMn'}]}}
-    {'agent': {'messages': [{'content': "Based on the search results, I can provide you with information about the current weather in San Francisco:\n\nThe weather in San Francisco is currently sunny. This is great news if you're planning any outdoor activities or simply want to enjoy a pleasant day in the city.\n\nIt's worth noting that the search result included an unusual comment about Geminis, which doesn't seem directly related to the weather. This appears to be a playful or humorous addition to the weather report, possibly from the source where this information was obtained.\n\nIs there anything else you'd like to know about the weather in San Francisco or any other information you need?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-bc6dca3f-a1e2-4f59-a69b-fe0515a348bb', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}}
-
-
-As we can see, the graph restarted from the tool node with the same input as our original graph run.
-
-## Branch off from previous state
-
-Using LangGraph's checkpointing, you can do more than just replay past states. You can branch off previous locations to let the agent explore alternate trajectories or to let a user "version control" changes in a workflow.
-
-Let's show how to do this to edit the state at a particular point in time. Let's update the state to change the input to the tool
-
-=== "Python"
-
-    ```python
-    # Let's now get the last message in the state
-    # This is the one with the tool calls that we want to update
-    last_message = state_to_replay['values']['messages'][-1]
-
-    # Let's now update the args for that tool call
-    last_message['tool_calls'][0]['args'] = {'query': 'current weather in SF'}
-
-    config = await client.threads.update_state(thread['thread_id'],{"messages":[last_message]},checkpoint_id=state_to_replay['checkpoint_id'])
-    ```
-
-=== "Javascript"
-
-    ```js
-    // Let's now get the last message in the state
-    // This is the one with the tool calls that we want to update
-    let lastMessage = stateToReplay['values']['messages'][-1];
-
-    // Let's now update the args for that tool call
-    lastMessage['tool_calls'][0]['args'] = { 'query': 'current weather in SF' };
-
-    const config = await client.threads.updateState(thread['thread_id'], { values: { "messages": [lastMessage] }, checkpointId: stateToReplay['checkpoint_id'] });
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl -s --request GET --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/history | \
-    jq -c '
-        .[2] as $state_to_replay |
-        .[2].values.messages[-1].tool_calls[0].args.query = "current weather in SF" |
-        {
-            values: { messages: .[2].values.messages[-1] },
-            checkpoint_id: $state_to_replay.checkpoint_id
-        }' | \
-    curl --request POST \
-        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state \
-        --header 'Content-Type: application/json' \
-        --data @-
-    ```
-
-Now we can rerun our graph with this new config, starting from the `new_state`, which is a branch of our `state_to_replay`:
-
-=== "Python"
-
-    ```python
-    async for chunk in client.runs.stream(
-        thread["thread_id"],
-        assistant_id,
-        input=None,
-        stream_mode="updates",
-        checkpoint_id=config['checkpoint_id']
-    ):
-        if chunk.data and chunk.event != "metadata": 
-            print(chunk.data)
-    ```
-
-=== "Javascript"
-
-    ```js
-    const streamResponse = client.runs.stream(
-      thread["thread_id"],
-      assistantId,
-      {
-        input: null,
-        streamMode: "updates",
-        checkpointId: config['checkpoint_id'],
-      }
-    );
-    for await (const chunk of streamResponse) {
-      if (chunk.data && chunk.event !== "metadata") {
-        console.log(chunk.data);
-      }
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl -s --request GET --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state | \
-    jq -c '.checkpoint_id' | \
-    curl --request POST \
-     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-     --header 'Content-Type: application/json' \
-     --data "{
-       \"assistant_id\": \"agent\",
-       \"checkpoint_id\": \"$1\",
-       \"stream_mode\": [
-         \"updates\"
-       ]
-     }" | \
-     sed 's/\r$//' | \
-     awk '
-     /^event:/ {
-         if (data_content != "" && event_type != "metadata") {
-             print data_content "\n"
-         }
-         sub(/^event: /, "", $0)
-         event_type = $0
-         data_content = ""
-     }
-     /^data:/ {
-         sub(/^data: /, "", $0)
-         data_content = $0
-     }
-     END {
-         if (data_content != "" && event_type != "metadata") {
-             print data_content "\n"
-         }
-     }
-     '
-    ```
-
-Output:
-
-
-    {'action': {'messages': [{'content': '["I looked up: current weather in SF. Result: It\'s sunny in San Francisco, but you better look out if you\'re a Gemini 😈."]', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': 'search', 'id': '2baf9941-4fda-4081-9f87-d76795d289f1', 'tool_call_id': 'toolu_011vroKUtWU7SBdrngpgpFMn'}]}}
-    {'agent': {'messages': [{'content': "Based on the search results, I can provide you with information about the current weather in San Francisco (SF):\n\nThe weather in San Francisco is currently sunny. This means it's a clear day with plenty of sunshine. \n\nIt's worth noting that the specific temperature wasn't provided in the search result, but sunny weather in San Francisco typically means comfortable temperatures. San Francisco is known for its mild climate, so even on sunny days, it's often not too hot.\n\nThe search result also included a playful reference to astrological signs, mentioning Gemini. However, this is likely just a joke or part of the search engine's presentation and not related to the actual weather conditions.\n\nIs there any specific information about the weather in San Francisco you'd like to know more about? I'd be happy to perform another search if you need details on temperature, wind conditions, or the forecast for the coming days.", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-a83de52d-ed18-4402-9384-75c462485743', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}}
-
-
-As we can see, the search query changed from San Francisco to SF, just as we had hoped!

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

@@ -1,292 +0,0 @@
-# How to Wait for User Input
-
-One of the main human-in-the-loop interaction patterns is waiting for human input. A key use case involves asking the user clarifying questions. One way to accomplish this is simply go to the `END` node and exit the graph. Then, any user response comes back in as fresh invocation of the graph. This is basically just creating a chatbot architecture.
-
-The issue with this is it is tough to resume back in a particular point in the graph. Often times the agent is halfway through some process, and just needs a bit of a user input. Although it is possible to design your graph in such a way where you have a `conditional_entry_point` to route user messages back to the right place, that is not super scalable (as it essentially involves having a routing function that can end up almost anywhere).
-
-A separate way to do this is to have a node explicitly for getting user input. This is easy to implement in a notebook setting - you just put an `input()` call in the node. But that isn't exactly production ready.
-
-Luckily, LangGraph makes it possible to do similar things in a production way. The basic idea is:
-
-- Set up a node that represents human input. This can have specific incoming/outgoing edges (as you desire). There shouldn't actually be any logic inside this node.
-- Add a breakpoint before the node. This will stop the graph before this node executes (which is good, because there's no real logic in it anyways)
-- Use `.update_state` to update the state of the graph. Pass in whatever human response you get. The key here is to use the `as_node` parameter to apply this update **as if you were that node**. This will have the effect of making it so that when you resume execution next it resumes as if that node just acted, and not from the beginning.
-
-## Setup
-
-We are not going to show the full code for the graph we are hosting, but you can see it [here](../../how-tos/human_in_the_loop/wait-user-input.ipynb#build-the-agent) if you want to. Once this graph is hosted, we are ready to invoke it and wait for user input. 
-
-### SDK initialization
-
-First, we need to setup our client so that we can communicate with our hosted graph:
-
-=== "Python"
-
-    ```python
-    from langgraph_sdk import get_client
-    client = get_client(url=<DEPLOYMENT_URL>)
-    # Using the graph deployed with the name "agent"
-    assistant_id = "agent"
-    thread = await client.threads.create()
-    ```
-
-=== "Javascript"
-
-    ```js
-    import { Client } from "@langchain/langgraph-sdk";
-
-    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
-    // Using the graph deployed with the name "agent"
-    const assistantId = "agent";
-    const thread = await client.threads.create();
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-      --url <DEPLOYMENT_URL>/threads \
-      --header 'Content-Type: application/json'
-    ```
-
-## Waiting for user input
-
-### Initial invocation
-
-Now, let's invoke our graph by interrupting before `ask_human` node:
-
-=== "Python"
-
-    ```python
-    input = {
-        "messages": [
-            {
-                "role": "human",
-                "content": "Use the search tool to ask the user where they are, then look up the weather there",
-            }
-        ]
-    }
-
-    async for chunk in client.runs.stream(
-        thread["thread_id"],
-        assistant_id,
-        input=input,
-        stream_mode="updates",
-        interrupt_before=["ask_human"],
-    ):
-        if chunk.data and chunk.event != "metadata": 
-            print(chunk.data)
-    ```
-=== "Javascript"
-
-    ```js
-    const input = {
-      messages: [
-        {
-          role: "human",
-          content: "Use the search tool to ask the user where they are, then look up the weather there"
-        }
-      ]
-    };
-
-    const streamResponse = client.runs.stream(
-      thread["thread_id"],
-      assistantId,
-      {
-        input: input,
-        streamMode: "updates",
-        interruptBefore: ["ask_human"]
-      }
-    );
-
-    for await (const chunk of streamResponse) {
-      if (chunk.data && chunk.event !== "metadata") {
-        console.log(chunk.data);
-      }
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-     --header 'Content-Type: application/json' \
-     --data "{
-       \"assistant_id\": \"agent\",
-       \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"Use the search tool to ask the user where they are, then look up the weather there\"}]},
-       \"interrupt_before\": [\"ask_human\"],
-       \"stream_mode\": [
-         \"updates\"
-       ]
-     }" | \
-     sed 's/\r$//' | \
-     awk '
-     /^event:/ {
-         if (data_content != "" && event_type != "metadata") {
-             print data_content "\n"
-         }
-         sub(/^event: /, "", $0)
-         event_type = $0
-         data_content = ""
-     }
-     /^data:/ {
-         sub(/^data: /, "", $0)
-         data_content = $0
-     }
-     END {
-         if (data_content != "" && event_type != "metadata") {
-             print data_content "\n"
-         }
-     }
-     '
-    ```
-    
-Output:
-
-    {'agent': {'messages': [{'content': [{'text': "Certainly! I'll use the AskHuman function to ask the user about their location, and then I'll use the search function to look up the weather for that location. Let's start by asking the user where they are.", 'type': 'text'}, {'id': 'toolu_01RFahzYPvnPWTb2USk2RdKR', 'input': {'question': 'Where are you currently located?'}, 'name': 'AskHuman', 'type': 'tool_use'}], 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-a8422215-71d3-4093-afb4-9db141c94ddb', 'example': False, 'tool_calls': [{'name': 'AskHuman', 'args': {'question': 'Where are you currently located?'}, 'id': 'toolu_01RFahzYPvnPWTb2USk2RdKR'}], 'invalid_tool_calls': [], 'usage_metadata': None}]}}
-
-
-### Adding user input to state
-
-We now want to update this thread with a response from the user. We then can kick off another run.
-
-Because we are treating this as a tool call, we will need to update the state as if it is a response from a tool call. In order to do this, we will need to check the state to get the ID of the tool call.
-
-
-=== "Python"
-
-    ```python
-    state = await client.threads.get_state(thread['thread_id'])
-    tool_call_id = state['values']['messages'][-1]['tool_calls'][0]['id']
-
-    # We now create the tool call with the id and the response we want
-    tool_message = [{"tool_call_id": tool_call_id, "type": "tool", "content": "san francisco"}]
-
-    await client.threads.update_state(thread['thread_id'], {"messages": tool_message}, as_node="ask_human")
-    ```
-
-=== "Javascript"
-
-    ```js
-    const state = await client.threads.getState(thread["thread_id"]);
-    const toolCallId = state.values.messages[state.values.messages.length - 1].tool_calls[0].id;
-
-    // We now create the tool call with the id and the response we want
-    const toolMessage = [
-      {
-        tool_call_id: toolCallId,
-        type: "tool",
-        content: "san francisco"
-      }
-    ];
-
-    await client.threads.updateState(
-      thread["thread_id"],
-      { values: { messages: toolMessage } },
-      { asNode: "ask_human" }
-    );
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request GET \
-     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state \
-     | jq -r '.values.messages[-1].tool_calls[0].id' \
-     | sh -c '
-         TOOL_CALL_ID="$1"
-         
-         # Construct the JSON payload
-         JSON_PAYLOAD=$(printf "{\"messages\": [{\"tool_call_id\": \"%s\", \"type\": \"tool\", \"content\": \"san francisco\"}], \"as_node\": \"ask_human\"}" "$TOOL_CALL_ID")
-         
-         # Send the updated state
-         curl --request POST \
-              --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state \
-              --header "Content-Type: application/json" \
-              --data "${JSON_PAYLOAD}"
-     ' _ 
-    ```
-
-Output:
-
-    {'configurable': {'thread_id': 'a9f322ae-4ed1-41ec-942b-38cb3d342c3a',
-    'checkpoint_ns': '',
-    'checkpoint_id': '1ef58e97-a623-63dd-8002-39a9a9b20be3'}}
-
-
-### Invoking after receiving human input
-
-We can now tell the agent to continue. We can just pass in None as the input to the graph, since no additional input is needed:
-
-=== "Python"
-
-    ```python
-    async for chunk in client.runs.stream(
-        thread["thread_id"],
-        assistant_id,
-        input=None,
-        stream_mode="updates",
-    ):
-        if chunk.data and chunk.event != "metadata": 
-            print(chunk.data)
-    ```
-=== "Javascript"
-
-    ```js
-    const streamResponse = client.runs.stream(
-      thread["thread_id"],
-      assistantId,
-      {
-        input: null,
-        streamMode: "updates"
-      }
-    );
-
-    for await (const chunk of streamResponse) {
-      if (chunk.data && chunk.event !== "metadata") {
-        console.log(chunk.data);
-      }
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \                                                                             
-     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-     --header 'Content-Type: application/json' \
-     --data "{
-       \"assistant_id\": \"agent\",
-       \"stream_mode\": [
-         \"updates\"
-       ]
-     }"| \ 
-     sed 's/\r$//' | \
-     awk '
-     /^event:/ {
-         if (data_content != "" && event_type != "metadata") {
-             print data_content "\n"
-         }
-         sub(/^event: /, "", $0)
-         event_type = $0
-         data_content = ""
-     }
-     /^data:/ {
-         sub(/^data: /, "", $0)
-         data_content = $0
-     }
-     END {
-         if (data_content != "" && event_type != "metadata") {
-             print data_content "\n"
-         }
-     }
-     '
-    ```
-
-Output:
-
-    {'agent': {'messages': [{'content': [{'text': "Thank you for letting me know that you're in San Francisco. Now, I'll use the search function to look up the weather in San Francisco.", 'type': 'text'}, {'id': 'toolu_01K57ofmgG2wyJ8tYJjbq5k7', 'input': {'query': 'current weather in San Francisco'}, 'name': 'search', 'type': 'tool_use'}], 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-241baed7-db5e-44ce-ac3c-56431705c22b', 'example': False, 'tool_calls': [{'name': 'search', 'args': {'query': 'current weather in San Francisco'}, 'id': 'toolu_01K57ofmgG2wyJ8tYJjbq5k7'}], 'invalid_tool_calls': [], 'usage_metadata': None}]}}
-    {'action': {'messages': [{'content': '["I looked up: current weather in San Francisco. Result: It\'s sunny in San Francisco, but you better look out if you\'re a Gemini 😈."]', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': 'search', 'id': '8b699b95-8546-4557-8e66-14ea71a15ed8', 'tool_call_id': 'toolu_01K57ofmgG2wyJ8tYJjbq5k7'}]}}
-    {'agent': {'messages': [{'content': "Based on the search results, I can provide you with information about the current weather in San Francisco:\n\nThe weather in San Francisco is currently sunny. It's a beautiful day in the city! \n\nHowever, I should note that the search result included an unusual comment about Gemini zodiac signs. This appears to be either a joke or potentially irrelevant information added by the search engine. For accurate and detailed weather information, you might want to check a reliable weather service or app for San Francisco.\n\nIs there anything else you'd like to know about the weather or San Francisco?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-b4d7309f-f849-46aa-b6ef-475bcabd2be9', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}}
-

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

@@ -1,77 +0,0 @@
----
-hide:
-  - toc
----
-
-# How-to Guides
-
-Welcome to the LangGraph Cloud how-to guides! These guides provide practical, step-by-step instructions for accomplishing key tasks in LangGraph Cloud.
-
-## Deployment
-
-LangGraph Cloud gives you best in class observability, testing, and hosting services. Read more about them in these how to guides:
-
-- [How to set up app for deployment (requirements.txt)](../deployment/setup.md)
-- [How to set up app for deployment (pyproject.toml)](../deployment/setup_pyproject.md)
-- [How to set up app for deployment (JavaScript)](../deployment/setup_javascript.md)
-- [How to test locally](../deployment/test_locally.md)
-- [How to deploy to LangGraph cloud](../deployment/cloud.md)
-
-
-## Streaming
-
-Streaming the results of your LLM application is vital for ensuring a good user experience, especially when your graph may call multiple models and take a long time to fully complete a run. Read about how to stream values from your graph in these how to guides:
-
-- [How to stream values](./stream_values.md)
-- [How to stream updates](./stream_updates.md)
-- [How to stream messages](./stream_messages.md)
-- [How to stream events](./stream_events.md)
-- [How to stream in debug mode](./stream_debug.md)
-- [How to stream multiple modes](./stream_multiple.md)
-
-## Double-texting
-
-Graph execution can take a while, and sometimes users may change their mind about the input they wanted to send before their original input has finished running. For example, a user might notice a typo in their original request and will edit the prompt and resend it. Deciding what to do in these cases is important for ensuring a smooth user experience and preventing your graphs from behaving in unexpected ways. The following how-to guides provide information on the various options LangGraph Cloud gives you for dealing with double-texting:
-
-- [How to use the interrupt option](./interrupt_concurrent.md)
-- [How to use the rollback option](./rollback_concurrent.md)
-- [How to use the reject option](./reject_concurrent.md)
-- [How to use the enqueue option](./enqueue_concurrent.md)
-
-## Human-in-the-loop
-
-When creating complex graphs, leaving every decision up to the LLM can be dangerous, especially when the decisions involve invoking certain tools or accessing specific documents. To remedy this, LangGraph allows you to insert human-in-the-loop behavior to ensure your graph does not have undesired outcomes. Read more about the different ways you can add human-in-the-loop capabilities to your LangGraph Cloud projects in these how-to guides:
-
-- [How to add a breakpoint](./human_in_the_loop_breakpoint.md)
-- [How to wait for user input](./human_in_the_loop_user_input.md)
-- [How to edit graph state](./human_in_the_loop_edit_state.md)
-- [How to replay and branch from prior states](./human_in_the_loop_time_travel.md)
-- [How to review tool calls](./human_in_the_loop_review_tool_calls.md)
-
-## LangGraph Studio
-
-LangGraph Studio is a built-in UI for visualizing, testing, and debugging your agents.
-
-- [How to enter LangGraph Studio](./test_deployment.md)
-- [How to enter LangGraph Studio for local deployment](./test_local_deployment.md)
-- [How to test your graph in LangGraph Studio](./invoke_studio.md)
-- [Interact with threads in LangGraph Studio](./threads_studio.md)
-
-## Different Types of Runs:
-
-LangGraph Cloud supports multiple types of runs besides streaming runs.
-
-- [How to run an agent in the background](./background_run.md)
-- [How to run multiple agents in the same thread](./same-thread.md)
-- [How to create cron jobs](./cron_jobs.md)
-- [How to create stateless runs](./stateless_runs.md)
-
-## Other 
-
-Other guides that may prove helpful!
-
-- [How to configure agents](./configuration_cloud.md)
-- [How to convert LangGraph calls to LangGraph cloud calls](cloud_examples/langgraph_to_langgraph_cloud.ipynb)
-- [How to integrate webhooks](./webhooks.md)
-- [How to copy threads](./copy_threads.md)
-- [How to check status of your threads](./check_thread_status.md)

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

@@ -1,242 +0,0 @@
-## Interrupt
-
-This guide assumes knowledge of what double-texting is, which you can learn about in the [double-texting conceptual guide](../concepts/api.md#double-texting).
-
-The guide covers the `interrupt` option for double texting, which interrupts the prior run of the graph and starts a new one with the double-text. This option does not delete the first run, but rather keeps it in the database but sets its status to `interrupted`. Below is a quick example of using the `interrupt` option.
-
-First, we will define a quick helper function for printing out JS and CURL model outputs (you can skip this if using Python):
-
-=== "Javascript"
-
-    ```js
-    function prettyPrint(m) {
-      const padded = " " + m['type'] + " ";
-      const sepLen = Math.floor((80 - padded.length) / 2);
-      const sep = "=".repeat(sepLen);
-      const secondSep = sep + (padded.length % 2 ? "=" : "");
-      
-      console.log(`${sep}${padded}${secondSep}`);
-      console.log("\n\n");
-      console.log(m.content);
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    # PLACE THIS IN A FILE CALLED pretty_print.sh
-    pretty_print() {
-      local type="$1"
-      local content="$2"
-      local padded=" $type "
-      local total_width=80
-      local sep_len=$(( (total_width - ${#padded}) / 2 ))
-      local sep=$(printf '=%.0s' $(eval "echo {1.."${sep_len}"}"))
-      local second_sep=$sep
-      if (( (total_width - ${#padded}) % 2 )); then
-        second_sep="${second_sep}="
-      fi
-
-      echo "${sep}${padded}${second_sep}"
-      echo
-      echo "$content"
-    }
-    ```
-
-Now, let's import our required packages and instantiate our client, assistant, and thread.
-
-=== "Python"
-
-    ```python
-    import asyncio
-
-    from langchain_core.messages import convert_to_messages
-    from langgraph_sdk import get_client
-
-    client = get_client(url=<DEPLOYMENT_URL>)
-    # Using the graph deployed with the name "agent"
-    assistant_id = "agent"
-    thread = await client.threads.create()
-    ```
-
-=== "Javascript"
-
-    ```js
-    import { Client } from "@langchain/langgraph-sdk";
-
-    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
-    // Using the graph deployed with the name "agent"
-    const assistantId = "agent";
-    const thread = await client.threads.create();
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-      --url <DEPLOYMENT_URL>/threads \
-      --header 'Content-Type: application/json'
-    ```
-
-Now we can start our two runs and join the second on euntil it has completed:
-
-=== "Python"
-
-    ```python
-    # the first run will be interrupted
-    interrupted_run = await client.runs.create(
-        thread["thread_id"],
-        assistant_id,
-        input={"messages": [{"role": "human", "content": "what's the weather in sf?"}]},
-    )
-    await asyncio.sleep(2)
-    run = await client.runs.create(
-        thread["thread_id"],
-        assistant_id,
-        input={"messages": [{"role": "human", "content": "what's the weather in nyc?"}]},
-        multitask_strategy="interrupt",
-    )
-    # wait until the second run completes
-    await client.runs.join(thread["thread_id"], run["run_id"])
-    ```
-
-=== "Javascript"
-
-    ```js
-    // the first run will be interrupted
-    let interruptedRun = await client.runs.create(
-      thread["thread_id"],
-      assistantId,
-      { input: { messages: [{ role: "human", content: "what's the weather in sf?" }] } }
-    );
-    await new Promise(resolve => setTimeout(resolve, 2000)); 
-
-    let run = await client.runs.create(
-      thread["thread_id"],
-      assistantId,
-      { 
-        input: { messages: [{ role: "human", content: "what's the weather in nyc?" }] },
-        multitaskStrategy: "interrupt" 
-      }
-    );
-
-    // wait until the second run completes
-    await client.runs.join(thread["thread_id"], run["run_id"]);
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-    --url <DEPLOY<ENT_URL>>/threads/<THREAD_ID>/runs \
-    --header 'Content-Type: application/json' \
-    --data "{
-      \"assistant_id\": \"agent\",
-      \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"what\'s the weather in sf?\"}]},
-    }" && sleep 2 && curl --request POST \
-    --url <DEPLOY<ENT_URL>>/threads/<THREAD_ID>/runs \
-    --header 'Content-Type: application/json' \
-    --data "{
-      \"assistant_id\": \"agent\",
-      \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"what\'s the weather in nyc?\"}]},
-      \"multitask_strategy\": \"interrupt\"
-    }" && curl --request GET \
-    --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/<RUN_ID>/join
-    ```
-
-We can see that the thread has partial data from the first run + data from the second run
-
-
-=== "Python"
-
-    ```python
-    state = await client.threads.get_state(thread["thread_id"])
-
-    for m in convert_to_messages(state["values"]["messages"]):
-        m.pretty_print()
-    ```
-
-=== "Javascript"
-
-    ```js
-    const state = await client.threads.getState(thread["thread_id"]);
-
-    for (const m of state['values']['messages']) {
-      prettyPrint(m);
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    source pretty_print.sh && curl --request GET \
-    --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state | \
-    jq -c '.values.messages[]' | while read -r element; do
-        type=$(echo "$element" | jq -r '.type')
-        content=$(echo "$element" | jq -r '.content | if type == "array" then tostring else . end')
-        pretty_print "$type" "$content"
-    done
-    ```
-
-Output:
-
-    ================================ Human Message =================================
-    
-    what's the weather in sf?
-    ================================== Ai Message ==================================
-    
-    [{'id': 'toolu_01MjNtVJwEcpujRGrf3x6Pih', 'input': {'query': 'weather in san francisco'}, 'name': 'tavily_search_results_json', 'type': 'tool_use'}]
-    Tool Calls:
-      tavily_search_results_json (toolu_01MjNtVJwEcpujRGrf3x6Pih)
-     Call ID: toolu_01MjNtVJwEcpujRGrf3x6Pih
-      Args:
-        query: weather in san francisco
-    ================================= Tool Message =================================
-    Name: tavily_search_results_json
-    
-    [{"url": "https://www.wunderground.com/hourly/us/ca/san-francisco/KCASANFR2002/date/2024-6-18", "content": "High 64F. Winds W at 10 to 20 mph. A few clouds from time to time. Low 49F. Winds W at 10 to 20 mph. Temp. San Francisco Weather Forecasts. Weather Underground provides local & long-range weather ..."}]
-    ================================ Human Message =================================
-    
-    what's the weather in nyc?
-    ================================== Ai Message ==================================
-    
-    [{'id': 'toolu_01KtE1m1ifPLQAx4fQLyZL9Q', 'input': {'query': 'weather in new york city'}, 'name': 'tavily_search_results_json', 'type': 'tool_use'}]
-    Tool Calls:
-      tavily_search_results_json (toolu_01KtE1m1ifPLQAx4fQLyZL9Q)
-     Call ID: toolu_01KtE1m1ifPLQAx4fQLyZL9Q
-      Args:
-        query: weather in new york city
-    ================================= Tool Message =================================
-    Name: tavily_search_results_json
-    
-    [{"url": "https://www.accuweather.com/en/us/new-york/10021/june-weather/349727", "content": "Get the monthly weather forecast for New York, NY, including daily high/low, historical averages, to help you plan ahead."}]
-    ================================== Ai Message ==================================
-    
-    The search results provide weather forecasts and information for New York City. Based on the top result from AccuWeather, here are some key details about the weather in NYC:
-    
-    - This is a monthly weather forecast for New York City for the month of June.
-    - It includes daily high and low temperatures to help plan ahead.
-    - Historical averages for June in NYC are also provided as a reference point.
-    - More detailed daily or hourly forecasts with precipitation chances, humidity, wind, etc. can be found by visiting the AccuWeather page.
-    
-    So in summary, the search provides a convenient overview of the expected weather conditions in New York City over the next month to give you an idea of what to prepare for if traveling or making plans there. Let me know if you need any other details!
-
-
-Verify that the original, interrupted run was interrupted
-
-=== "Python"
-
-    ```python
-    print((await client.runs.get(thread["thread_id"], interrupted_run["run_id"]))["status"])
-    ```
-
-=== "Javascript"
-
-    ```js
-    console.log((await client.runs.get(thread['thread_id'], interruptedRun["run_id"]))["status"])
-    ```
-
-Output:
-
-    'interrupted'
-

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

@@ -1,15 +0,0 @@
-# Invoke Assistant
-
-The LangGraph Studio lets you test different configurations and inputs to your graph. It also provides a nice visualization of your graph during execution so it is easy to see which nodes are being run and what the outputs of each individual node are.
-
-1. The LangGraph Studio UI displays a visualization of the selected assistant.
-    1. In the top-left dropdown menu of the left-hand pane, select an assistant.
-    1. In the bottom of the left-hand pane, edit the `Input` and `Configure` the assistant.
-    1. Select `Submit` to invoke the selected assistant.
-1. View output of the invocation in the right-hand pane.
-
-The following video shows these exact steps being carried out:
-
-<video controls allowfullscreen="true" poster="../img/studio_input_poster.png">
-    <source src="../img/studio_input.mp4" type="video/mp4">
-</video>

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

@@ -1,223 +0,0 @@
-## Reject
-
-This guide assumes knowledge of what double-texting is, which you can learn about in the [double-texting conceptual guide][double-texting].
-
-The guide covers the `reject` option for double texting, which rejects the new run of the graph by throwing an error and continues with the original run until completion. Below is a quick example of using the `reject` option.
-
-First, we will define a quick helper function for printing out JS and CURL model outputs (you can skip this if using Python):
-
-=== "Javascript"
-
-    ```js
-    function prettyPrint(m) {
-      const padded = " " + m['type'] + " ";
-      const sepLen = Math.floor((80 - padded.length) / 2);
-      const sep = "=".repeat(sepLen);
-      const secondSep = sep + (padded.length % 2 ? "=" : "");
-      
-      console.log(`${sep}${padded}${secondSep}`);
-      console.log("\n\n");
-      console.log(m.content);
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    # PLACE THIS IN A FILE CALLED pretty_print.sh
-    pretty_print() {
-      local type="$1"
-      local content="$2"
-      local padded=" $type "
-      local total_width=80
-      local sep_len=$(( (total_width - ${#padded}) / 2 ))
-      local sep=$(printf '=%.0s' $(eval "echo {1.."${sep_len}"}"))
-      local second_sep=$sep
-      if (( (total_width - ${#padded}) % 2 )); then
-        second_sep="${second_sep}="
-      fi
-
-      echo "${sep}${padded}${second_sep}"
-      echo
-      echo "$content"
-    }
-    ```
-
-Now, let's import our required packages and instantiate our client, assistant, and thread.
-
-=== "Python"
-
-    ```python
-    import httpx
-    from langchain_core.messages import convert_to_messages
-    from langgraph_sdk import get_client
-
-    client = get_client(url=<DEPLOYMENT_URL>)
-    # Using the graph deployed with the name "agent"
-    assistant_id = "agent"
-    thread = await client.threads.create()
-    ```
-
-=== "Javascript"
-
-    ```js
-    import { Client } from "@langchain/langgraph-sdk";
-
-    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
-    // Using the graph deployed with the name "agent"
-    const assistantId = "agent";
-    const thread = await client.threads.create();
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-      --url <DEPLOYMENT_URL>/threads \
-      --header 'Content-Type: application/json'
-    ```
-
-Now we can run a thread and try to run a second one with the "reject" option, which should fail since we have already started a run:
-
-
-=== "Python"
-
-    ```python
-    run = await client.runs.create(
-        thread["thread_id"],
-        assistant_id,
-        input={"messages": [{"role": "human", "content": "what's the weather in sf?"}]},
-    )
-    try:
-        await client.runs.create(
-            thread["thread_id"],
-            assistant_id,
-            input={
-                "messages": [{"role": "human", "content": "what's the weather in nyc?"}]
-            },
-            multitask_strategy="reject",
-        )
-    except httpx.HTTPStatusError as e:
-        print("Failed to start concurrent run", e)
-    ```
-
-=== "Javascript"
-
-    ```js
-    const run = await client.runs.create(
-      thread["thread_id"],
-      assistantId,
-      input={"messages": [{"role": "human", "content": "what's the weather in sf?"}]},
-    );
-    
-    try {
-      await client.runs.create(
-        thread["thread_id"],
-        assistantId,
-        { 
-          input: {"messages": [{"role": "human", "content": "what's the weather in nyc?"}]},
-          multitask_strategy:"reject"
-        },
-      );
-    } catch (e) {
-      console.error("Failed to start concurrent run", e);
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-    --url <DEPLOY<ENT_URL>>/threads/<THREAD_ID>/runs \
-    --header 'Content-Type: application/json' \
-    --data "{
-      \"assistant_id\": \"agent\",
-      \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"what\'s the weather in sf?\"}]},
-    }" && curl --request POST \
-    --url <DEPLOY<ENT_URL>>/threads/<THREAD_ID>/runs \
-    --header 'Content-Type: application/json' \
-    --data "{
-      \"assistant_id\": \"agent\",
-      \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"what\'s the weather in nyc?\"}]},
-      \"multitask_strategy\": \"reject\"
-    }" || { echo "Failed to start concurrent run"; echo "Error: $?" >&2; }
-    ```
-
-Output:
-
-    Failed to start concurrent run Client error '409 Conflict' for url 'http://localhost:8123/threads/f9e7088b-8028-4e5c-88d2-9cc9a2870e50/runs'
-    For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/409
-
-
-We can verify that the original thread finished executing:
-
-=== "Python"
-
-    ```python
-    # wait until the original run completes
-    await client.runs.join(thread["thread_id"], run["run_id"])
-
-    state = await client.threads.get_state(thread["thread_id"])
-
-    for m in convert_to_messages(state["values"]["messages"]):
-        m.pretty_print()
-    ```
-
-=== "Javascript"
-
-    ```js
-    await client.runs.join(thread["thread_id"], run["run_id"]);
-
-    const state = await client.threads.getState(thread["thread_id"]);
-
-    for (const m of state["values"]["messages"]) {
-      prettyPrint(m);
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    source pretty_print.sh && curl --request GET \
-    --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/<RUN_ID>/join && \
-    curl --request GET --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state | \
-    jq -c '.values.messages[]' | while read -r element; do
-        type=$(echo "$element" | jq -r '.type')
-        content=$(echo "$element" | jq -r '.content | if type == "array" then tostring else . end')
-        pretty_print "$type" "$content"
-    done
-    ```
-
-Output:
-
-    ================================ Human Message =================================
-    
-    what's the weather in sf?
-    ================================== Ai Message ==================================
-    
-    [{'id': 'toolu_01CyewEifV2Kmi7EFKHbMDr1', 'input': {'query': 'weather in san francisco'}, 'name': 'tavily_search_results_json', 'type': 'tool_use'}]
-    Tool Calls:
-      tavily_search_results_json (toolu_01CyewEifV2Kmi7EFKHbMDr1)
-     Call ID: toolu_01CyewEifV2Kmi7EFKHbMDr1
-      Args:
-        query: weather in san francisco
-    ================================= Tool Message =================================
-    Name: tavily_search_results_json
-    
-    [{"url": "https://www.accuweather.com/en/us/san-francisco/94103/june-weather/347629", "content": "Get the monthly weather forecast for San Francisco, CA, including daily high/low, historical averages, to help you plan ahead."}]
-    ================================== Ai Message ==================================
-    
-    According to the search results from Tavily, the current weather in San Francisco is:
-    
-    The average high temperature in San Francisco in June is around 65°F (18°C), with average lows around 54°F (12°C). June tends to be one of the cooler and foggier months in San Francisco due to the marine layer of fog that often blankets the city during the summer months.
-    
-    Some key points about the typical June weather in San Francisco:
-    
-    - Mild temperatures with highs in the 60s F and lows in the 50s F
-    - Foggy mornings that often burn off to sunny afternoons
-    - Little to no rainfall, as June falls in the dry season
-    - Breezy conditions, with winds off the Pacific Ocean
-    - Layers are recommended for changing weather conditions
-    
-    So in summary, you can expect mild, foggy mornings giving way to sunny but cool afternoons in San Francisco this time of year. The marine layer keeps temperatures moderate compared to other parts of California in June.
-

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

@@ -1,227 +0,0 @@
-## Rollback
-
-This guide assumes knowledge of what double-texting is, which you can learn about in the [double-texting conceptual guide][double-texting].
-
-The guide covers the `rollback` option for double texting, which interrupts the prior run of the graph and starts a new one with the double-text. This option is very similar to the `interrupt` option, but in this case the first run is completely deleted from the database and cannot be restarted. Below is a quick example of using the `rollback` option.
-
-First, we will define a quick helper function for printing out JS and CURL model outputs (you can skip this if using Python):
-
-=== "Javascript"
-
-    ```js
-    function prettyPrint(m) {
-      const padded = " " + m['type'] + " ";
-      const sepLen = Math.floor((80 - padded.length) / 2);
-      const sep = "=".repeat(sepLen);
-      const secondSep = sep + (padded.length % 2 ? "=" : "");
-      
-      console.log(`${sep}${padded}${secondSep}`);
-      console.log("\n\n");
-      console.log(m.content);
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    # PLACE THIS IN A FILE CALLED pretty_print.sh
-    pretty_print() {
-      local type="$1"
-      local content="$2"
-      local padded=" $type "
-      local total_width=80
-      local sep_len=$(( (total_width - ${#padded}) / 2 ))
-      local sep=$(printf '=%.0s' $(eval "echo {1.."${sep_len}"}"))
-      local second_sep=$sep
-      if (( (total_width - ${#padded}) % 2 )); then
-        second_sep="${second_sep}="
-      fi
-
-      echo "${sep}${padded}${second_sep}"
-      echo
-      echo "$content"
-    }
-    ```
-
-Now, let's import our required packages and instantiate our client, assistant, and thread.
-
-=== "Python"
-
-    ```python
-    import asyncio
-
-    import httpx
-    from langchain_core.messages import convert_to_messages
-    from langgraph_sdk import get_client
-
-    client = get_client(url=<DEPLOYMENT_URL>)
-    # Using the graph deployed with the name "agent"
-    assistant_id = "agent"
-    thread = await client.threads.create()
-    ```
-
-=== "Javascript"
-
-    ```js
-    import { Client } from "@langchain/langgraph-sdk";
-
-    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
-    // Using the graph deployed with the name "agent"
-    const assistantId = "agent";
-    const thread = await client.threads.create();
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-      --url <DEPLOYMENT_URL>/threads \
-      --header 'Content-Type: application/json'
-    ```
-
-Now let's run a thread with the multitask parameter set to "rollback":
-
-=== "Python"
-
-    ```python
-    # the first run will be rolled back
-    rolled_back_run = await client.runs.create(
-        thread["thread_id"],
-        assistant_id,
-        input={"messages": [{"role": "human", "content": "what's the weather in sf?"}]},
-    )
-    await asyncio.sleep(2)
-    run = await client.runs.create(
-        thread["thread_id"],
-        assistant_id,
-        input={"messages": [{"role": "human", "content": "what's the weather in nyc?"}]},
-        multitask_strategy="rollback",
-    )
-    # wait until the second run completes
-    await client.runs.join(thread["thread_id"], run["run_id"])
-    ```
-
-=== "Javascript"
-
-    ```js
-    // the first run will be interrupted
-    let rolledBackRun = await client.runs.create(
-      thread["thread_id"],
-      assistantId,
-      { input: { messages: [{ role: "human", content: "what's the weather in sf?" }] } }
-    );
-    await new Promise(resolve => setTimeout(resolve, 2000)); 
-
-    let run = await client.runs.create(
-      thread["thread_id"],
-      assistant_id,
-      { 
-        input: { messages: [{ role: "human", content: "what's the weather in nyc?" }] },
-        multitaskStrategy: "rollback" 
-      }
-    );
-
-    // wait until the second run completes
-    await client.runs.join(thread["thread_id"], run["run_id"]);
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-    --url <DEPLOY<ENT_URL>>/threads/<THREAD_ID>/runs \
-    --header 'Content-Type: application/json' \
-    --data "{
-      \"assistant_id\": \"agent\",
-      \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"what\'s the weather in sf?\"}]},
-    }" && sleep 2 && curl --request POST \
-    --url <DEPLOY<ENT_URL>>/threads/<THREAD_ID>/runs \
-    --header 'Content-Type: application/json' \
-    --data "{
-      \"assistant_id\": \"agent\",
-      \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"what\'s the weather in nyc?\"}]},
-      \"multitask_strategy\": \"rollback\"
-    }" && curl --request GET \
-    --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/<RUN_ID>/join
-    ```
-
-We can see that the thread has data only from the second run
-
-=== "Python"
-
-    ```python
-    state = await client.threads.get_state(thread["thread_id"])
-
-    for m in convert_to_messages(state["values"]["messages"]):
-        m.pretty_print()
-    ```
-
-=== "Javascript"
-
-    ```js
-    const state = await client.threads.getState(thread["thread_id"]);
-
-    for (const m of state['values']['messages']) {
-      prettyPrint(m);
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    source pretty_print.sh && curl --request GET \
-    --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/state | \
-    jq -c '.values.messages[]' | while read -r element; do
-        type=$(echo "$element" | jq -r '.type')
-        content=$(echo "$element" | jq -r '.content | if type == "array" then tostring else . end')
-        pretty_print "$type" "$content"
-    done
-    ```
-
-Output:
-
-    ================================ Human Message =================================
-    
-    what's the weather in nyc?
-    ================================== Ai Message ==================================
-    
-    [{'id': 'toolu_01JzPqefao1gxwajHQ3Yh3JD', 'input': {'query': 'weather in nyc'}, 'name': 'tavily_search_results_json', 'type': 'tool_use'}]
-    Tool Calls:
-      tavily_search_results_json (toolu_01JzPqefao1gxwajHQ3Yh3JD)
-     Call ID: toolu_01JzPqefao1gxwajHQ3Yh3JD
-      Args:
-        query: weather in nyc
-    ================================= Tool Message =================================
-    Name: tavily_search_results_json
-    
-    [{"url": "https://www.weatherapi.com/", "content": "{'location': {'name': 'New York', 'region': 'New York', 'country': 'United States of America', 'lat': 40.71, 'lon': -74.01, 'tz_id': 'America/New_York', 'localtime_epoch': 1718734479, 'localtime': '2024-06-18 14:14'}, 'current': {'last_updated_epoch': 1718733600, 'last_updated': '2024-06-18 14:00', 'temp_c': 29.4, 'temp_f': 84.9, 'is_day': 1, 'condition': {'text': 'Sunny', 'icon': '//cdn.weatherapi.com/weather/64x64/day/113.png', 'code': 1000}, 'wind_mph': 2.2, 'wind_kph': 3.6, 'wind_degree': 158, 'wind_dir': 'SSE', 'pressure_mb': 1025.0, 'pressure_in': 30.26, 'precip_mm': 0.0, 'precip_in': 0.0, 'humidity': 63, 'cloud': 0, 'feelslike_c': 31.3, 'feelslike_f': 88.3, 'windchill_c': 28.3, 'windchill_f': 82.9, 'heatindex_c': 29.6, 'heatindex_f': 85.3, 'dewpoint_c': 18.4, 'dewpoint_f': 65.2, 'vis_km': 16.0, 'vis_miles': 9.0, 'uv': 7.0, 'gust_mph': 16.5, 'gust_kph': 26.5}}"}]
-    ================================== Ai Message ==================================
-    
-    The weather API results show that the current weather in New York City is sunny with a temperature of around 85°F (29°C). The wind is light at around 2-3 mph from the south-southeast. Overall it looks like a nice sunny summer day in NYC.
-
-
-Verify that the original, rolled back run was deleted
-
-=== "Python"
-
-    ```python
-    try:
-        await client.runs.get(thread["thread_id"], rolled_back_run["run_id"])
-    except httpx.HTTPStatusError as _:
-        print("Original run was correctly deleted")
-    ```
-
-=== "Javascript"
-
-    ```js
-    try {
-      await client.runs.get(thread["thread_id"], rolledBackRun["run_id"]);
-    } catch (e) {
-      console.log("Original run was correctly deleted");
-    }
-    ```
-
-Output:
-
-    Original run was correctly deleted
-

docs/docs/cloud/how-tos/same-thread.md

@@ -1,310 +0,0 @@
-# How to run multiple agents on the same thread
-
-In LangGraph Cloud, a thread is not explicitly associated with a particular agent.
-This means that you can run multiple agents on the same thread, which allows a different agent to continue from an initial agent's progress.
-
-In this example, we will create two agents and then call them both on the same thread.
-You'll see that the second agent will respond using information from the [checkpoint](https://langchain-ai.github.io/langgraph/concepts/low_level/#checkpointer-state) generated in the thread by the first agent as context.
-
-=== "Python"
-
-    ```python
-    from langgraph_sdk import get_client
-
-    client = get_client(url=<DEPLOYMENT_URL>)
-
-    openai_assistant = await client.assistants.create(
-        graph_id="agent", config={"configurable": {"model_name": "openai"}}
-    )
-
-    # There should always be a default assistant with no configuration
-    assistants = await client.assistants.search()
-    default_assistant = [a for a in assistants if not a["config"]][0]
-    ```
-
-=== "Javascript"
-
-    ```js
-    import { Client } from "@langchain/langgraph-sdk";
-
-    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
-    
-    const openAIAssistant = await client.assistants.create(
-      { graphId: "agent", config: {"configurable": {"model_name": "openai"}}}
-    );
-
-    const assistants = await client.assistants.search();
-    const defaultAssistant = assistants.find(a => !a.config);
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-        --url <DEPLOYMENT_URL>/assistants \
-        --header 'Content-Type: application/json' \
-        --data '{
-            "graph_id": "agent",
-            "config": { "configurable": { "model_name": "openai" } }
-        }' && \
-    curl --request POST \
-        --url <DEPLOYMENT_URL>/assistants/search \
-        --header 'Content-Type: application/json' \
-        --data '{
-            "limit": 10,
-            "offset": 0
-        }' | jq -c 'map(select(.config == null or .config == {})) | .[0]'
-    ```
-
-We can see that these agents are different:
-
-=== "Python"
-
-    ```python
-    print(openai_assistant)
-    ```
-
-=== "Javascript"
-
-    ```js
-    console.log(openAIAssistant);
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request GET \
-        --url <DEPLOYMENT_URL>/assistants/<OPENAI_ASSISTANT_ID>
-    ```
-
-Output:
-
-    {
-        "assistant_id": "db87f39d-b2b1-4da8-ac65-cf81beb3c766",
-        "graph_id": "agent",
-        "created_at": "2024-08-30T21:18:51.850581+00:00",
-        "updated_at": "2024-08-30T21:18:51.850581+00:00",
-        "config": {
-            "configurable": {
-                "model_name": "openai"
-            }
-        },
-        "metadata": {}
-    }
-
-=== "Python"
-
-    ```python
-    print(default_assistant)
-    ```
-
-=== "Javascript"
-
-    ```js
-    console.log(defaultAssistant);
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request GET \
-        --url <DEPLOYMENT_URL>/assistants/<DEFAULT_ASSISTANT_ID>
-    ```
-
-Output:
-
-    {
-        "assistant_id": "fe096781-5601-53d2-b2f6-0d3403f7e9ca",
-        "graph_id": "agent",
-        "created_at": "2024-08-08T22:45:24.562906+00:00",
-        "updated_at": "2024-08-08T22:45:24.562906+00:00",
-        "config": {},
-        "metadata": {
-            "created_by": "system"
-        }
-    }
-
-We can now run the OpenAI assistant on the thread first.
-
-=== "Python"
-
-    ```python
-    thread = await client.threads.create()
-    input = {"messages": [{"role": "user", "content": "who made you?"}]}
-    async for event in client.runs.stream(
-        thread["thread_id"],
-        openai_assistant["assistant_id"],
-        input=input,
-        stream_mode="updates",
-    ):
-        print(f"Receiving event of type: {event.event}")
-        print(event.data)
-        print("\n\n")
-    ```
-
-=== "Javascript"
-
-    ```js
-    const thread = await client.threads.create();
-    let input =  {"messages": [{"role": "user", "content": "who made you?"}]}
-
-    const streamResponse = client.runs.stream(
-      thread["thread_id"],
-      openAIAssistant["assistant_id"],
-      {
-        input,
-        streamMode: "updates"
-      }
-    );
-    for await (const event of streamResponse) {
-      console.log(`Receiving event of type: ${event.event}`);
-      console.log(event.data);
-      console.log("\n\n");
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    thread_id=$(curl --request POST \
-        --url <DEPLOYMENT_URL>/threads \
-        --header 'Content-Type: application/json' \
-        --data '{}' | jq -r '.thread_id') && \
-    curl --request POST \
-        --url "<DEPLOYMENT_URL>/threads/${thread_id}/runs/stream" \
-        --header 'Content-Type: application/json' \
-        --data '{
-            "assistant_id": <OPENAI_ASSISTANT_ID>,
-            "input": {
-                "messages": [
-                    {
-                        "role": "human",
-                        "content": "who made you?"
-                    }
-                ]
-            },
-            "stream_mode": [
-                "updates"
-            ]
-        }' | \
-        sed 's/\r$//' | \
-        awk '
-        /^event:/ {
-            if (data_content != "") {
-                print data_content "\n"
-            }
-            sub(/^event: /, "Receiving event of type: ", $0)
-            printf "%s...\n", $0
-            data_content = ""
-        }
-        /^data:/ {
-            sub(/^data: /, "", $0)
-            data_content = $0
-        }
-        END {
-            if (data_content != "") {
-                print data_content "\n\n"
-            }
-        }
-    '
-    ```
-
-Output:
-
-    Receiving event of type: metadata
-    {'run_id': '1ef671c5-fb83-6e70-b698-44dba2d9213e'}
-
-
-    Receiving event of type: updates
-    {'agent': {'messages': [{'content': 'I was created by OpenAI, a research organization focused on developing and advancing artificial intelligence technology.', 'additional_kwargs': {}, 'response_metadata': {'finish_reason': 'stop', 'model_name': 'gpt-4o-2024-05-13', 'system_fingerprint': 'fp_157b3831f5'}, 'type': 'ai', 'name': None, 'id': 'run-f5735b86-b80d-4c71-8dc3-4782b5a9c7c8', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}}
-
-Now, we can run it on the default assistant and see that this second assistant is aware of the initial question, and can answer the question, "and you?":
-
-=== "Python"
-
-    ```python
-    input = {"messages": [{"role": "user", "content": "and you?"}]}
-    async for event in client.runs.stream(
-        thread["thread_id"],
-        default_assistant["assistant_id"],
-        input=input,
-        stream_mode="updates",
-    ):
-        print(f"Receiving event of type: {event.event}")
-        print(event.data)
-        print("\n\n")
-    ```
-
-=== "Javascript"
-
-    ```js
-    let input =  {"messages": [{"role": "user", "content": "and you?"}]}
-
-    const streamResponse = client.runs.stream(
-      thread["thread_id"],
-      defaultAssistant["assistant_id"],
-      {
-        input,
-        streamMode: "updates"
-      }
-    );
-    for await (const event of streamResponse) {
-      console.log(`Receiving event of type: ${event.event}`);
-      console.log(event.data);
-      console.log("\n\n");
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-        --header 'Content-Type: application/json' \
-        --data '{
-            "assistant_id": <DEFAULT_ASSISTANT_ID>,
-            "input": {
-                "messages": [
-                    {
-                        "role": "human",
-                        "content": "and you?"
-                    }
-                ]
-            },
-            "stream_mode": [
-                "updates"
-            ]
-        }' | \
-        sed 's/\r$//' | \
-        awk '
-        /^event:/ {
-            if (data_content != "") {
-                print data_content "\n"
-            }
-            sub(/^event: /, "Receiving event of type: ", $0)
-            printf "%s...\n", $0
-            data_content = ""
-        }
-        /^data:/ {
-            sub(/^data: /, "", $0)
-            data_content = $0
-        }
-        END {
-            if (data_content != "") {
-                print data_content "\n\n"
-            }
-        }
-    '
-    ```
-
-Output:
-
-    Receiving event of type: metadata
-    {'run_id': '1ef6722d-80b3-6fbb-9324-253796b1cd13'}
-
-
-    Receiving event of type: updates
-    {'agent': {'messages': [{'content': [{'text': 'I am an artificial intelligence created by Anthropic, not by OpenAI. I should not have stated that OpenAI created me, as that is incorrect. Anthropic is the company that developed and trained me using advanced language models and AI technology. I will be more careful about providing accurate information regarding my origins in the future.', 'type': 'text', 'index': 0}], 'additional_kwargs': {}, 'response_metadata': {'stop_reason': 'end_turn', 'stop_sequence': None}, 'type': 'ai', 'name': None, 'id': 'run-ebaacf62-9dd9-4165-9535-db432e4793ec', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': {'input_tokens': 302, 'output_tokens': 72, 'total_tokens': 374}}]}}
-
-
-

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

@@ -1,180 +0,0 @@
-# Stateless Runs
-
-Most of the time, you provide a `thread_id` to your client when you run your graph in order to keep track of prior runs through the persistent state implemented in LangGraph Cloud. However, if you don't need to persist the runs you don't need to use the built in persistent state and can create stateless runs.
-
-## Setup
-
-First, let's setup our client:
-
-=== "Python"
-
-    ```python
-    from langgraph_sdk import get_client
-
-    client = get_client(url=<DEPLOYMENT_URL>)
-    # Using the graph deployed with the name "agent"
-    assistant_id = "agent"
-    # create thread
-    thread = await client.threads.create()
-    ```
-
-=== "Javascript"
-
-    ```js
-    import { Client } from "@langchain/langgraph-sdk";
-
-    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
-    // Using the graph deployed with the name "agent"
-    const assistantId = "agent";
-    // create thread
-    const thread = await client.threads.create();
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-        --url <DEPLOYMENT_URL>/assistants/search \
-        --header 'Content-Type: application/json' \
-        --data '{
-            "limit": 10,
-            "offset": 0
-        }' | jq -c 'map(select(.config == null or .config == {})) | .[0].graph_id' && \
-    curl --request POST \
-        --url <DEPLOYMENT_URL>/threads \
-        --header 'Content-Type: application/json' \
-        --data '{}'
-    ```
-
-## Stateless streaming
-
-We can stream the results of a stateless run in an almost identical fashion to how we stream from a run with the state attribute, but instead of passing a value to the `thread_id` parameter, we pass `None`:
-
-=== "Python"
-
-    ```python
-    input = {
-        "messages": [
-            {"role": "user", "content": "Hello! My name is Bagatur and I am 26 years old."}
-        ]
-    }
-
-    async for chunk in client.runs.stream(
-        # Don't pass in a thread_id and the stream will be stateless
-        None,
-        assistant_id,
-        input=input,
-        stream_mode="updates",
-    ):
-        if chunk.data and "run_id" not in chunk.data:
-            print(chunk.data)
-    ```
-
-=== "Javascript"
-
-    ```js
-    let input = {
-      messages: [
-        { role: "user", content: "Hello! My name is Bagatur and I am 26 years old." }
-      ]
-    };
-
-    const streamResponse = client.runs.stream(
-      // Don't pass in a thread_id and the stream will be stateless
-      null,
-      assistantId,
-      {
-        input,
-        streamMode: "updates"
-      }
-    );
-    for await (const chunk of streamResponse) {
-      if (chunk.data && !("run_id" in chunk.data)) {
-        console.log(chunk.data);
-      }
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-        --header 'Content-Type: application/json' \
-        --data "{
-            \"assistant_id\": \"agent\",
-            \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"Hello! My name is Bagatur and I am 26 years old.\"}]},
-            \"stream_mode\": [
-                \"updates\"
-            ]
-        }" | jq -c 'select(.data and (.data | has("run_id") | not)) | .data'
-    ```
-
-Output:
-
-    {'agent': {'messages': [{'content': "Hello Bagatur! It's nice to meet you. Thank you for introducing yourself and sharing your age. Is there anything specific you'd like to know or discuss? I'm here to help with any questions or topics you're interested in.", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-489ec573-1645-4ce2-a3b8-91b391d50a71', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}}
-
-## Waiting for stateless results
-
-In addition to streaming, you can also wait for a stateless result by using the `.wait` function like follows:
-
-=== "Python"
-
-    ```python
-    stateless_run_result = await client.runs.wait(
-        None,
-        assistant_id,
-        input=input,
-    )
-    print(stateless_run_result)
-    ```
-
-=== "Javascript"
-
-    ```js
-    let statelessRunResult = await client.runs.wait(
-      null,
-      assistantId,
-      { input: input }
-    );
-    console.log(statelessRunResult);
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-        --url <DEPLOYMENT_URL>/runs/runs/wait \
-        --header 'Content-Type: application/json' \
-        --data '{
-            "assistant_id": <ASSISTANT_IDD>,
-        }'
-    ```
-
-Output:
-
-    {
-        'messages': [
-            {
-                'content': 'Hello! My name is Bagatur and I am 26 years old.',
-                'additional_kwargs': {},
-                'response_metadata': {},
-                'type': 'human',
-                'name': None,
-                'id': '5e088543-62c2-43de-9d95-6086ad7f8b48',
-                'example': False}
-            ,
-            {
-                'content': "Hello Bagatur! It's nice to meet you. Thank you for introducing yourself and sharing your age. Is there anything specific you'd like to know or discuss? I'm here to help with any questions or topics you'd like to explore.",
-                'additional_kwargs': {},
-                'response_metadata': {},
-                'type': 'ai',
-                'name': None,
-                'id': 'run-d6361e8d-4d4c-45bd-ba47-39520257f773',
-                'example': False,
-                'tool_calls': [],
-                'invalid_tool_calls': [],
-                'usage_metadata': None
-            }
-        ]
-    }

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

@@ -1,416 +0,0 @@
-# How to stream events
-
-This guide covers how to stream events from your graph (`stream_mode="events"`). Depending on the use case and user experience of your LangGraph application, your application may process event types differently. Read more about events in this [conceptual guide](https://langchain-ai.github.io/langgraph/concepts/low_level/#astream_events-for-streaming-tokens-of-llm-calls).
-
-=== "Python"
-
-    ```python
-    from langgraph_sdk import get_client
-
-    client = get_client(url=<DEPLOYMENT_URL>)
-    # Using the graph deployed with the name "agent"
-    assistant_id = "agent"
-    # create thread
-    thread = await client.threads.create()
-    print(thread)
-    ```
-
-=== "Javascript"
-
-    ```js
-    import { Client } from "@langchain/langgraph-sdk";
-
-    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
-    // Using the graph deployed with the name "agent"
-    const assistantID = "agent";
-    // create thread
-    const thread = await client.threads.create();
-    console.log(thread);
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-      --url <DEPLOYMENT_URL>/threads \
-      --header 'Content-Type: application/json'
-    ```
-
-Output:
-
-
-    {
-        'thread_id': '3f4c64e0-f792-4a5e-aa07-a4404e06e0bd',
-        'created_at': '2024-06-24T22:16:29.301522+00:00',
-        'updated_at': '2024-06-24T22:16:29.301522+00:00',
-        'metadata': {},
-        'status': 'idle',
-        'config': {},
-        'values': None
-    }
-
-
-
-Streaming events produces responses containing an `event` key (in addition to other keys such as `data`). See the LangChain [`Runnable.astream_events()` reference](https://api.python.langchain.com/en/latest/runnables/langchain_core.runnables.base.Runnable.html#langchain_core.runnables.base.Runnable.astream_events) for all event types.
-
-
-=== "Python"
-
-    ```python
-    # create input
-    input = {
-        "messages": [
-            {
-                "role": "human",
-                "content": "What's the weather in SF?",
-            }
-        ]
-    }
-
-    # stream events
-    async for chunk in client.runs.stream(
-        thread_id=thread["thread_id"],
-        assistant_id=assistant_id,
-        input=input,
-        stream_mode="events",
-    ):
-        print(f"Receiving new event of type: {chunk.event}...")
-        print(chunk.data)
-        print("\n\n")
-    ```
-
-=== "Javascript"
-
-    ```js
-    // create input
-    const input = {
-      "messages": [
-        {
-          "role": "human",
-          "content": "What's the weather in SF?",
-        }
-      ]
-    }
-
-    // stream events
-    const streamResponse = client.runs.stream(
-      thread["thread_id"],
-      assistantID,
-      {
-        input,
-        streamMode: "events"
-      }
-    );
-    for await (const chunk of streamResponse) {
-      console.log(`Receiving new event of type: ${chunk.event}...`);
-      console.log(chunk.data);
-      console.log("\n\n");
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-     --header 'Content-Type: application/json' \
-     --data "{
-       \"assistant_id\": \"agent\",
-       \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"What's the weather in sf\"}]},
-       \"stream_mode\": [
-         \"events\"
-       ]
-     }" | \
-     sed 's/\r$//' | \
-     awk '
-     /^event:/ {
-         if (data_content != "") {
-             print data_content "\n"
-         }
-         sub(/^event: /, "Receiving event of type: ", $0)
-         printf "%s...\n", $0
-         data_content = ""
-     }
-     /^data:/ {
-         sub(/^data: /, "", $0)
-         data_content = $0
-     }
-     END {
-         if (data_content != "") {
-             print data_content "\n"
-         }
-     }
-     ' 
-    ```
-
-Output:
-
-    Receiving new event of type: metadata...
-    {'run_id': '1ef301a5-b867-67de-9e9e-a32e53c5b1f8'}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_start', 'data': {'input': {'messages': [{'role': 'human', 'content': "What's the weather in SF?"}]}}, 'name': 'LangGraph', 'tags': [], 'run_id': '1ef301a5-b867-67de-9e9e-a32e53c5b1f8', 'metadata': {'graph_id': 'agent', 'created_by': 'system', 'run_id': '1ef301a5-b867-67de-9e9e-a32e53c5b1f8', 'user_id': '', 'thread_id': '7196a3aa-763c-4a8d-bfda-12fbfe1cd727', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'parent_ids': []}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_start', 'data': {}, 'name': 'agent', 'tags': ['graph:step:6'], 'run_id': '7bb08493-d507-4e28-b9e6-4a5eda9d04f0', 'metadata': {'graph_id': 'agent', 'created_by': 'system', 'run_id': '1ef301a5-b867-67de-9e9e-a32e53c5b1f8', 'user_id': '', 'thread_id': '7196a3aa-763c-4a8d-bfda-12fbfe1cd727', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 6, 'langgraph_node': 'agent', 'langgraph_triggers': ['start:agent'], 'langgraph_task_idx': 0}, 'parent_ids': ['1ef301a5-b867-67de-9e9e-a32e53c5b1f8']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chat_model_start', 'data': {'input': {'messages': [[{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '51f2874d-f8c7-4040-8b3b-8f15429a56ae', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-5f556aa0-26ea-42e2-b9e4-7ece3a00974e', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '1faf5dd0-ae97-4235-963f-5075083a027a', 'tool_call_id': 'tool_call_id'}, {'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-ae383611-6a42-475a-912a-09d5972e9e94', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'c67e08e6-e7af-4c4a-aa5e-50c8340ae341', 'example': False}]]}}, 'name': 'FakeListChatModel', 'tags': ['seq:step:1'], 'run_id': 'cb1b98c1-c9e2-4a30-9d7a-38fa1f6224bd', 'metadata': {'graph_id': 'agent', 'created_by': 'system', 'run_id': '1ef301a5-b867-67de-9e9e-a32e53c5b1f8', 'user_id': '', 'thread_id': '7196a3aa-763c-4a8d-bfda-12fbfe1cd727', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 6, 'langgraph_node': 'agent', 'langgraph_triggers': ['start:agent'], 'langgraph_task_idx': 0, 'ls_model_type': 'chat'}, 'parent_ids': ['1ef301a5-b867-67de-9e9e-a32e53c5b1f8', '7bb08493-d507-4e28-b9e6-4a5eda9d04f0']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chat_model_stream', 'data': {'chunk': {'content': 'b', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'AIMessageChunk', 'name': None, 'id': 'run-cb1b98c1-c9e2-4a30-9d7a-38fa1f6224bd', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None, 'tool_call_chunks': []}}, 'run_id': 'cb1b98c1-c9e2-4a30-9d7a-38fa1f6224bd', 'name': 'FakeListChatModel', 'tags': ['seq:step:1'], 'metadata': {'graph_id': 'agent', 'created_by': 'system', 'run_id': '1ef301a5-b867-67de-9e9e-a32e53c5b1f8', 'user_id': '', 'thread_id': '7196a3aa-763c-4a8d-bfda-12fbfe1cd727', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 6, 'langgraph_node': 'agent', 'langgraph_triggers': ['start:agent'], 'langgraph_task_idx': 0, 'ls_model_type': 'chat'}, 'parent_ids': ['1ef301a5-b867-67de-9e9e-a32e53c5b1f8', '7bb08493-d507-4e28-b9e6-4a5eda9d04f0']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chat_model_stream', 'data': {'chunk': {'content': 'e', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'AIMessageChunk', 'name': None, 'id': 'run-cb1b98c1-c9e2-4a30-9d7a-38fa1f6224bd', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None, 'tool_call_chunks': []}}, 'run_id': 'cb1b98c1-c9e2-4a30-9d7a-38fa1f6224bd', 'name': 'FakeListChatModel', 'tags': ['seq:step:1'], 'metadata': {'graph_id': 'agent', 'created_by': 'system', 'run_id': '1ef301a5-b867-67de-9e9e-a32e53c5b1f8', 'user_id': '', 'thread_id': '7196a3aa-763c-4a8d-bfda-12fbfe1cd727', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 6, 'langgraph_node': 'agent', 'langgraph_triggers': ['start:agent'], 'langgraph_task_idx': 0, 'ls_model_type': 'chat'}, 'parent_ids': ['1ef301a5-b867-67de-9e9e-a32e53c5b1f8', '7bb08493-d507-4e28-b9e6-4a5eda9d04f0']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chat_model_stream', 'data': {'chunk': {'content': 'g', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'AIMessageChunk', 'name': None, 'id': 'run-cb1b98c1-c9e2-4a30-9d7a-38fa1f6224bd', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None, 'tool_call_chunks': []}}, 'run_id': 'cb1b98c1-c9e2-4a30-9d7a-38fa1f6224bd', 'name': 'FakeListChatModel', 'tags': ['seq:step:1'], 'metadata': {'graph_id': 'agent', 'created_by': 'system', 'run_id': '1ef301a5-b867-67de-9e9e-a32e53c5b1f8', 'user_id': '', 'thread_id': '7196a3aa-763c-4a8d-bfda-12fbfe1cd727', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 6, 'langgraph_node': 'agent', 'langgraph_triggers': ['start:agent'], 'langgraph_task_idx': 0, 'ls_model_type': 'chat'}, 'parent_ids': ['1ef301a5-b867-67de-9e9e-a32e53c5b1f8', '7bb08493-d507-4e28-b9e6-4a5eda9d04f0']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chat_model_stream', 'data': {'chunk': {'content': 'i', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'AIMessageChunk', 'name': None, 'id': 'run-cb1b98c1-c9e2-4a30-9d7a-38fa1f6224bd', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None, 'tool_call_chunks': []}}, 'run_id': 'cb1b98c1-c9e2-4a30-9d7a-38fa1f6224bd', 'name': 'FakeListChatModel', 'tags': ['seq:step:1'], 'metadata': {'graph_id': 'agent', 'created_by': 'system', 'run_id': '1ef301a5-b867-67de-9e9e-a32e53c5b1f8', 'user_id': '', 'thread_id': '7196a3aa-763c-4a8d-bfda-12fbfe1cd727', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 6, 'langgraph_node': 'agent', 'langgraph_triggers': ['start:agent'], 'langgraph_task_idx': 0, 'ls_model_type': 'chat'}, 'parent_ids': ['1ef301a5-b867-67de-9e9e-a32e53c5b1f8', '7bb08493-d507-4e28-b9e6-4a5eda9d04f0']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chat_model_stream', 'data': {'chunk': {'content': 'n', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'AIMessageChunk', 'name': None, 'id': 'run-cb1b98c1-c9e2-4a30-9d7a-38fa1f6224bd', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None, 'tool_call_chunks': []}}, 'run_id': 'cb1b98c1-c9e2-4a30-9d7a-38fa1f6224bd', 'name': 'FakeListChatModel', 'tags': ['seq:step:1'], 'metadata': {'graph_id': 'agent', 'created_by': 'system', 'run_id': '1ef301a5-b867-67de-9e9e-a32e53c5b1f8', 'user_id': '', 'thread_id': '7196a3aa-763c-4a8d-bfda-12fbfe1cd727', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 6, 'langgraph_node': 'agent', 'langgraph_triggers': ['start:agent'], 'langgraph_task_idx': 0, 'ls_model_type': 'chat'}, 'parent_ids': ['1ef301a5-b867-67de-9e9e-a32e53c5b1f8', '7bb08493-d507-4e28-b9e6-4a5eda9d04f0']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chat_model_end', 'data': {'output': {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-cb1b98c1-c9e2-4a30-9d7a-38fa1f6224bd', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, 'input': {'messages': [[{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '51f2874d-f8c7-4040-8b3b-8f15429a56ae', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-5f556aa0-26ea-42e2-b9e4-7ece3a00974e', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '1faf5dd0-ae97-4235-963f-5075083a027a', 'tool_call_id': 'tool_call_id'}, {'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-ae383611-6a42-475a-912a-09d5972e9e94', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'c67e08e6-e7af-4c4a-aa5e-50c8340ae341', 'example': False}]]}}, 'run_id': 'cb1b98c1-c9e2-4a30-9d7a-38fa1f6224bd', 'name': 'FakeListChatModel', 'tags': ['seq:step:1'], 'metadata': {'graph_id': 'agent', 'created_by': 'system', 'run_id': '1ef301a5-b867-67de-9e9e-a32e53c5b1f8', 'user_id': '', 'thread_id': '7196a3aa-763c-4a8d-bfda-12fbfe1cd727', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 6, 'langgraph_node': 'agent', 'langgraph_triggers': ['start:agent'], 'langgraph_task_idx': 0, 'ls_model_type': 'chat'}, 'parent_ids': ['1ef301a5-b867-67de-9e9e-a32e53c5b1f8', '7bb08493-d507-4e28-b9e6-4a5eda9d04f0']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_start', 'data': {'input': {'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '51f2874d-f8c7-4040-8b3b-8f15429a56ae', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-5f556aa0-26ea-42e2-b9e4-7ece3a00974e', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '1faf5dd0-ae97-4235-963f-5075083a027a', 'tool_call_id': 'tool_call_id'}, {'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-ae383611-6a42-475a-912a-09d5972e9e94', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'c67e08e6-e7af-4c4a-aa5e-50c8340ae341', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-cb1b98c1-c9e2-4a30-9d7a-38fa1f6224bd', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}], 'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}}}, 'name': 'should_continue', 'tags': ['seq:step:3'], 'run_id': 'c7fe4d2d-3fb8-4e53-946d-03de13527853', 'metadata': {'graph_id': 'agent', 'created_by': 'system', 'run_id': '1ef301a5-b867-67de-9e9e-a32e53c5b1f8', 'user_id': '', 'thread_id': '7196a3aa-763c-4a8d-bfda-12fbfe1cd727', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 6, 'langgraph_node': 'agent', 'langgraph_triggers': ['start:agent'], 'langgraph_task_idx': 0}, 'parent_ids': ['1ef301a5-b867-67de-9e9e-a32e53c5b1f8', '7bb08493-d507-4e28-b9e6-4a5eda9d04f0']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_end', 'data': {'output': 'tool', 'input': {'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '51f2874d-f8c7-4040-8b3b-8f15429a56ae', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-5f556aa0-26ea-42e2-b9e4-7ece3a00974e', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '1faf5dd0-ae97-4235-963f-5075083a027a', 'tool_call_id': 'tool_call_id'}, {'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-ae383611-6a42-475a-912a-09d5972e9e94', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'c67e08e6-e7af-4c4a-aa5e-50c8340ae341', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-cb1b98c1-c9e2-4a30-9d7a-38fa1f6224bd', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}], 'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}}}, 'run_id': 'c7fe4d2d-3fb8-4e53-946d-03de13527853', 'name': 'should_continue', 'tags': ['seq:step:3'], 'metadata': {'graph_id': 'agent', 'created_by': 'system', 'run_id': '1ef301a5-b867-67de-9e9e-a32e53c5b1f8', 'user_id': '', 'thread_id': '7196a3aa-763c-4a8d-bfda-12fbfe1cd727', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 6, 'langgraph_node': 'agent', 'langgraph_triggers': ['start:agent'], 'langgraph_task_idx': 0}, 'parent_ids': ['1ef301a5-b867-67de-9e9e-a32e53c5b1f8', '7bb08493-d507-4e28-b9e6-4a5eda9d04f0']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_stream', 'run_id': '7bb08493-d507-4e28-b9e6-4a5eda9d04f0', 'name': 'agent', 'tags': ['graph:step:6'], 'metadata': {'graph_id': 'agent', 'created_by': 'system', 'run_id': '1ef301a5-b867-67de-9e9e-a32e53c5b1f8', 'user_id': '', 'thread_id': '7196a3aa-763c-4a8d-bfda-12fbfe1cd727', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 6, 'langgraph_node': 'agent', 'langgraph_triggers': ['start:agent'], 'langgraph_task_idx': 0}, 'data': {'chunk': {'messages': [{'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-cb1b98c1-c9e2-4a30-9d7a-38fa1f6224bd', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}], 'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}}}, 'parent_ids': ['1ef301a5-b867-67de-9e9e-a32e53c5b1f8']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_end', 'data': {'output': {'messages': [{'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-cb1b98c1-c9e2-4a30-9d7a-38fa1f6224bd', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}], 'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}}, 'input': {'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}, 'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '51f2874d-f8c7-4040-8b3b-8f15429a56ae', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-5f556aa0-26ea-42e2-b9e4-7ece3a00974e', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '1faf5dd0-ae97-4235-963f-5075083a027a', 'tool_call_id': 'tool_call_id'}, {'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-ae383611-6a42-475a-912a-09d5972e9e94', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'c67e08e6-e7af-4c4a-aa5e-50c8340ae341', 'example': False}], 'sleep': None}}, 'run_id': '7bb08493-d507-4e28-b9e6-4a5eda9d04f0', 'name': 'agent', 'tags': ['graph:step:6'], 'metadata': {'graph_id': 'agent', 'created_by': 'system', 'run_id': '1ef301a5-b867-67de-9e9e-a32e53c5b1f8', 'user_id': '', 'thread_id': '7196a3aa-763c-4a8d-bfda-12fbfe1cd727', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 6, 'langgraph_node': 'agent', 'langgraph_triggers': ['start:agent'], 'langgraph_task_idx': 0}, 'parent_ids': ['1ef301a5-b867-67de-9e9e-a32e53c5b1f8']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_start', 'data': {}, 'name': 'tool', 'tags': ['graph:step:7'], 'run_id': 'f044fd3d-7271-488f-b8aa-e01572ff9112', 'metadata': {'graph_id': 'agent', 'created_by': 'system', 'run_id': '1ef301a5-b867-67de-9e9e-a32e53c5b1f8', 'user_id': '', 'thread_id': '7196a3aa-763c-4a8d-bfda-12fbfe1cd727', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 7, 'langgraph_node': 'tool', 'langgraph_triggers': ['branch:agent:should_continue:tool'], 'langgraph_task_idx': 0}, 'parent_ids': ['1ef301a5-b867-67de-9e9e-a32e53c5b1f8']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_stream', 'run_id': 'f044fd3d-7271-488f-b8aa-e01572ff9112', 'name': 'tool', 'tags': ['graph:step:7'], 'metadata': {'graph_id': 'agent', 'created_by': 'system', 'run_id': '1ef301a5-b867-67de-9e9e-a32e53c5b1f8', 'user_id': '', 'thread_id': '7196a3aa-763c-4a8d-bfda-12fbfe1cd727', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 7, 'langgraph_node': 'tool', 'langgraph_triggers': ['branch:agent:should_continue:tool'], 'langgraph_task_idx': 0}, 'data': {'chunk': {'messages': [{'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': None, 'tool_call_id': 'tool_call_id'}]}}, 'parent_ids': ['1ef301a5-b867-67de-9e9e-a32e53c5b1f8']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_end', 'data': {'output': {'messages': [{'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '1c9a16d2-5f0a-4eba-a0d2-240484a4ce7e', 'tool_call_id': 'tool_call_id'}]}, 'input': {'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}, 'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '51f2874d-f8c7-4040-8b3b-8f15429a56ae', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-5f556aa0-26ea-42e2-b9e4-7ece3a00974e', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '1faf5dd0-ae97-4235-963f-5075083a027a', 'tool_call_id': 'tool_call_id'}, {'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-ae383611-6a42-475a-912a-09d5972e9e94', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'c67e08e6-e7af-4c4a-aa5e-50c8340ae341', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-cb1b98c1-c9e2-4a30-9d7a-38fa1f6224bd', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}], 'sleep': None}}, 'run_id': 'f044fd3d-7271-488f-b8aa-e01572ff9112', 'name': 'tool', 'tags': ['graph:step:7'], 'metadata': {'graph_id': 'agent', 'created_by': 'system', 'run_id': '1ef301a5-b867-67de-9e9e-a32e53c5b1f8', 'user_id': '', 'thread_id': '7196a3aa-763c-4a8d-bfda-12fbfe1cd727', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 7, 'langgraph_node': 'tool', 'langgraph_triggers': ['branch:agent:should_continue:tool'], 'langgraph_task_idx': 0}, 'parent_ids': ['1ef301a5-b867-67de-9e9e-a32e53c5b1f8']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_start', 'data': {}, 'name': 'agent', 'tags': ['graph:step:8'], 'run_id': '1f4f95d0-0ce1-4061-85d4-946446bbd3e5', 'metadata': {'graph_id': 'agent', 'created_by': 'system', 'run_id': '1ef301a5-b867-67de-9e9e-a32e53c5b1f8', 'user_id': '', 'thread_id': '7196a3aa-763c-4a8d-bfda-12fbfe1cd727', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 8, 'langgraph_node': 'agent', 'langgraph_triggers': ['tool'], 'langgraph_task_idx': 0}, 'parent_ids': ['1ef301a5-b867-67de-9e9e-a32e53c5b1f8']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chat_model_start', 'data': {'input': {'messages': [[{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '51f2874d-f8c7-4040-8b3b-8f15429a56ae', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-5f556aa0-26ea-42e2-b9e4-7ece3a00974e', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '1faf5dd0-ae97-4235-963f-5075083a027a', 'tool_call_id': 'tool_call_id'}, {'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-ae383611-6a42-475a-912a-09d5972e9e94', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'c67e08e6-e7af-4c4a-aa5e-50c8340ae341', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-cb1b98c1-c9e2-4a30-9d7a-38fa1f6224bd', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '1c9a16d2-5f0a-4eba-a0d2-240484a4ce7e', 'tool_call_id': 'tool_call_id'}]]}}, 'name': 'FakeListChatModel', 'tags': ['seq:step:1'], 'run_id': '028a68fb-6435-4b46-a156-c3326f73985c', 'metadata': {'graph_id': 'agent', 'created_by': 'system', 'run_id': '1ef301a5-b867-67de-9e9e-a32e53c5b1f8', 'user_id': '', 'thread_id': '7196a3aa-763c-4a8d-bfda-12fbfe1cd727', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 8, 'langgraph_node': 'agent', 'langgraph_triggers': ['tool'], 'langgraph_task_idx': 0, 'ls_model_type': 'chat'}, 'parent_ids': ['1ef301a5-b867-67de-9e9e-a32e53c5b1f8', '1f4f95d0-0ce1-4061-85d4-946446bbd3e5']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chat_model_stream', 'data': {'chunk': {'content': 'e', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'AIMessageChunk', 'name': None, 'id': 'run-028a68fb-6435-4b46-a156-c3326f73985c', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None, 'tool_call_chunks': []}}, 'run_id': '028a68fb-6435-4b46-a156-c3326f73985c', 'name': 'FakeListChatModel', 'tags': ['seq:step:1'], 'metadata': {'graph_id': 'agent', 'created_by': 'system', 'run_id': '1ef301a5-b867-67de-9e9e-a32e53c5b1f8', 'user_id': '', 'thread_id': '7196a3aa-763c-4a8d-bfda-12fbfe1cd727', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 8, 'langgraph_node': 'agent', 'langgraph_triggers': ['tool'], 'langgraph_task_idx': 0, 'ls_model_type': 'chat'}, 'parent_ids': ['1ef301a5-b867-67de-9e9e-a32e53c5b1f8', '1f4f95d0-0ce1-4061-85d4-946446bbd3e5']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chat_model_stream', 'data': {'chunk': {'content': 'n', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'AIMessageChunk', 'name': None, 'id': 'run-028a68fb-6435-4b46-a156-c3326f73985c', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None, 'tool_call_chunks': []}}, 'run_id': '028a68fb-6435-4b46-a156-c3326f73985c', 'name': 'FakeListChatModel', 'tags': ['seq:step:1'], 'metadata': {'graph_id': 'agent', 'created_by': 'system', 'run_id': '1ef301a5-b867-67de-9e9e-a32e53c5b1f8', 'user_id': '', 'thread_id': '7196a3aa-763c-4a8d-bfda-12fbfe1cd727', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 8, 'langgraph_node': 'agent', 'langgraph_triggers': ['tool'], 'langgraph_task_idx': 0, 'ls_model_type': 'chat'}, 'parent_ids': ['1ef301a5-b867-67de-9e9e-a32e53c5b1f8', '1f4f95d0-0ce1-4061-85d4-946446bbd3e5']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chat_model_stream', 'data': {'chunk': {'content': 'd', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'AIMessageChunk', 'name': None, 'id': 'run-028a68fb-6435-4b46-a156-c3326f73985c', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None, 'tool_call_chunks': []}}, 'run_id': '028a68fb-6435-4b46-a156-c3326f73985c', 'name': 'FakeListChatModel', 'tags': ['seq:step:1'], 'metadata': {'graph_id': 'agent', 'created_by': 'system', 'run_id': '1ef301a5-b867-67de-9e9e-a32e53c5b1f8', 'user_id': '', 'thread_id': '7196a3aa-763c-4a8d-bfda-12fbfe1cd727', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 8, 'langgraph_node': 'agent', 'langgraph_triggers': ['tool'], 'langgraph_task_idx': 0, 'ls_model_type': 'chat'}, 'parent_ids': ['1ef301a5-b867-67de-9e9e-a32e53c5b1f8', '1f4f95d0-0ce1-4061-85d4-946446bbd3e5']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chat_model_end', 'data': {'output': {'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-028a68fb-6435-4b46-a156-c3326f73985c', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, 'input': {'messages': [[{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '51f2874d-f8c7-4040-8b3b-8f15429a56ae', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-5f556aa0-26ea-42e2-b9e4-7ece3a00974e', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '1faf5dd0-ae97-4235-963f-5075083a027a', 'tool_call_id': 'tool_call_id'}, {'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-ae383611-6a42-475a-912a-09d5972e9e94', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'c67e08e6-e7af-4c4a-aa5e-50c8340ae341', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-cb1b98c1-c9e2-4a30-9d7a-38fa1f6224bd', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '1c9a16d2-5f0a-4eba-a0d2-240484a4ce7e', 'tool_call_id': 'tool_call_id'}]]}}, 'run_id': '028a68fb-6435-4b46-a156-c3326f73985c', 'name': 'FakeListChatModel', 'tags': ['seq:step:1'], 'metadata': {'graph_id': 'agent', 'created_by': 'system', 'run_id': '1ef301a5-b867-67de-9e9e-a32e53c5b1f8', 'user_id': '', 'thread_id': '7196a3aa-763c-4a8d-bfda-12fbfe1cd727', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 8, 'langgraph_node': 'agent', 'langgraph_triggers': ['tool'], 'langgraph_task_idx': 0, 'ls_model_type': 'chat'}, 'parent_ids': ['1ef301a5-b867-67de-9e9e-a32e53c5b1f8', '1f4f95d0-0ce1-4061-85d4-946446bbd3e5']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_start', 'data': {'input': {'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '51f2874d-f8c7-4040-8b3b-8f15429a56ae', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-5f556aa0-26ea-42e2-b9e4-7ece3a00974e', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '1faf5dd0-ae97-4235-963f-5075083a027a', 'tool_call_id': 'tool_call_id'}, {'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-ae383611-6a42-475a-912a-09d5972e9e94', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'c67e08e6-e7af-4c4a-aa5e-50c8340ae341', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-cb1b98c1-c9e2-4a30-9d7a-38fa1f6224bd', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '1c9a16d2-5f0a-4eba-a0d2-240484a4ce7e', 'tool_call_id': 'tool_call_id'}, {'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-028a68fb-6435-4b46-a156-c3326f73985c', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}], 'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}}}, 'name': 'should_continue', 'tags': ['seq:step:3'], 'run_id': 'f2b2dfaf-475d-422b-8bf5-02a31bcc7d1a', 'metadata': {'graph_id': 'agent', 'created_by': 'system', 'run_id': '1ef301a5-b867-67de-9e9e-a32e53c5b1f8', 'user_id': '', 'thread_id': '7196a3aa-763c-4a8d-bfda-12fbfe1cd727', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 8, 'langgraph_node': 'agent', 'langgraph_triggers': ['tool'], 'langgraph_task_idx': 0}, 'parent_ids': ['1ef301a5-b867-67de-9e9e-a32e53c5b1f8', '1f4f95d0-0ce1-4061-85d4-946446bbd3e5']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_end', 'data': {'output': '__end__', 'input': {'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '51f2874d-f8c7-4040-8b3b-8f15429a56ae', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-5f556aa0-26ea-42e2-b9e4-7ece3a00974e', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '1faf5dd0-ae97-4235-963f-5075083a027a', 'tool_call_id': 'tool_call_id'}, {'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-ae383611-6a42-475a-912a-09d5972e9e94', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'c67e08e6-e7af-4c4a-aa5e-50c8340ae341', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-cb1b98c1-c9e2-4a30-9d7a-38fa1f6224bd', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '1c9a16d2-5f0a-4eba-a0d2-240484a4ce7e', 'tool_call_id': 'tool_call_id'}, {'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-028a68fb-6435-4b46-a156-c3326f73985c', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}], 'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}}}, 'run_id': 'f2b2dfaf-475d-422b-8bf5-02a31bcc7d1a', 'name': 'should_continue', 'tags': ['seq:step:3'], 'metadata': {'graph_id': 'agent', 'created_by': 'system', 'run_id': '1ef301a5-b867-67de-9e9e-a32e53c5b1f8', 'user_id': '', 'thread_id': '7196a3aa-763c-4a8d-bfda-12fbfe1cd727', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 8, 'langgraph_node': 'agent', 'langgraph_triggers': ['tool'], 'langgraph_task_idx': 0}, 'parent_ids': ['1ef301a5-b867-67de-9e9e-a32e53c5b1f8', '1f4f95d0-0ce1-4061-85d4-946446bbd3e5']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_stream', 'run_id': '1f4f95d0-0ce1-4061-85d4-946446bbd3e5', 'name': 'agent', 'tags': ['graph:step:8'], 'metadata': {'graph_id': 'agent', 'created_by': 'system', 'run_id': '1ef301a5-b867-67de-9e9e-a32e53c5b1f8', 'user_id': '', 'thread_id': '7196a3aa-763c-4a8d-bfda-12fbfe1cd727', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 8, 'langgraph_node': 'agent', 'langgraph_triggers': ['tool'], 'langgraph_task_idx': 0}, 'data': {'chunk': {'messages': [{'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-028a68fb-6435-4b46-a156-c3326f73985c', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}], 'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}}}, 'parent_ids': ['1ef301a5-b867-67de-9e9e-a32e53c5b1f8']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_end', 'data': {'output': {'messages': [{'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-028a68fb-6435-4b46-a156-c3326f73985c', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}], 'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}}, 'input': {'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}, 'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '51f2874d-f8c7-4040-8b3b-8f15429a56ae', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-5f556aa0-26ea-42e2-b9e4-7ece3a00974e', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '1faf5dd0-ae97-4235-963f-5075083a027a', 'tool_call_id': 'tool_call_id'}, {'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-ae383611-6a42-475a-912a-09d5972e9e94', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'c67e08e6-e7af-4c4a-aa5e-50c8340ae341', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-cb1b98c1-c9e2-4a30-9d7a-38fa1f6224bd', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '1c9a16d2-5f0a-4eba-a0d2-240484a4ce7e', 'tool_call_id': 'tool_call_id'}], 'sleep': None}}, 'run_id': '1f4f95d0-0ce1-4061-85d4-946446bbd3e5', 'name': 'agent', 'tags': ['graph:step:8'], 'metadata': {'graph_id': 'agent', 'created_by': 'system', 'run_id': '1ef301a5-b867-67de-9e9e-a32e53c5b1f8', 'user_id': '', 'thread_id': '7196a3aa-763c-4a8d-bfda-12fbfe1cd727', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 8, 'langgraph_node': 'agent', 'langgraph_triggers': ['tool'], 'langgraph_task_idx': 0}, 'parent_ids': ['1ef301a5-b867-67de-9e9e-a32e53c5b1f8']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_end', 'data': {'output': {'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}, 'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '51f2874d-f8c7-4040-8b3b-8f15429a56ae', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-5f556aa0-26ea-42e2-b9e4-7ece3a00974e', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '1faf5dd0-ae97-4235-963f-5075083a027a', 'tool_call_id': 'tool_call_id'}, {'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-ae383611-6a42-475a-912a-09d5972e9e94', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'c67e08e6-e7af-4c4a-aa5e-50c8340ae341', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-cb1b98c1-c9e2-4a30-9d7a-38fa1f6224bd', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '1c9a16d2-5f0a-4eba-a0d2-240484a4ce7e', 'tool_call_id': 'tool_call_id'}, {'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-028a68fb-6435-4b46-a156-c3326f73985c', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}}, 'run_id': '1ef301a5-b867-67de-9e9e-a32e53c5b1f8', 'name': 'LangGraph', 'tags': [], 'metadata': {'graph_id': 'agent', 'created_by': 'system', 'run_id': '1ef301a5-b867-67de-9e9e-a32e53c5b1f8', 'user_id': '', 'thread_id': '7196a3aa-763c-4a8d-bfda-12fbfe1cd727', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'parent_ids': []}
-    
-    
-    
-    Receiving new event of type: end...
-    None
-
-
-## Token-by-Token Streaming
-
-Token-by-token streaming can be implemented with the `events` streaming mode. The `on_chat_model_stream` event type should be processed to stream LLM responses token-by-token.
-
-=== "Python"
-
-    ```python
-    llm_response = ""
-
-    # stream token-by-token
-    async for chunk in client.runs.stream(
-        thread_id=thread["thread_id"],
-        assistant_id=assistant_id,
-        input=input,
-        stream_mode="events",
-    ):
-        if (
-            chunk.event == "events" and
-            chunk.data["event"] == "on_chat_model_stream" and
-            len(chunk.data["data"]["chunk"]["content"]) > 0 and
-            'text' in chunk.data["data"]["chunk"]["content"][0]
-        ):
-            llm_response += chunk.data["data"]["chunk"]["content"][0]['text']
-            print(llm_response)
-    ```
-
-=== "Javascript"
-
-    ```js
-    const llmResponse = "";
-    // stream events
-    const streamResponse = client.runs.stream(
-      thread["thread_id"],
-      assistantID,
-      {
-        input,
-        streamMode: "events"
-      }
-    );
-    for await (const chunk of streamResponse) {
-      if (chunk.event === "events" && chunk.data.event === "on_chat_model_stream" && chunk.data.chunk.content.length > 0 && 'text' in chunk.data.chunk.content[0]) {
-        llmResponse += chunk.data.data.chunk.content[0].text;
-        console.log(llmResponse);
-      }
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-     --header 'Content-Type: application/json' \
-     --data "{
-       \"assistant_id\": \"agent\",
-       \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"What's the weather in sf\"}]},
-       \"stream_mode\": [
-         \"events\"
-       ]
-     }" | sed 's/\r$//' | awk '
-    /^event:/ { event = $2 }
-    /^data:/ {
-        json_data = substr($0, index($0, $2))
-
-        if (event == "events") {
-        print json_data
-        }
-    }' | jq -r '
-        select(.event == "on_chat_model_stream") |
-        .data.chunk.content[] | .text // empty
-    ' | awk '
-    BEGIN { llm_response="" }
-    $0 != "" && $0 != "null" {
-        llm_response = llm_response $0
-        print llm_response
-    }'
-    ```
-
-Output:
-
-    The
-    The search
-    The search results provide
-    The search results provide the current weather conditions
-    The search results provide the current weather conditions in San Francisco.
-    The search results provide the current weather conditions in San Francisco. According
-    The search results provide the current weather conditions in San Francisco. According to the data,
-    The search results provide the current weather conditions in San Francisco. According to the data, as
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12,
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024,
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C).
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The win
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is bl
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 k
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph).
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70%
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70% and visibility
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70% and visibility is 6
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70% and visibility is 6 miles
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70% and visibility is 6 miles (10 km
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70% and visibility is 6 miles (10 km).
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70% and visibility is 6 miles (10 km). Overall
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70% and visibility is 6 miles (10 km). Overall, it appears
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70% and visibility is 6 miles (10 km). Overall, it appears to be a nice
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70% and visibility is 6 miles (10 km). Overall, it appears to be a nice sunny day in San
-    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70% and visibility is 6 miles (10 km). Overall, it appears to be a nice sunny day in San Francisco.
-
-

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

@@ -1,492 +0,0 @@
-# How to stream messages from your graph
-
-This guide covers how to stream messages from your graph. In order to use this mode, the state of the graph you are interacting with MUST have a `messages` key that is a list of messages.
-
-E.g., the state should look something like:
-
-=== "Python"
-
-    ```python
-    from typing import TypedDict, Annotated
-    from langgraph.graph import add_messages
-    from langchain_core.messages import AnyMessage
-
-    class State(TypedDict):
-        messages: Annotated[list[AnyMessage], add_messages]
-    ```
-
-=== "Javascript"
-
-    ```js
-    import { type BaseMessage } from "@langchain/core/messages";
-    import { Annotation, messagesStateReducer } from "@langchain/langgraph";
-
-    export const StateAnnotation = Annotation.Root({
-      messages: Annotation<BaseMessage[]>({
-        reducer: messagesStateReducer,
-        default: () => [],
-      }),
-    });
-    ```
-
-Alternatively, you can use an instance or subclass of `from langgraph.graph import MessagesState` (`MessagesState` is equivalent to the implementation above). Or in Javascript: `import { MessagesAnnotation } from "@langchain/langgraph";`.
-
-With `stream_mode="messages"` two things will be streamed back:
-
-- It outputs messages produced by any chat model called inside (unless tagged in a special way)
-- It outputs messages returned from nodes (to allow for nodes to return `ToolMessages` and the like)
-
-Read more about how the `messages` streaming mode works [here](https://langchain-ai.github.io/langgraph/cloud/concepts/api/#modemessages)
-
-First let's set up our client and thread:
-
-=== "Python"
-
-    ```python
-    from langgraph_sdk import get_client
-
-    client = get_client(url=<DEPLOYMENT_URL>)
-    # Using the graph deployed with the name "agent"
-    assistant_id = "agent"
-    # create thread
-    thread = await client.threads.create()
-    print(thread)
-    ```
-
-=== "Javascript"
-
-    ```js
-    import { Client } from "@langchain/langgraph-sdk";
-
-    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
-    // Using the graph deployed with the name "agent"
-    const assistantID = "agent";
-    // create thread
-    const thread = await client.threads.create();
-    console.log(thread);
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-      --url <DEPLOYMENT_URL>/threads \
-      --header 'Content-Type: application/json'
-    ```
-
-Output:
-
-    {
-        'thread_id': 'e1431c95-e241-4d1d-a252-27eceb1e5c86',
-        'created_at': '2024-06-21T15:48:59.808924+00:00',
-        'updated_at': '2024-06-21T15:48:59.808924+00:00',
-        'metadata': {},
-        'status': 'idle',
-        'config': {},
-        'values': None
-    }
-
-Let's also define a helper function for better formatting of the tool calls in messages (for CURL we will define a helper script called `process_stream.sh`)
-
-=== "Python"
-
-    ```python
-    def format_tool_calls(tool_calls):
-        if tool_calls:
-            formatted_calls = []
-            for call in tool_calls:
-                formatted_calls.append(
-                    f"Tool Call ID: {call['id']}, Function: {call['name']}, Arguments: {call['args']}"
-                )
-            return "\n".join(formatted_calls)
-        return "No tool calls"
-    ```
-
-=== "Javascript"
-
-    ```js
-    function formatToolCalls(toolCalls) {
-      if (toolCalls && toolCalls.length > 0) {
-        const formattedCalls = toolCalls.map(call => {
-          return `Tool Call ID: ${call.id}, Function: ${call.name}, Arguments: ${call.args}`;
-        });
-        return formattedCalls.join("\n");
-      }
-      return "No tool calls";
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    # process_stream.sh
-
-    format_tool_calls() {
-        echo "$1" | jq -r 'map("Tool Call ID: \(.id), Function: \(.name), Arguments: \(.args)") | join("\n")'
-    }
-
-    process_data_item() {
-        local data_item="$1"
-
-        if echo "$data_item" | jq -e '.role == "user"' > /dev/null; then
-            echo "Human: $(echo "$data_item" | jq -r '.content')"
-        else
-            local tool_calls=$(echo "$data_item" | jq -r '.tool_calls // []')
-            local invalid_tool_calls=$(echo "$data_item" | jq -r '.invalid_tool_calls // []')
-            local content=$(echo "$data_item" | jq -r '.content // ""')
-            local response_metadata=$(echo "$data_item" | jq -r '.response_metadata // {}')
-
-            if [ -n "$content" ] && [ "$content" != "null" ]; then
-                echo "AI: $content"
-            fi
-
-            if [ "$tool_calls" != "[]" ]; then
-                echo "Tool Calls:"
-                format_tool_calls "$tool_calls"
-            fi
-
-            if [ "$invalid_tool_calls" != "[]" ]; then
-                echo "Invalid Tool Calls:"
-                format_tool_calls "$invalid_tool_calls"
-            fi
-
-            if [ "$response_metadata" != "{}" ]; then
-                local finish_reason=$(echo "$response_metadata" | jq -r '.finish_reason // "N/A"')
-                echo "Response Metadata: Finish Reason - $finish_reason"
-            fi
-        fi
-    }
-
-    while IFS=': ' read -r key value; do
-        case "$key" in
-            event)
-                event="$value"
-                ;;
-            data)
-                if [ "$event" = "metadata" ]; then
-                    run_id=$(echo "$value" | jq -r '.run_id')
-                    echo "Metadata: Run ID - $run_id"
-                    echo "------------------------------------------------"
-                elif [ "$event" = "messages/partial" ]; then
-                    echo "$value" | jq -c '.[]' | while read -r data_item; do
-                        process_data_item "$data_item"
-                    done
-                    echo "------------------------------------------------"
-                fi
-                ;;
-        esac
-    done
-    ```
-
-
-Now we can stream by messages, which will return complete messages (at the end of node execution) as well as tokens for any messages generated inside a node:
-
-=== "Python"
-
-    ```python
-    input = {"messages": [{"role": "user", "content": "what's the weather in sf"}]}
-    config = {"configurable": {"model_name": "openai"}}
-
-    async for event in client.runs.stream(
-        thread["thread_id"],
-        assistant_id=assistant_id,
-        input=input,
-        config=config,
-        stream_mode="messages",
-    ):
-        if event.event == "metadata":
-            print(f"Metadata: Run ID - {event.data['run_id']}")
-            print("-" * 50)
-        elif event.event == "messages/partial":
-            for data_item in event.data:
-                if "role" in data_item and data_item["role"] == "user":
-                    print(f"Human: {data_item['content']}")
-                else:
-                    tool_calls = data_item.get("tool_calls", [])
-                    invalid_tool_calls = data_item.get("invalid_tool_calls", [])
-                    content = data_item.get("content", "")
-                    response_metadata = data_item.get("response_metadata", {})
-
-                    if content:
-                        print(f"AI: {content}")
-
-                    if tool_calls:
-                        print("Tool Calls:")
-                        print(format_tool_calls(tool_calls))
-
-                    if invalid_tool_calls:
-                        print("Invalid Tool Calls:")
-                        print(format_tool_calls(invalid_tool_calls))
-
-                    if response_metadata:
-                        finish_reason = response_metadata.get("finish_reason", "N/A")
-                        print(f"Response Metadata: Finish Reason - {finish_reason}")
-            print("-" * 50)
-    ```
-
-=== "Javascript"
-
-    ```js
-    const input = {
-      messages: [
-        {
-          role: "human",
-          content: "What's the weather in sf",
-        }
-      ]
-    };
-    const config = { configurable: { model_name: "openai" } };
-
-    const streamResponse = client.runs.stream(
-      thread["thread_id"],
-      assistantID,
-      {
-        input,
-        config,
-        streamMode: "messages"
-      }
-    );
-
-    for await (const event of streamResponse) {
-      if (event.event === "metadata") {
-        console.log(`Metadata: Run ID - ${event.data.run_id}`);
-        console.log("-".repeat(50));
-      } else if (event.event === "messages/partial") {
-        event.data.forEach(dataItem => {
-          if (dataItem.role && dataItem.role === "user") {
-            console.log(`Human: ${dataItem.content}`);
-          } else {
-            const toolCalls = dataItem.tool_calls || [];
-            const invalidToolCalls = dataItem.invalid_tool_calls || [];
-            const content = dataItem.content || "";
-            const responseMetadata = dataItem.response_metadata || {};
-
-            if (content) {
-              console.log(`AI: ${content}`);
-            }
-
-            if (toolCalls.length > 0) {
-              console.log("Tool Calls:");
-              console.log(formatToolCalls(toolCalls));
-            }
-
-            if (invalidToolCalls.length > 0) {
-              console.log("Invalid Tool Calls:");
-              console.log(formatToolCalls(invalidToolCalls));
-            }
-
-            if (responseMetadata) {
-              const finishReason = responseMetadata.finish_reason || "N/A";
-              console.log(`Response Metadata: Finish Reason - ${finishReason}`);
-            }
-          }
-        });
-        console.log("-".repeat(50));
-      }
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-    --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-    --header 'Content-Type: application/json' \
-    --data "{
-    \"assistant_id\": \"agent\",
-    \"config\":{\"configurable\":{\"model_name\":\"openai\"}},
-    \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"What's the weather in sf\"}]},
-    \"stream_mode\": [
-    \"messages\"
-    ]
-    }" | sed 's/\r$//' | ./process_stream.sh
-    ```
-
-
-Output:
-
-    Metadata: Run ID - 1ef2fe5c-6a1d-6575-bc09-d7832711c17e
-    --------------------------------------------------
-    Invalid Tool Calls:
-    Tool Call ID: call_cg14F20jMBqWYrNgEkdWHwB3, Function: tavily_search_results_json, Arguments: 
-    --------------------------------------------------
-    Tool Calls:
-    Tool Call ID: call_cg14F20jMBqWYrNgEkdWHwB3, Function: tavily_search_results_json, Arguments: {}
-    --------------------------------------------------
-    Tool Calls:
-    Tool Call ID: call_cg14F20jMBqWYrNgEkdWHwB3, Function: tavily_search_results_json, Arguments: {}
-    --------------------------------------------------
-    Tool Calls:
-    Tool Call ID: call_cg14F20jMBqWYrNgEkdWHwB3, Function: tavily_search_results_json, Arguments: {'query': ''}
-    --------------------------------------------------
-    Tool Calls:
-    Tool Call ID: call_cg14F20jMBqWYrNgEkdWHwB3, Function: tavily_search_results_json, Arguments: {'query': 'current'}
-    --------------------------------------------------
-    Tool Calls:
-    Tool Call ID: call_cg14F20jMBqWYrNgEkdWHwB3, Function: tavily_search_results_json, Arguments: {'query': 'current weather'}
-    --------------------------------------------------
-    Tool Calls:
-    Tool Call ID: call_cg14F20jMBqWYrNgEkdWHwB3, Function: tavily_search_results_json, Arguments: {'query': 'current weather in'}
-    --------------------------------------------------
-    Tool Calls:
-    Tool Call ID: call_cg14F20jMBqWYrNgEkdWHwB3, Function: tavily_search_results_json, Arguments: {'query': 'current weather in San'}
-    --------------------------------------------------
-    Tool Calls:
-    Tool Call ID: call_cg14F20jMBqWYrNgEkdWHwB3, Function: tavily_search_results_json, Arguments: {'query': 'current weather in San Francisco'}
-    --------------------------------------------------
-    Tool Calls:
-    Tool Call ID: call_cg14F20jMBqWYrNgEkdWHwB3, Function: tavily_search_results_json, Arguments: {'query': 'current weather in San Francisco'}
-    --------------------------------------------------
-    Tool Calls:
-    Tool Call ID: call_cg14F20jMBqWYrNgEkdWHwB3, Function: tavily_search_results_json, Arguments: {'query': 'current weather in San Francisco'}
-    Response Metadata: Finish Reason - tool_calls
-    --------------------------------------------------
-    --------------------------------------------------
-    AI: The
-    --------------------------------------------------
-    AI: The current
-    --------------------------------------------------
-    AI: The current weather
-    --------------------------------------------------
-    AI: The current weather in
-    --------------------------------------------------
-    AI: The current weather in San
-    --------------------------------------------------
-    AI: The current weather in San Francisco
-    --------------------------------------------------
-    AI: The current weather in San Francisco is
-    --------------------------------------------------
-    AI: The current weather in San Francisco is over
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F).
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-s
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-south
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 k
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph).
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%,
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is 
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is 16
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is 16 km
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is 16 km (
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is 16 km (9
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is 16 km (9 miles
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is 16 km (9 miles).
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is 16 km (9 miles). The
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is 16 km (9 miles). The UV
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is 16 km (9 miles). The UV index
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is 16 km (9 miles). The UV index is
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is 16 km (9 miles). The UV index is 
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is 16 km (9 miles). The UV index is 3
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is 16 km (9 miles). The UV index is 3.
-    --------------------------------------------------
-    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is 16 km (9 miles). The UV index is 3.
-    Response Metadata: Finish Reason - stop
-    --------------------------------------------------
-

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

@@ -1,492 +0,0 @@
-# How to configure multiple streaming modes at the same time
-
-This guide covers how to configure multiple streaming modes at the same time.
-
-First let's set up our client and thread:
-
-=== "Python"
-
-    ```python
-    from langgraph_sdk import get_client
-
-    client = get_client(url=<DEPLOYMENT_URL>)
-    # Using the graph deployed with the name "agent"
-    assistant_id = "agent"
-    # create thread
-    thread = await client.threads.create()
-    print(thread)
-    ```
-
-=== "Javascript"
-
-    ```js
-    import { Client } from "@langchain/langgraph-sdk";
-
-    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
-    // Using the graph deployed with the name "agent"
-    const assistantID = "agent";
-    // create thread
-    const thread = await client.threads.create();
-    console.log(thread);
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-      --url <DEPLOYMENT_URL>/threads \
-      --header 'Content-Type: application/json'
-    ```
-
-Output:
-
-    {
-        'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4',
-        'created_at': '2024-06-24T21:30:07.980789+00:00',
-        'updated_at': '2024-06-24T21:30:07.980789+00:00',
-        'metadata': {},
-        'status': 'idle',
-        'config': {},
-        'values': None
-    }
-
-When configuring multiple streaming modes for a run, responses for each respective mode will be produced. In the following example, note that a `list` of modes (`messages`, `events`, `debug`) is passed to the `stream_mode` parameter and the response contains `events`, `debug`, `messages/complete`, `messages/metadata`, and `messages/partial` event types.
-
-=== "Python"
-
-    ```python
-    # create input
-    input = {
-        "messages": [
-            {
-                "role": "human",
-                "content": "What's the weather in SF?",
-            }
-        ]
-    }
-
-    # stream events with multiple streaming modes
-    async for chunk in client.runs.stream(
-        thread_id=thread["thread_id"],
-        assistant_id=assistant_id,
-        input=input,
-        stream_mode=["messages", "events", "debug"],
-    ):
-        print(f"Receiving new event of type: {chunk.event}...")
-        print(chunk.data)
-        print("\n\n")
-    ```
-
-=== "Javascript"
-
-    ```js
-    // create input
-    const input = {
-      messages: [
-        {
-          role: "human",
-          content: "What's the weather in SF?",
-        }
-      ]
-    };
-
-    // stream events with multiple streaming modes
-    const streamResponse = client.runs.stream(
-      thread["thread_id"],
-      assistantID,
-      {
-        input,
-        streamMode: ["messages", "events", "debug"]
-      }
-    );
-    for await (const chunk of streamResponse) {
-      console.log(`Receiving new event of type: ${chunk.event}...`);
-      console.log(chunk.data);
-      console.log("\n\n");
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-     --header 'Content-Type: application/json' \
-     --data "{
-       \"assistant_id\": \"agent\",
-       \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"What's the weather in SF?\"}]},
-       \"stream_mode\": [
-         \"messages\",
-         \"events\",
-         \"debug\"
-       ]
-     }" | \
-     sed 's/\r$//' | \
-     awk '
-     /^event:/ {
-         if (data_content != "") {
-             print data_content "\n"
-         }
-         sub(/^event: /, "Receiving event of type: ", $0)
-         printf "%s...\n", $0
-         data_content = ""
-     }
-     /^data:/ {
-         sub(/^data: /, "", $0)
-         data_content = $0
-     }
-     END {
-         if (data_content != "") {
-             print data_content "\n"
-         }
-     }
-     '
-    ```
-
-Output:
-
-    Receiving new event of type: metadata...
-    {'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25'}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_start', 'data': {'input': {'messages': [{'role': 'human', 'content': "What's the weather in SF?"}]}}, 'name': 'LangGraph', 'tags': [], 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'parent_ids': []}
-    
-    
-    
-    Receiving new event of type: debug...
-    {'type': 'checkpoint', 'timestamp': '2024-06-24T21:34:06.116009+00:00', 'step': -1, 'payload': {'config': {'tags': [], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'callbacks': [None], 'recursion_limit': 25, 'configurable': {'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'thread_ts': '1ef32717-bc7c-6daa-bfff-6b9027c1a50e', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25'}, 'values': {'messages': []}, 'metadata': {'source': 'input', 'step': -1, 'writes': {'messages': [{'role': 'human', 'content': "What's the weather in SF?"}]}}}}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_stream', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'name': 'LangGraph', 'tags': [], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'data': {'chunk': ['debug', {'type': 'checkpoint', 'timestamp': '2024-06-24T21:34:06.116009+00:00', 'step': -1, 'payload': {'config': {'tags': [], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'callbacks': [None], 'recursion_limit': 25, 'configurable': {'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'thread_ts': '1ef32717-bc7c-6daa-bfff-6b9027c1a50e', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25'}, 'values': {'messages': []}, 'metadata': {'source': 'input', 'step': -1, 'writes': {'messages': [{'role': 'human', 'content': "What's the weather in SF?"}]}}}}]}, 'parent_ids': []}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_stream', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'name': 'LangGraph', 'tags': [], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'data': {'chunk': ['values', {'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}]}]}, 'parent_ids': []}
-    
-    
-    
-    Receiving new event of type: messages/complete...
-    [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}]
-    
-    
-    
-    Receiving new event of type: debug...
-    {'type': 'checkpoint', 'timestamp': '2024-06-24T21:34:06.117924+00:00', 'step': 0, 'payload': {'config': {'tags': [], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'callbacks': [None], 'recursion_limit': 25, 'configurable': {'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'thread_ts': '1ef32717-bc81-68c8-8000-4e18ae7d67a5', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25'}, 'values': {'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}]}, 'metadata': {'source': 'loop', 'step': 0, 'writes': None}}}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_stream', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'name': 'LangGraph', 'tags': [], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'data': {'chunk': ['debug', {'type': 'checkpoint', 'timestamp': '2024-06-24T21:34:06.117924+00:00', 'step': 0, 'payload': {'config': {'tags': [], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'callbacks': [None], 'recursion_limit': 25, 'configurable': {'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'thread_ts': '1ef32717-bc81-68c8-8000-4e18ae7d67a5', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25'}, 'values': {'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}]}, 'metadata': {'source': 'loop', 'step': 0, 'writes': None}}}]}, 'parent_ids': []}
-    
-    
-    
-    Receiving new event of type: debug...
-    {'type': 'task', 'timestamp': '2024-06-24T21:34:06.118042+00:00', 'step': 1, 'payload': {'id': '212ed9c2-a454-50c5-a202-12066bbbe7b8', 'name': 'agent', 'input': {'some_bytes': None, 'some_byte_array': None, 'dict_with_bytes': None, 'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}], 'sleep': None}, 'triggers': ['start:agent']}}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_stream', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'name': 'LangGraph', 'tags': [], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'data': {'chunk': ['debug', {'type': 'task', 'timestamp': '2024-06-24T21:34:06.118042+00:00', 'step': 1, 'payload': {'id': '212ed9c2-a454-50c5-a202-12066bbbe7b8', 'name': 'agent', 'input': {'some_bytes': None, 'some_byte_array': None, 'dict_with_bytes': None, 'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}], 'sleep': None}, 'triggers': ['start:agent']}}]}, 'parent_ids': []}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_start', 'data': {}, 'name': 'agent', 'tags': ['graph:step:1'], 'run_id': '72b74d24-5792-48da-a887-102100d6e2c0', 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 1, 'langgraph_node': 'agent', 'langgraph_triggers': ['start:agent'], 'langgraph_task_idx': 0}, 'parent_ids': ['1ef32717-bc30-6cf2-8a26-33f63567bc25']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chat_model_start', 'data': {'input': {'messages': [[{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}]]}}, 'name': 'FakeListChatModel', 'tags': ['seq:step:1'], 'run_id': '2424dd6d-5cf5-4244-8d98-357640ce6e12', 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 1, 'langgraph_node': 'agent', 'langgraph_triggers': ['start:agent'], 'langgraph_task_idx': 0, 'ls_model_type': 'chat'}, 'parent_ids': ['1ef32717-bc30-6cf2-8a26-33f63567bc25', '72b74d24-5792-48da-a887-102100d6e2c0']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chat_model_stream', 'data': {'chunk': {'content': 'b', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'AIMessageChunk', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None, 'tool_call_chunks': []}}, 'run_id': '2424dd6d-5cf5-4244-8d98-357640ce6e12', 'name': 'FakeListChatModel', 'tags': ['seq:step:1'], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 1, 'langgraph_node': 'agent', 'langgraph_triggers': ['start:agent'], 'langgraph_task_idx': 0, 'ls_model_type': 'chat'}, 'parent_ids': ['1ef32717-bc30-6cf2-8a26-33f63567bc25', '72b74d24-5792-48da-a887-102100d6e2c0']}
-    
-    
-    
-    Receiving new event of type: messages/metadata...
-    {'run-2424dd6d-5cf5-4244-8d98-357640ce6e12': {'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 1, 'langgraph_node': 'agent', 'langgraph_triggers': ['start:agent'], 'langgraph_task_idx': 0, 'ls_model_type': 'chat'}}}
-    
-    
-    
-    Receiving new event of type: messages/partial...
-    [{'content': 'b', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chat_model_stream', 'data': {'chunk': {'content': 'e', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'AIMessageChunk', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None, 'tool_call_chunks': []}}, 'run_id': '2424dd6d-5cf5-4244-8d98-357640ce6e12', 'name': 'FakeListChatModel', 'tags': ['seq:step:1'], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 1, 'langgraph_node': 'agent', 'langgraph_triggers': ['start:agent'], 'langgraph_task_idx': 0, 'ls_model_type': 'chat'}, 'parent_ids': ['1ef32717-bc30-6cf2-8a26-33f63567bc25', '72b74d24-5792-48da-a887-102100d6e2c0']}
-    
-    
-    
-    Receiving new event of type: messages/partial...
-    [{'content': 'be', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chat_model_stream', 'data': {'chunk': {'content': 'g', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'AIMessageChunk', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None, 'tool_call_chunks': []}}, 'run_id': '2424dd6d-5cf5-4244-8d98-357640ce6e12', 'name': 'FakeListChatModel', 'tags': ['seq:step:1'], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 1, 'langgraph_node': 'agent', 'langgraph_triggers': ['start:agent'], 'langgraph_task_idx': 0, 'ls_model_type': 'chat'}, 'parent_ids': ['1ef32717-bc30-6cf2-8a26-33f63567bc25', '72b74d24-5792-48da-a887-102100d6e2c0']}
-    
-    
-    
-    Receiving new event of type: messages/partial...
-    [{'content': 'beg', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chat_model_stream', 'data': {'chunk': {'content': 'i', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'AIMessageChunk', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None, 'tool_call_chunks': []}}, 'run_id': '2424dd6d-5cf5-4244-8d98-357640ce6e12', 'name': 'FakeListChatModel', 'tags': ['seq:step:1'], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 1, 'langgraph_node': 'agent', 'langgraph_triggers': ['start:agent'], 'langgraph_task_idx': 0, 'ls_model_type': 'chat'}, 'parent_ids': ['1ef32717-bc30-6cf2-8a26-33f63567bc25', '72b74d24-5792-48da-a887-102100d6e2c0']}
-    
-    
-    
-    Receiving new event of type: messages/partial...
-    [{'content': 'begi', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chat_model_stream', 'data': {'chunk': {'content': 'n', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'AIMessageChunk', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None, 'tool_call_chunks': []}}, 'run_id': '2424dd6d-5cf5-4244-8d98-357640ce6e12', 'name': 'FakeListChatModel', 'tags': ['seq:step:1'], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 1, 'langgraph_node': 'agent', 'langgraph_triggers': ['start:agent'], 'langgraph_task_idx': 0, 'ls_model_type': 'chat'}, 'parent_ids': ['1ef32717-bc30-6cf2-8a26-33f63567bc25', '72b74d24-5792-48da-a887-102100d6e2c0']}
-    
-    
-    
-    Receiving new event of type: messages/partial...
-    [{'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chat_model_end', 'data': {'output': {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, 'input': {'messages': [[{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}]]}}, 'run_id': '2424dd6d-5cf5-4244-8d98-357640ce6e12', 'name': 'FakeListChatModel', 'tags': ['seq:step:1'], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 1, 'langgraph_node': 'agent', 'langgraph_triggers': ['start:agent'], 'langgraph_task_idx': 0, 'ls_model_type': 'chat'}, 'parent_ids': ['1ef32717-bc30-6cf2-8a26-33f63567bc25', '72b74d24-5792-48da-a887-102100d6e2c0']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_start', 'data': {'input': {'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}], 'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}}}, 'name': 'should_continue', 'tags': ['seq:step:3'], 'run_id': '227afb0f-f909-4d54-a042-556ca6d98a69', 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 1, 'langgraph_node': 'agent', 'langgraph_triggers': ['start:agent'], 'langgraph_task_idx': 0}, 'parent_ids': ['1ef32717-bc30-6cf2-8a26-33f63567bc25', '72b74d24-5792-48da-a887-102100d6e2c0']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_end', 'data': {'output': 'tool', 'input': {'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}], 'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}}}, 'run_id': '227afb0f-f909-4d54-a042-556ca6d98a69', 'name': 'should_continue', 'tags': ['seq:step:3'], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 1, 'langgraph_node': 'agent', 'langgraph_triggers': ['start:agent'], 'langgraph_task_idx': 0}, 'parent_ids': ['1ef32717-bc30-6cf2-8a26-33f63567bc25', '72b74d24-5792-48da-a887-102100d6e2c0']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_stream', 'run_id': '72b74d24-5792-48da-a887-102100d6e2c0', 'name': 'agent', 'tags': ['graph:step:1'], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 1, 'langgraph_node': 'agent', 'langgraph_triggers': ['start:agent'], 'langgraph_task_idx': 0}, 'data': {'chunk': {'messages': [{'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}], 'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}}}, 'parent_ids': ['1ef32717-bc30-6cf2-8a26-33f63567bc25']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_end', 'data': {'output': {'messages': [{'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}], 'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}}, 'input': {'some_bytes': None, 'some_byte_array': None, 'dict_with_bytes': None, 'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}], 'sleep': None}}, 'run_id': '72b74d24-5792-48da-a887-102100d6e2c0', 'name': 'agent', 'tags': ['graph:step:1'], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 1, 'langgraph_node': 'agent', 'langgraph_triggers': ['start:agent'], 'langgraph_task_idx': 0}, 'parent_ids': ['1ef32717-bc30-6cf2-8a26-33f63567bc25']}
-    
-    
-    
-    Receiving new event of type: debug...
-    {'type': 'task_result', 'timestamp': '2024-06-24T21:34:06.124350+00:00', 'step': 1, 'payload': {'id': '212ed9c2-a454-50c5-a202-12066bbbe7b8', 'name': 'agent', 'result': [['some_bytes', 'c29tZV9ieXRlcw=='], ['some_byte_array', 'c29tZV9ieXRlX2FycmF5'], ['dict_with_bytes', {'more_bytes': 'bW9yZV9ieXRlcw=='}], ['messages', [{'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]]]}}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_stream', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'name': 'LangGraph', 'tags': [], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'data': {'chunk': ['debug', {'type': 'task_result', 'timestamp': '2024-06-24T21:34:06.124350+00:00', 'step': 1, 'payload': {'id': '212ed9c2-a454-50c5-a202-12066bbbe7b8', 'name': 'agent', 'result': [['some_bytes', 'c29tZV9ieXRlcw=='], ['some_byte_array', 'c29tZV9ieXRlX2FycmF5'], ['dict_with_bytes', {'more_bytes': 'bW9yZV9ieXRlcw=='}], ['messages', [{'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]]]}}]}, 'parent_ids': []}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_stream', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'name': 'LangGraph', 'tags': [], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'data': {'chunk': ['values', {'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}, 'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}]}, 'parent_ids': []}
-    
-    
-    
-    Receiving new event of type: messages/complete...
-    [{'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]
-    
-    
-    
-    Receiving new event of type: debug...
-    {'type': 'checkpoint', 'timestamp': '2024-06-24T21:34:06.124510+00:00', 'step': 1, 'payload': {'config': {'tags': [], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'callbacks': [None], 'recursion_limit': 25, 'configurable': {'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'thread_ts': '1ef32717-bc91-6a34-8001-26353c117c25', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25'}, 'values': {'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}, 'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}, 'metadata': {'source': 'loop', 'step': 1, 'writes': {'agent': {'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}, 'messages': [{'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}}}}}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_stream', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'name': 'LangGraph', 'tags': [], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'data': {'chunk': ['debug', {'type': 'checkpoint', 'timestamp': '2024-06-24T21:34:06.124510+00:00', 'step': 1, 'payload': {'config': {'tags': [], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'callbacks': [None], 'recursion_limit': 25, 'configurable': {'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'thread_ts': '1ef32717-bc91-6a34-8001-26353c117c25', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25'}, 'values': {'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}, 'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}, 'metadata': {'source': 'loop', 'step': 1, 'writes': {'agent': {'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}, 'messages': [{'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}}}}}]}, 'parent_ids': []}
-    
-    
-    
-    Receiving new event of type: debug...
-    {'type': 'task', 'timestamp': '2024-06-24T21:34:06.124572+00:00', 'step': 2, 'payload': {'id': '44139125-a1be-57c2-9cb2-19eb62bbaf2f', 'name': 'tool', 'input': {'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}, 'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}], 'sleep': None}, 'triggers': ['branch:agent:should_continue:tool']}}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_stream', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'name': 'LangGraph', 'tags': [], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'data': {'chunk': ['debug', {'type': 'task', 'timestamp': '2024-06-24T21:34:06.124572+00:00', 'step': 2, 'payload': {'id': '44139125-a1be-57c2-9cb2-19eb62bbaf2f', 'name': 'tool', 'input': {'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}, 'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}], 'sleep': None}, 'triggers': ['branch:agent:should_continue:tool']}}]}, 'parent_ids': []}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_start', 'data': {}, 'name': 'tool', 'tags': ['graph:step:2'], 'run_id': '91575720-886e-485e-ae2d-d6817e5346bf', 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 2, 'langgraph_node': 'tool', 'langgraph_triggers': ['branch:agent:should_continue:tool'], 'langgraph_task_idx': 0}, 'parent_ids': ['1ef32717-bc30-6cf2-8a26-33f63567bc25']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_stream', 'run_id': '91575720-886e-485e-ae2d-d6817e5346bf', 'name': 'tool', 'tags': ['graph:step:2'], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 2, 'langgraph_node': 'tool', 'langgraph_triggers': ['branch:agent:should_continue:tool'], 'langgraph_task_idx': 0}, 'data': {'chunk': {'messages': [{'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': None, 'tool_call_id': 'tool_call_id'}]}}, 'parent_ids': ['1ef32717-bc30-6cf2-8a26-33f63567bc25']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_end', 'data': {'output': {'messages': [{'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '639ca779-403d-4915-a066-327e1f634c8b', 'tool_call_id': 'tool_call_id'}]}, 'input': {'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}, 'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}], 'sleep': None}}, 'run_id': '91575720-886e-485e-ae2d-d6817e5346bf', 'name': 'tool', 'tags': ['graph:step:2'], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 2, 'langgraph_node': 'tool', 'langgraph_triggers': ['branch:agent:should_continue:tool'], 'langgraph_task_idx': 0}, 'parent_ids': ['1ef32717-bc30-6cf2-8a26-33f63567bc25']}
-    
-    
-    
-    Receiving new event of type: debug...
-    {'type': 'task_result', 'timestamp': '2024-06-24T21:34:06.126828+00:00', 'step': 2, 'payload': {'id': '44139125-a1be-57c2-9cb2-19eb62bbaf2f', 'name': 'tool', 'result': [['messages', [{'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '639ca779-403d-4915-a066-327e1f634c8b', 'tool_call_id': 'tool_call_id'}]]]}}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_stream', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'name': 'LangGraph', 'tags': [], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'data': {'chunk': ['debug', {'type': 'task_result', 'timestamp': '2024-06-24T21:34:06.126828+00:00', 'step': 2, 'payload': {'id': '44139125-a1be-57c2-9cb2-19eb62bbaf2f', 'name': 'tool', 'result': [['messages', [{'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '639ca779-403d-4915-a066-327e1f634c8b', 'tool_call_id': 'tool_call_id'}]]]}}]}, 'parent_ids': []}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_stream', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'name': 'LangGraph', 'tags': [], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'data': {'chunk': ['values', {'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}, 'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '639ca779-403d-4915-a066-327e1f634c8b', 'tool_call_id': 'tool_call_id'}]}]}, 'parent_ids': []}
-    
-    
-    
-    Receiving new event of type: messages/complete...
-    [{'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '639ca779-403d-4915-a066-327e1f634c8b', 'tool_call_id': 'tool_call_id'}]
-    
-    
-    
-    Receiving new event of type: debug...
-    {'type': 'checkpoint', 'timestamp': '2024-06-24T21:34:06.126966+00:00', 'step': 2, 'payload': {'config': {'tags': [], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'callbacks': [None], 'recursion_limit': 25, 'configurable': {'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'thread_ts': '1ef32717-bc97-6a06-8002-8e9ffc1ea75a', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25'}, 'values': {'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}, 'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '639ca779-403d-4915-a066-327e1f634c8b', 'tool_call_id': 'tool_call_id'}]}, 'metadata': {'source': 'loop', 'step': 2, 'writes': {'tool': {'messages': [{'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '639ca779-403d-4915-a066-327e1f634c8b', 'tool_call_id': 'tool_call_id'}]}}}}}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_stream', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'name': 'LangGraph', 'tags': [], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'data': {'chunk': ['debug', {'type': 'checkpoint', 'timestamp': '2024-06-24T21:34:06.126966+00:00', 'step': 2, 'payload': {'config': {'tags': [], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'callbacks': [None], 'recursion_limit': 25, 'configurable': {'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'thread_ts': '1ef32717-bc97-6a06-8002-8e9ffc1ea75a', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25'}, 'values': {'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}, 'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '639ca779-403d-4915-a066-327e1f634c8b', 'tool_call_id': 'tool_call_id'}]}, 'metadata': {'source': 'loop', 'step': 2, 'writes': {'tool': {'messages': [{'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '639ca779-403d-4915-a066-327e1f634c8b', 'tool_call_id': 'tool_call_id'}]}}}}}]}, 'parent_ids': []}
-    
-    
-    
-    Receiving new event of type: debug...
-    {'type': 'task', 'timestamp': '2024-06-24T21:34:06.127034+00:00', 'step': 3, 'payload': {'id': 'f1ccf371-63b3-5268-a837-7f360a93c4ec', 'name': 'agent', 'input': {'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}, 'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '639ca779-403d-4915-a066-327e1f634c8b', 'tool_call_id': 'tool_call_id'}], 'sleep': None}, 'triggers': ['tool']}}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_stream', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'name': 'LangGraph', 'tags': [], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'data': {'chunk': ['debug', {'type': 'task', 'timestamp': '2024-06-24T21:34:06.127034+00:00', 'step': 3, 'payload': {'id': 'f1ccf371-63b3-5268-a837-7f360a93c4ec', 'name': 'agent', 'input': {'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}, 'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '639ca779-403d-4915-a066-327e1f634c8b', 'tool_call_id': 'tool_call_id'}], 'sleep': None}, 'triggers': ['tool']}}]}, 'parent_ids': []}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_start', 'data': {}, 'name': 'agent', 'tags': ['graph:step:3'], 'run_id': 'b7d0900c-bfc2-43e4-b760-99bbc5bad84e', 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 3, 'langgraph_node': 'agent', 'langgraph_triggers': ['tool'], 'langgraph_task_idx': 0}, 'parent_ids': ['1ef32717-bc30-6cf2-8a26-33f63567bc25']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chat_model_start', 'data': {'input': {'messages': [[{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '639ca779-403d-4915-a066-327e1f634c8b', 'tool_call_id': 'tool_call_id'}]]}}, 'name': 'FakeListChatModel', 'tags': ['seq:step:1'], 'run_id': '0f2ef0a1-0fc7-445c-9df4-55e8bb284575', 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 3, 'langgraph_node': 'agent', 'langgraph_triggers': ['tool'], 'langgraph_task_idx': 0, 'ls_model_type': 'chat'}, 'parent_ids': ['1ef32717-bc30-6cf2-8a26-33f63567bc25', 'b7d0900c-bfc2-43e4-b760-99bbc5bad84e']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chat_model_stream', 'data': {'chunk': {'content': 'e', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'AIMessageChunk', 'name': None, 'id': 'run-0f2ef0a1-0fc7-445c-9df4-55e8bb284575', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None, 'tool_call_chunks': []}}, 'run_id': '0f2ef0a1-0fc7-445c-9df4-55e8bb284575', 'name': 'FakeListChatModel', 'tags': ['seq:step:1'], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 3, 'langgraph_node': 'agent', 'langgraph_triggers': ['tool'], 'langgraph_task_idx': 0, 'ls_model_type': 'chat'}, 'parent_ids': ['1ef32717-bc30-6cf2-8a26-33f63567bc25', 'b7d0900c-bfc2-43e4-b760-99bbc5bad84e']}
-    
-    
-    
-    Receiving new event of type: messages/metadata...
-    {'run-0f2ef0a1-0fc7-445c-9df4-55e8bb284575': {'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 3, 'langgraph_node': 'agent', 'langgraph_triggers': ['tool'], 'langgraph_task_idx': 0, 'ls_model_type': 'chat'}}}
-    
-    
-    
-    Receiving new event of type: messages/partial...
-    [{'content': 'e', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-0f2ef0a1-0fc7-445c-9df4-55e8bb284575', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chat_model_stream', 'data': {'chunk': {'content': 'n', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'AIMessageChunk', 'name': None, 'id': 'run-0f2ef0a1-0fc7-445c-9df4-55e8bb284575', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None, 'tool_call_chunks': []}}, 'run_id': '0f2ef0a1-0fc7-445c-9df4-55e8bb284575', 'name': 'FakeListChatModel', 'tags': ['seq:step:1'], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 3, 'langgraph_node': 'agent', 'langgraph_triggers': ['tool'], 'langgraph_task_idx': 0, 'ls_model_type': 'chat'}, 'parent_ids': ['1ef32717-bc30-6cf2-8a26-33f63567bc25', 'b7d0900c-bfc2-43e4-b760-99bbc5bad84e']}
-    
-    
-    
-    Receiving new event of type: messages/partial...
-    [{'content': 'en', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-0f2ef0a1-0fc7-445c-9df4-55e8bb284575', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chat_model_stream', 'data': {'chunk': {'content': 'd', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'AIMessageChunk', 'name': None, 'id': 'run-0f2ef0a1-0fc7-445c-9df4-55e8bb284575', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None, 'tool_call_chunks': []}}, 'run_id': '0f2ef0a1-0fc7-445c-9df4-55e8bb284575', 'name': 'FakeListChatModel', 'tags': ['seq:step:1'], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 3, 'langgraph_node': 'agent', 'langgraph_triggers': ['tool'], 'langgraph_task_idx': 0, 'ls_model_type': 'chat'}, 'parent_ids': ['1ef32717-bc30-6cf2-8a26-33f63567bc25', 'b7d0900c-bfc2-43e4-b760-99bbc5bad84e']}
-    
-    
-    
-    Receiving new event of type: messages/partial...
-    [{'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-0f2ef0a1-0fc7-445c-9df4-55e8bb284575', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chat_model_end', 'data': {'output': {'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-0f2ef0a1-0fc7-445c-9df4-55e8bb284575', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, 'input': {'messages': [[{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '639ca779-403d-4915-a066-327e1f634c8b', 'tool_call_id': 'tool_call_id'}]]}}, 'run_id': '0f2ef0a1-0fc7-445c-9df4-55e8bb284575', 'name': 'FakeListChatModel', 'tags': ['seq:step:1'], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 3, 'langgraph_node': 'agent', 'langgraph_triggers': ['tool'], 'langgraph_task_idx': 0, 'ls_model_type': 'chat'}, 'parent_ids': ['1ef32717-bc30-6cf2-8a26-33f63567bc25', 'b7d0900c-bfc2-43e4-b760-99bbc5bad84e']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_start', 'data': {'input': {'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '639ca779-403d-4915-a066-327e1f634c8b', 'tool_call_id': 'tool_call_id'}, {'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-0f2ef0a1-0fc7-445c-9df4-55e8bb284575', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}], 'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}}}, 'name': 'should_continue', 'tags': ['seq:step:3'], 'run_id': '8af814e9-8136-4aab-acbc-dffc5bcafdfd', 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 3, 'langgraph_node': 'agent', 'langgraph_triggers': ['tool'], 'langgraph_task_idx': 0}, 'parent_ids': ['1ef32717-bc30-6cf2-8a26-33f63567bc25', 'b7d0900c-bfc2-43e4-b760-99bbc5bad84e']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_end', 'data': {'output': '__end__', 'input': {'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '639ca779-403d-4915-a066-327e1f634c8b', 'tool_call_id': 'tool_call_id'}, {'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-0f2ef0a1-0fc7-445c-9df4-55e8bb284575', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}], 'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}}}, 'run_id': '8af814e9-8136-4aab-acbc-dffc5bcafdfd', 'name': 'should_continue', 'tags': ['seq:step:3'], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 3, 'langgraph_node': 'agent', 'langgraph_triggers': ['tool'], 'langgraph_task_idx': 0}, 'parent_ids': ['1ef32717-bc30-6cf2-8a26-33f63567bc25', 'b7d0900c-bfc2-43e4-b760-99bbc5bad84e']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_stream', 'run_id': 'b7d0900c-bfc2-43e4-b760-99bbc5bad84e', 'name': 'agent', 'tags': ['graph:step:3'], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 3, 'langgraph_node': 'agent', 'langgraph_triggers': ['tool'], 'langgraph_task_idx': 0}, 'data': {'chunk': {'messages': [{'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-0f2ef0a1-0fc7-445c-9df4-55e8bb284575', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}], 'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}}}, 'parent_ids': ['1ef32717-bc30-6cf2-8a26-33f63567bc25']}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_end', 'data': {'output': {'messages': [{'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-0f2ef0a1-0fc7-445c-9df4-55e8bb284575', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}], 'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}}, 'input': {'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}, 'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '639ca779-403d-4915-a066-327e1f634c8b', 'tool_call_id': 'tool_call_id'}], 'sleep': None}}, 'run_id': 'b7d0900c-bfc2-43e4-b760-99bbc5bad84e', 'name': 'agent', 'tags': ['graph:step:3'], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca', 'langgraph_step': 3, 'langgraph_node': 'agent', 'langgraph_triggers': ['tool'], 'langgraph_task_idx': 0}, 'parent_ids': ['1ef32717-bc30-6cf2-8a26-33f63567bc25']}
-    
-    
-    
-    Receiving new event of type: debug...
-    {'type': 'task_result', 'timestamp': '2024-06-24T21:34:06.133991+00:00', 'step': 3, 'payload': {'id': 'f1ccf371-63b3-5268-a837-7f360a93c4ec', 'name': 'agent', 'result': [['some_bytes', 'c29tZV9ieXRlcw=='], ['some_byte_array', 'c29tZV9ieXRlX2FycmF5'], ['dict_with_bytes', {'more_bytes': 'bW9yZV9ieXRlcw=='}], ['messages', [{'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-0f2ef0a1-0fc7-445c-9df4-55e8bb284575', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]]]}}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_stream', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'name': 'LangGraph', 'tags': [], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'data': {'chunk': ['debug', {'type': 'task_result', 'timestamp': '2024-06-24T21:34:06.133991+00:00', 'step': 3, 'payload': {'id': 'f1ccf371-63b3-5268-a837-7f360a93c4ec', 'name': 'agent', 'result': [['some_bytes', 'c29tZV9ieXRlcw=='], ['some_byte_array', 'c29tZV9ieXRlX2FycmF5'], ['dict_with_bytes', {'more_bytes': 'bW9yZV9ieXRlcw=='}], ['messages', [{'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-0f2ef0a1-0fc7-445c-9df4-55e8bb284575', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]]]}}]}, 'parent_ids': []}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_stream', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'name': 'LangGraph', 'tags': [], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'data': {'chunk': ['values', {'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}, 'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '639ca779-403d-4915-a066-327e1f634c8b', 'tool_call_id': 'tool_call_id'}, {'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-0f2ef0a1-0fc7-445c-9df4-55e8bb284575', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}]}, 'parent_ids': []}
-    
-    
-    
-    Receiving new event of type: messages/complete...
-    [{'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-0f2ef0a1-0fc7-445c-9df4-55e8bb284575', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]
-    
-    
-    
-    Receiving new event of type: debug...
-    {'type': 'checkpoint', 'timestamp': '2024-06-24T21:34:06.134190+00:00', 'step': 3, 'payload': {'config': {'tags': [], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'callbacks': [None], 'recursion_limit': 25, 'configurable': {'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'thread_ts': '1ef32717-bca9-6418-8003-8d0d0b06845c', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25'}, 'values': {'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}, 'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '639ca779-403d-4915-a066-327e1f634c8b', 'tool_call_id': 'tool_call_id'}, {'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-0f2ef0a1-0fc7-445c-9df4-55e8bb284575', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}, 'metadata': {'source': 'loop', 'step': 3, 'writes': {'agent': {'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}, 'messages': [{'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-0f2ef0a1-0fc7-445c-9df4-55e8bb284575', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}}}}}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_stream', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'name': 'LangGraph', 'tags': [], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'data': {'chunk': ['debug', {'type': 'checkpoint', 'timestamp': '2024-06-24T21:34:06.134190+00:00', 'step': 3, 'payload': {'config': {'tags': [], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'callbacks': [None], 'recursion_limit': 25, 'configurable': {'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'thread_ts': '1ef32717-bca9-6418-8003-8d0d0b06845c', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25'}, 'values': {'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}, 'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '639ca779-403d-4915-a066-327e1f634c8b', 'tool_call_id': 'tool_call_id'}, {'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-0f2ef0a1-0fc7-445c-9df4-55e8bb284575', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}, 'metadata': {'source': 'loop', 'step': 3, 'writes': {'agent': {'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}, 'messages': [{'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-0f2ef0a1-0fc7-445c-9df4-55e8bb284575', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}}}}}]}, 'parent_ids': []}
-    
-    
-    
-    Receiving new event of type: events...
-    {'event': 'on_chain_end', 'data': {'output': {'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}, 'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '639ca779-403d-4915-a066-327e1f634c8b', 'tool_call_id': 'tool_call_id'}, {'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-0f2ef0a1-0fc7-445c-9df4-55e8bb284575', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}}, 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'name': 'LangGraph', 'tags': [], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'parent_ids': []}
-    
-    
-    
-    Receiving new event of type: end...
-    None
-    
-    
-

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

@@ -1,160 +0,0 @@
-# How to stream state updates of your graph
-
-This guide covers how to use `stream_mode="updates"` for your graph, which will stream the updates to the graph state that are made after each node is executed. This differs from using `stream_mode="values"`: instead of streaming the entire value of the state at each superstep, it only streams the updates from each of the nodes that made an update to the state at that superstep. Read [this conceptual guide](https://langchain-ai.github.io/langgraph/concepts/low_level/#stream-and-astream) to learn more.
-
-First let's set up our client and thread:
-
-=== "Python"
-
-    ```python
-    from langgraph_sdk import get_client
-
-    client = get_client(url=<DEPLOYMENT_URL>)
-    # create thread
-    thread = await client.threads.create()
-    print(thread)
-    ```
-
-=== "Javascript"
-
-    ```js
-    import { Client } from "@langchain/langgraph-sdk";
-
-    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
-    // create thread
-    const thread = await client.threads.create();
-    console.log(thread);
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-      --url <DEPLOYMENT_URL>/threads \
-      --header 'Content-Type: application/json'
-    ```
-
-Output:
-
-    {
-      'thread_id': '979e3c89-a702-4882-87c2-7a59a250ce16',
-      'created_at': '2024-06-21T15:22:07.453100+00:00',
-      'updated_at': '2024-06-21T15:22:07.453100+00:00',
-      'metadata': {},
-      'status': 'idle',
-      'config': {},
-      'values': None 
-    }
-
-Now we can stream by updates, which outputs updates made to the state by each node after it has executed:
-
-
-=== "Python"
-
-    ```python
-    input = {
-        "messages": [
-            {
-                "role": "human",
-                "content": "what's the weather in la"
-            }
-        ]
-    }
-    async for chunk in client.runs.stream(
-        thread["thread_id"],
-        "agent",
-        input=input,
-        stream_mode="updates",
-    ):
-        print(f"Receiving new event of type: {chunk.event}...")
-        print(chunk.data)
-        print("\n\n")
-    ```
-
-=== "Javascript"
-
-    ```js
-    const input = {
-      messages: [
-        {
-          role: "human",
-          content: "What's the weather in la"
-        }
-      ]
-    };
-
-    const streamResponse = client.runs.stream(
-      thread["thread_id"],
-      "agent",
-      {
-        input,
-        streamMode: "updates"
-      }
-    );
-
-    for await (const chunk of streamResponse) {
-      console.log(`Receiving new event of type: ${chunk.event}...`);
-      console.log(chunk.data);
-      console.log("\n\n");
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-     --header 'Content-Type: application/json' \
-     --data "{
-       \"assistant_id\": \"agent\",
-       \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"What's the weather in la\"}]},
-       \"stream_mode\": [
-         \"updates\"
-       ]
-     }" | \
-     sed 's/\r$//' | \
-     awk '
-     /^event:/ {
-         if (data_content != "") {
-             print data_content "\n"
-         }
-         sub(/^event: /, "Receiving event of type: ", $0)
-         printf "%s...\n", $0
-         data_content = ""
-     }
-     /^data:/ {
-         sub(/^data: /, "", $0)
-         data_content = $0
-     }
-     END {
-         if (data_content != "") {
-             print data_content "\n"
-         }
-     }
-     '
-    ```
-
-Output:
-
-    Receiving new event of type: metadata...
-    {'run_id': 'cfc96c16-ed9a-44bd-b5bb-c30e3c0725f0'}
-    
-    
-    
-    Receiving new event of type: data...
-    {'agent': {'messages': [{'content': [{'id': 'toolu_0148tMmDK51iLQfG1yaNwRHM', 'input': {'query': 'weather in los angeles'}, 'name': 'tavily_search_results_json', 'type': 'tool_use'}], 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-1a9d32b0-7007-4a36-abde-8df812a0ed94', 'example': False, 'tool_calls': [{'name': 'tavily_search_results_json', 'args': {'query': 'weather in los angeles'}, 'id': 'toolu_0148tMmDK51iLQfG1yaNwRHM'}], 'invalid_tool_calls': []}]}}
-    
-    
-    
-    Receiving new event of type: data...
-    {'action': {'messages': [{'content': '[{"url": "https://www.weatherapi.com/", "content": "{\'location\': {\'name\': \'Los Angeles\', \'region\': \'California\', \'country\': \'United States of America\', \'lat\': 34.05, \'lon\': -118.24, \'tz_id\': \'America/Los_Angeles\', \'localtime_epoch\': 1716062239, \'localtime\': \'2024-05-18 12:57\'}, \'current\': {\'last_updated_epoch\': 1716061500, \'last_updated\': \'2024-05-18 12:45\', \'temp_c\': 18.9, \'temp_f\': 66.0, \'is_day\': 1, \'condition\': {\'text\': \'Overcast\', \'icon\': \'//cdn.weatherapi.com/weather/64x64/day/122.png\', \'code\': 1009}, \'wind_mph\': 2.2, \'wind_kph\': 3.6, \'wind_degree\': 10, \'wind_dir\': \'N\', \'pressure_mb\': 1017.0, \'pressure_in\': 30.02, \'precip_mm\': 0.0, \'precip_in\': 0.0, \'humidity\': 65, \'cloud\': 100, \'feelslike_c\': 18.9, \'feelslike_f\': 66.0, \'vis_km\': 16.0, \'vis_miles\': 9.0, \'uv\': 6.0, \'gust_mph\': 7.5, \'gust_kph\': 12.0}}"}]', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': 'tavily_search_results_json', 'id': 'a36e8cd1-0e96-4417-9c15-f10a945d2b42', 'tool_call_id': 'toolu_0148tMmDK51iLQfG1yaNwRHM'}]}}
-    
-    
-    
-    Receiving new event of type: data...
-    {'agent': {'messages': [{'content': 'The weather in Los Angeles is currently overcast with a temperature of around 66°F (18.9°C). There are light winds from the north at around 2-3 mph. The humidity is 65% and visibility is good at 9 miles. Overall, mild spring weather conditions in LA.', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-d5c1c2f0-b12d-41ce-990b-f36570e7483d', 'example': False, 'tool_calls': [], 'invalid_tool_calls': []}]}}
-    
-    
-    
-    Receiving new event of type: end...
-    None

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

@@ -1,258 +0,0 @@
-# How to stream full state of your graph
-
-This guide covers how to use `stream_mode="values"`, which streams the value of the state at each superstep. This differs from using `stream_mode="updates"`: instead of streaming just the updates to the state from each node, it streams the entire graph state at that superstep. Read [this conceptual guide](https://langchain-ai.github.io/langgraph/concepts/low_level/#stream-and-astream) to learn more.
-
-First let's set up our client and thread:
-
-=== "Python"
-
-    ```python
-    from langgraph_sdk import get_client
-
-    client = get_client(url=<DEPLOYMENT_URL>)
-    # create thread
-    thread = await client.threads.create()
-    print(thread)
-    ```
-
-=== "Javascript"
-
-    ```js
-    import { Client } from "@langchain/langgraph-sdk";
-
-    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
-    // create thread
-    const thread = await client.threads.create();
-    console.log(thread);
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-      --url <DEPLOYMENT_URL>/threads \
-      --header 'Content-Type: application/json'
-    ```
-
-Output:
-
-    {
-      'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4',
-      'created_at': '2024-06-24T21:30:07.980789+00:00',
-      'updated_at': '2024-06-24T21:30:07.980789+00:00',
-      'metadata': {},
-      'status': 'idle',
-      'config': {},
-      'values': None
-    }
-
-Now we can stream by values, which streams the full state of the graph after each node has finished executing:
-
-=== "Python"
-
-    ```python
-    input = {"messages": [{"role": "human", "content": "what's the weather in la"}]}
-
-    # stream values
-    async for chunk in client.runs.stream(
-        thread["thread_id"],
-        "agent", 
-        input=input,
-        stream_mode="values"
-    ):
-        print(f"Receiving new event of type: {chunk.event}...")
-        print(chunk.data)
-        print("\n\n")
-    ```
-
-=== "Javascript"
-
-    ```js
-    const input = {"messages": [{"role": "human", "content": "what's the weather in la"}]}
-
-    const streamResponse = client.runs.stream(
-      thread["thread_id"],
-      "agent",
-      {
-        input,
-        streamMode: "values"
-      }
-    );
-    for await (const chunk of streamResponse) {
-      console.log(`Receiving new event of type: ${chunk.event}...`);
-      console.log(chunk.data);
-      console.log("\n\n");
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-     --header 'Content-Type: application/json' \
-     --data "{
-       \"assistant_id\": \"agent\",
-       \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"what's the weather in la\"}]},
-       \"stream_mode\": [
-         \"values\"
-       ]
-     }" | \
-     sed 's/\r$//' | \
-     awk '
-     /^event:/ {
-         if (data_content != "") {
-             print data_content "\n"
-         }
-         sub(/^event: /, "Receiving event of type: ", $0)
-         printf "%s...\n", $0
-         data_content = ""
-     }
-     /^data:/ {
-         sub(/^data: /, "", $0)
-         data_content = $0
-     }
-     END {
-         if (data_content != "") {
-             print data_content "\n"
-         }
-     }
-     ' 
-    ```
-
-
-Output:
-
-    Receiving new event of type: metadata...
-    {'run_id': 'f08791ce-0a3d-44e0-836c-ff62cd2e2786'}
-    
-    
-    
-    Receiving new event of type: values...
-    {'messages': [{'role': 'human', 'content': 'what's the weather in la'}]}
-    
-    
-    
-    Receiving new event of type: values...
-    {'messages': [{'content': 'what's the weather in la', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'faa15565-8823-4aa1-87af-e21b40526fae', 'example': False}, {'content': [{'id': 'toolu_01E5mSaZWm5rWJnCqmt63v4g', 'input': {'query': 'weather in los angeles'}, 'name': 'tavily_search_results_json', 'type': 'tool_use'}], 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-3fe1db7a-6b8d-4d83-ba07-8657190ad811', 'example': False, 'tool_calls': [{'name': 'tavily_search_results_json', 'args': {'query': 'weather in los angeles'}, 'id': 'toolu_01E5mSaZWm5rWJnCqmt63v4g'}], 'invalid_tool_calls': []}]}
-    
-    
-    
-    Receiving new event of type: values...
-    {'messages': [{'content': 'what's the weather in la', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'faa15565-8823-4aa1-87af-e21b40526fae', 'example': False}, {'content': [{'id': 'toolu_01E5mSaZWm5rWJnCqmt63v4g', 'input': {'query': 'weather in los angeles'}, 'name': 'tavily_search_results_json', 'type': 'tool_use'}], 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-3fe1db7a-6b8d-4d83-ba07-8657190ad811', 'example': False, 'tool_calls': [{'name': 'tavily_search_results_json', 'args': {'query': 'weather in los angeles'}, 'id': 'toolu_01E5mSaZWm5rWJnCqmt63v4g'}], 'invalid_tool_calls': []}, {'content': '[{"url": "https://www.weatherapi.com/", "content": "{\'location\': {\'name\': \'Los Angeles\', \'region\': \'California\', \'country\': \'United States of America\', \'lat\': 34.05, \'lon\': -118.24, \'tz_id\': \'America/Los_Angeles\', \'localtime_epoch\': 1716310320, \'localtime\': \'2024-05-21 9:52\'}, \'current\': {\'last_updated_epoch\': 1716309900, \'last_updated\': \'2024-05-21 09:45\', \'temp_c\': 16.7, \'temp_f\': 62.1, \'is_day\': 1, \'condition\': {\'text\': \'Overcast\', \'icon\': \'//cdn.weatherapi.com/weather/64x64/day/122.png\', \'code\': 1009}, \'wind_mph\': 8.1, \'wind_kph\': 13.0, \'wind_degree\': 250, \'wind_dir\': \'WSW\', \'pressure_mb\': 1015.0, \'pressure_in\': 29.97, \'precip_mm\': 0.0, \'precip_in\': 0.0, \'humidity\': 65, \'cloud\': 100, \'feelslike_c\': 16.7, \'feelslike_f\': 62.1, \'vis_km\': 16.0, \'vis_miles\': 9.0, \'uv\': 5.0, \'gust_mph\': 12.5, \'gust_kph\': 20.2}}"}]', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': 'tavily_search_results_json', 'id': '0d5dab31-5ff8-4ae2-a560-bc4bcba7c9d7', 'tool_call_id': 'toolu_01E5mSaZWm5rWJnCqmt63v4g'}]}
-    
-    
-    
-    Receiving new event of type: values...
-    {'messages': [{'content': 'what's the weather in la', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'faa15565-8823-4aa1-87af-e21b40526fae', 'example': False}, {'content': [{'id': 'toolu_01E5mSaZWm5rWJnCqmt63v4g', 'input': {'query': 'weather in los angeles'}, 'name': 'tavily_search_results_json', 'type': 'tool_use'}], 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-3fe1db7a-6b8d-4d83-ba07-8657190ad811', 'example': False, 'tool_calls': [{'name': 'tavily_search_results_json', 'args': {'query': 'weather in los angeles'}, 'id': 'toolu_01E5mSaZWm5rWJnCqmt63v4g'}], 'invalid_tool_calls': []}, {'content': '[{"url": "https://www.weatherapi.com/", "content": "{\'location\': {\'name\': \'Los Angeles\', \'region\': \'California\', \'country\': \'United States of America\', \'lat\': 34.05, \'lon\': -118.24, \'tz_id\': \'America/Los_Angeles\', \'localtime_epoch\': 1716310320, \'localtime\': \'2024-05-21 9:52\'}, \'current\': {\'last_updated_epoch\': 1716309900, \'last_updated\': \'2024-05-21 09:45\', \'temp_c\': 16.7, \'temp_f\': 62.1, \'is_day\': 1, \'condition\': {\'text\': \'Overcast\', \'icon\': \'//cdn.weatherapi.com/weather/64x64/day/122.png\', \'code\': 1009}, \'wind_mph\': 8.1, \'wind_kph\': 13.0, \'wind_degree\': 250, \'wind_dir\': \'WSW\', \'pressure_mb\': 1015.0, \'pressure_in\': 29.97, \'precip_mm\': 0.0, \'precip_in\': 0.0, \'humidity\': 65, \'cloud\': 100, \'feelslike_c\': 16.7, \'feelslike_f\': 62.1, \'vis_km\': 16.0, \'vis_miles\': 9.0, \'uv\': 5.0, \'gust_mph\': 12.5, \'gust_kph\': 20.2}}"}]', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': 'tavily_search_results_json', 'id': '0d5dab31-5ff8-4ae2-a560-bc4bcba7c9d7', 'tool_call_id': 'toolu_01E5mSaZWm5rWJnCqmt63v4g'}, {'content': 'Based on the weather API results, the current weather in Los Angeles is overcast with a temperature of around 62°F (17°C). There are light winds from the west-southwest around 8-13 mph. The humidity is 65% and visibility is good at 9 miles. Overall, mild spring weather conditions in LA.', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-4d6d4c23-5aad-4042-b0d9-19407a9e08e3', 'example': False, 'tool_calls': [], 'invalid_tool_calls': []}]}
-    
-    
-    
-    Receiving new event of type: end...
-    None
-    
-    
-    
-
-
-If we want to just get the final result, we can use this endpoint and just keep track of the last value we received
-
-
-=== "Python"
-
-    ```python
-    final_answer = None
-    async for chunk in client.runs.stream(
-        thread["thread_id"],
-        "agent",
-        input=input,
-        stream_mode="values"
-    ):
-        if chunk.event == "values":
-            final_answer = chunk.data
-    ```
-
-=== "Javascript"
-
-    ```js
-    let finalAnswer;
-    const streamResponse = client.runs.stream(
-      thread["thread_id"],
-      "agent",
-      {
-        input,
-        streamMode: "values"
-      }
-    );
-    for await (const chunk of streamResponse) {
-      finalAnswer = chunk.data;
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-     --header 'Content-Type: application/json' \
-     --data "{
-       \"assistant_id\": \"agent\",
-       \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"what's the weather in la\"}]},
-       \"stream_mode\": [
-         \"values\"
-       ]
-     }" | \
-     sed 's/\r$//' | \
-     awk '
-     /^data:/ { 
-         sub(/^data: /, "", $0)   
-         data_content = $0          
-     }    
-     END {                                               
-         if (data_content != "") {
-             print data_content
-         }
-     }         
-     '
-    ```
-
-
-Output:
-
-    {'messages': [{'content': 'what's the weather in la',
-       'additional_kwargs': {},
-       'response_metadata': {},
-       'type': 'human',
-       'name': None,
-       'id': 'e78c2f94-d810-42fc-a399-11f6bb1b1092',
-       'example': False},
-      {'content': [{'id': 'toolu_01SBMoAGr4U9x3ibztm2UUom',
-         'input': {'query': 'weather in los angeles'},
-         'name': 'tavily_search_results_json',
-         'type': 'tool_use'}],
-       'additional_kwargs': {},
-       'response_metadata': {},
-       'type': 'ai',
-       'name': None,
-       'id': 'run-80767ab8-09fc-40ec-9e45-657ddef5e0b1',
-       'example': False,
-       'tool_calls': [{'name': 'tavily_search_results_json',
-         'args': {'query': 'weather in los angeles'},
-         'id': 'toolu_01SBMoAGr4U9x3ibztm2UUom'}],
-       'invalid_tool_calls': []},
-      {'content': '[{"url": "https://www.weatherapi.com/", "content": "{\'location\': {\'name\': \'Los Angeles\', \'region\': \'California\', \'country\': \'United States of America\', \'lat\': 34.05, \'lon\': -118.24, \'tz_id\': \'America/Los_Angeles\', \'localtime_epoch\': 1716310320, \'localtime\': \'2024-05-21 9:52\'}, \'current\': {\'last_updated_epoch\': 1716309900, \'last_updated\': \'2024-05-21 09:45\', \'temp_c\': 16.7, \'temp_f\': 62.1, \'is_day\': 1, \'condition\': {\'text\': \'Overcast\', \'icon\': \'//cdn.weatherapi.com/weather/64x64/day/122.png\', \'code\': 1009}, \'wind_mph\': 8.1, \'wind_kph\': 13.0, \'wind_degree\': 250, \'wind_dir\': \'WSW\', \'pressure_mb\': 1015.0, \'pressure_in\': 29.97, \'precip_mm\': 0.0, \'precip_in\': 0.0, \'humidity\': 65, \'cloud\': 100, \'feelslike_c\': 16.7, \'feelslike_f\': 62.1, \'vis_km\': 16.0, \'vis_miles\': 9.0, \'uv\': 5.0, \'gust_mph\': 12.5, \'gust_kph\': 20.2}}"}]',
-       'additional_kwargs': {},
-       'response_metadata': {},
-       'type': 'tool',
-       'name': 'tavily_search_results_json',
-       'id': 'af25e94a-c119-48c3-bbd3-096e42f472ac',
-       'tool_call_id': 'toolu_01SBMoAGr4U9x3ibztm2UUom'},
-      {'content': 'Based on the weather API results, the current weather in Los Angeles is overcast with a temperature of around 62°F (17°C). There are light winds from the west-southwest around 8-13 mph. The humidity is 65% and visibility is good at 9 miles. Overall, mild spring weather conditions in LA.',
-       'additional_kwargs': {},
-       'response_metadata': {},
-       'type': 'ai',
-       'name': None,
-       'id': 'run-b90f0037-e56a-4f3b-ad92-00d10d079a9e',
-       'example': False,
-       'tool_calls': [],
-       'invalid_tool_calls': []}]}

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

@@ -1,16 +0,0 @@
-# Test Cloud Deployment
-
-The LangGraph Studio UI connects directly to LangGraph Cloud deployments.
-
-Starting from the <a href="https://smith.langchain.com/" target="_blank">LangSmith UI</a>...
-
-1. In the left-hand navigation panel, select `Deployments`. The `Deployments` view contains a list of existing LangGraph Cloud deployments.
-1. Select an existing deployment to test with LangGraph Studio.
-1. In the top-right corner, select `Open LangGraph Studio`.
-1. [Invoke an assistant](./invoke_studio.md) or [view an existing thread](./threads_studio.md).
-
-The following video shows these exact steps being carried out:
-
-<video controls allowfullscreen="true" poster="../img/studio_usage_poster.png">
-    <source src="../img/studio_usage.mp4" type="video/mp4">
-</video>

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

@@ -1,28 +0,0 @@
-# LangGraph Studio With Local Deployment
-
-!!! warning "Browser Compatibility"
-    Viewing the studio page of a local LangGraph deployment does not work in Safari. Use Chrome instead.
-
-## Setup
-
-Make sure you have setup your app correctly, by creating a compiled graph, a `.env` file with any environment variables, and a `langgraph.json` config file that points to your environment file and compiled graph. See [here](https://langchain-ai.github.io/langgraph/cloud/deployment/setup/) for more detailed instructions.
-
-After you have your app setup, head into the directory with your `langgraph.json` file and call `langgraph up -c langgraph.json --watch` to start the API server in watch mode which means it will restart on code changes, which is ideal for local testing. If the API server start correctly you should see logs that look something like this:
-
-    Ready!
-    - API: http://localhost:8123
-    2024-06-26 19:20:41,056:INFO:uvicorn.access 127.0.0.1:44138 - "GET /ok HTTP/1.1" 200
-
-Read this [reference](https://langchain-ai.github.io/langgraph/cloud/reference/cli/#up) to learn about all the options for starting the API server.
-
-## Access Studio
-
-Once you have successfully started the API server, you can access the studio by going to the following URL: `https://smith.langchain.com/studio/?baseUrl=http://127.0.0.1:8123` (see warning above if using Safari).
-
-If everything is working correctly you should see the studio show up looking something like this (with your graph diagram on the left hand side):
-
-![LangGraph Studio](./img/studio_screenshot.png)
-
-## Use the Studio for Testing
-
-To learn about how to use the studio for testing, read the [LangGraph Studio how-tos](https://langchain-ai.github.io/langgraph/cloud/how-tos/#langgraph-studio).

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

@@ -1,23 +0,0 @@
-# Interacting with Threads in Studio
-
-## View Thread
-
-1. In the top of the right-hand pane, select the `New Thread` dropdown menu to view existing threads.
-1. View the state of the thread (i.e. the output) in the right-hand pane.
-1. To create a new thread, select `+ New Thread`.
-
-The following video shows these exact steps being carried out:
-
-<video controls="true" allowfullscreen="true" poster="../img/studio_threads_poster.png">
-    <source src="../img/studio_threads.mp4" type="video/mp4">
-</video>
-
-## Edit Thread State
-
-The LangGraph Studio UI contains features for editing thread state. Explore these features in the right-hand pane. Select the `Edit` icon, modify the desired state, and then select `Fork` to invoke the assistant with the updated state.
-
-The following video shows how to edit a thread in the studio:
-
-<video controls allowfullscreen="true" poster="../img/studio_forks_poster.png">
-    <source src="../img/studio_forks.mp4" type="video/mp4">
-</video>

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

@@ -1,125 +0,0 @@
-# Use Webhooks
-
-You may wish to use webhooks in your client, especially when using async streams in case you want to update something in your service once the API call to LangGraph Cloud has finished running. To do so, you will need to expose an endpoint that can accept POST requests, and then pass it to your API request in the "webhook" parameter.
-
-Currently, the SDK has not exposed this endpoint but you can access it through curl commands as follows.
-
-The following endpoints accept `webhook` as a parameter: 
-
-- Create Run -> POST /thread/{thread_id}/runs
-- Create Thread Cron -> POST /thread/{thread_id}/runs/crons
-- Stream Run -> POST /thread/{thread_id}/runs/stream
-- Wait Run -> POST /thread/{thread_id}/runs/wait
-- Create Cron -> POST /runs/crons
-- Stream Run Stateless -> POST /runs/stream
-- Wait Run Stateless -> POST /runs/wait
-
-In this example, we will show calling a webhook after streaming a run. First, let's setup our assistant and thread:
-
-=== "Python"
-
-    ```python
-    from langgraph_sdk import get_client
-
-    client = get_client(url=<DEPLOYMENT_URL>)
-    # Using the graph deployed with the name "agent"
-    assistant_id = "agent"
-    # create thread
-    thread = await client.threads.create()
-    print(thread)
-    ```
-
-=== "Javascript"
-
-    ```js
-    import { Client } from "@langchain/langgraph-sdk";
-
-    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
-    // Using the graph deployed with the name "agent"
-    const assistantID = "agent";
-    // create thread
-    const thread = await client.threads.create();
-    console.log(thread);
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-        --url <DEPLOYMENT_URL>/assistants/search \
-        --header 'Content-Type: application/json' \
-        --data '{
-            "limit": 10,
-            "offset": 0
-        }' | jq -c 'map(select(.config == null or .config == {})) | .[0]' && \
-    curl --request POST \
-        --url <DEPLOYMENT_URL>/threads \
-        --header 'Content-Type: application/json' \
-        --data '{}'
-    ```
-
-Output:
-
-    {
-        'thread_id': '9dde5490-2b67-47c8-aa14-4bfec88af217', 
-        'created_at': '2024-08-30T23:07:38.242730+00:00', 
-        'updated_at': '2024-08-30T23:07:38.242730+00:00', 
-        'metadata': {}, 
-        'status': 'idle', 
-        'config': {}, 
-        'values': None
-    }
-
-Now we can invoke a run with a webhook:
-
-=== "Python"
-
-    ```python
-    # create input
-    input = { "messages": [{ "role": "human", "content": "Hello!" }] }
-
-    async for chunk in client.runs.stream(
-        thread_id=thread["thread_id"],
-        assistant_id=assistant_id,
-        input=input,
-        stream_mode="events",
-        webhook="your-webhook"
-    ):
-        # Do something with the stream output
-        pass
-    ```
-
-=== "Javascript"
-
-    ```js
-    // create input
-    const input = { messages: [{ role: "human", content: "Hello!" }] };
-
-    // stream events
-    const streamResponse = client.runs.stream(
-      thread["thread_id"],
-      assistantID,
-      {
-        input: input,
-        webhook: "your-webhook"
-      }
-    );
-    for await (const chunk of streamResponse) {
-      // Do something with the stream output
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-        --header 'Content-Type: application/json' \
-        --data '{
-            "assistant_id": <ASSISTANT_ID>,
-            "input" : {"messages":[{"role": "user", "content": "Hello!"}]},
-            "webhook": <YOUR_WEBHOOK_URL>
-        }'
-    ```
-
-And that's it! Now you can trigger your custom webhooks whenever you want in your LangGraph applications!

docs/docs/cloud/index.md

@@ -1,44 +0,0 @@
-# LangGraph Cloud (beta)
-
-!!! tip
-    - LangGraph is an MIT-licensed open-source library, which we are committed to maintaining and growing for the community.
-    - LangGraph Cloud is an optional managed hosting service for LangGraph, which provides additional features geared towards production deployments.
-    - We are actively contributing improvements back to LangGraph informed by our work on LangGraph Cloud.
-    - You can always deploy LangGraph applications on your own infrastructure using the open-source LangGraph project.
-
-!!! warning "Under Construction"
-    LangGraph Cloud documentation is under construction. Contents may change until general availability.
-
-
-<video controls preload="auto" allowfullscreen="true" poster="how-tos/img/studio_forks_poster.png">
-    <source src="how-tos/img/studio_forks.mp4" type="video/mp4">
-</video>
-
-
-## Overview
-
-LangGraph Cloud is a managed service for deploying and hosting LangGraph applications. Deploying applications with LangGraph Cloud shortens the time-to-market for developers. With one click, deploy a production-ready API with built-in persistence for your LangGraph application. LangGraph Cloud APIs are horizontally scalable and deployed with durable storage.
-
-The LangGraph Cloud API exposes functionality of your LangGraph application through [Assistants](./concepts/api.md#assistants). An assistant abstracts the cognitive architecture of your graph. Invoke an assistant by calling the pre-built [API endpoints](./reference/api/api_ref.md).
-
-LangGraph Cloud is seamlessly integrated with [LangSmith](https://www.langchain.com/langsmith) and is accessible from within the LangSmith UI.
-
-LangGraph Cloud applications can be tested and debugged using the [LangGraph Studio Desktop](https://github.com/langchain-ai/langgraph-studio). 
-
-## Key Features
-
-The LangGraph Cloud API supports key LangGraph features in addition to new functionality for enabling complex, agentic workflows.
-
-- **Assistants and Threads**: Assistants abstract the cognitive architecture of graphs and threads track the state/history of graphs.
-- **Streaming**: API support for [LangGraph streaming modes](../concepts/low_level.md#streaming) including setting multiple streaming modes at the same time.
-- **Human-in-the-Loop**: API support for [LangGraph human-in-the-loop features](../concepts/agentic_concepts.md#human-in-the-loop).
-- **Double Texting**: Configure how assistants respond when new input is received while processing a previous input. Interrupt, rollback, reject, or enqueue.
-- **Background Runs/Cron Jobs**: A built-in task queue enables background runs and scheduled cron jobs.
-- **Stateless Runs**: For simpler use cases, invoke an assistant without needing to create a thread.
-
-## Documentation
-
-- [Tutorials](./quick_start.md): Learn to build and deploy applications for LangGraph Cloud.
-- [How-to Guides](./how-tos/index.md): Learn how to set up a LangGraph application for deployment and implement features of the LangGraph Cloud API such as streaming tokens, configuring double texting, and creating cron jobs. Go here if you want to copy and run a specific code snippet.
-- [Conceptual Guides](./concepts/api.md): In-depth explanations of the core data models (e.g. assistants), key features of the LangGraph Cloud API (e.g. double texting), and the architecture of a LangGraph Cloud deployment.
-- [Reference](./reference/api/api_ref.md): References for the LangGraph Cloud API, the corresponding Python and JS/TS SDKs, the LangGraph CLI, and deployment environment variables.

docs/docs/cloud/quick_start.md

@@ -1,399 +0,0 @@
-# Quick Start
-
-This quick start guide will cover how to build a simple agent that can look up things on the internet. We will then deploy it to LangGraph Cloud, use the LangGraph Studio to visualize and test it out, and use the LangGraph SDK to interact with it.
-
-## Set up requirements
-
-This tutorial will use:
-
-- Anthropic for the LLM - sign up and get an API key [here](https://console.anthropic.com/)
-- Tavily for the search engine - sign up and get an API key [here](https://app.tavily.com/)
-- LangSmith for hosting - sign up and get an API key [here](https://smith.langchain.com/)
-
-## Set up local files
-
-1.  Create a new application with the following directory and files:
-
-=== "Python"
-
-        <my-app>/
-        |-- agent.py            # code for your LangGraph agent
-        |-- requirements.txt    # Python packages required for your graph
-        |-- langgraph.json      # configuration file for LangGraph
-        |-- .env                # environment files with API keys
-
-=== "Javascript"
-
-        <my-app>/
-        |-- agent.ts            # code for your LangGraph agent
-        |-- package.json        # Javascript packages required for your graph
-        |-- langgraph.json      # configuration file for LangGraph
-        |-- .env                # environment files with API keys
-
-2.  The `agent.py`/`agent.ts` file should contain code for defining your graph. The following code is a simple example, the important thing is that at some point in your file you compile your graph and assign the compiled graph to a variable (in this case the `graph` variable). This example code uses `create_react_agent`, a prebuilt agent. You can read more about it [here](../concepts/agentic_concepts.md#react-agent).
-
-=== "Python"
-
-    ```python
-    from langchain_anthropic import ChatAnthropic
-    from langchain_community.tools.tavily_search import TavilySearchResults
-    from langgraph.prebuilt import create_react_agent
-
-    model = ChatAnthropic(model="claude-3-5-sonnet-20240620")
-
-    tools = [TavilySearchResults(max_results=2)]
-
-    graph = create_react_agent(model, tools)
-    ```
-
-=== "Javascript"
-
-    ```ts
-    import { ChatAnthropic } from "@langchain/anthropic";
-    import { TavilySearchResults } from "@langchain/community/tools/tavily_search";
-    import { createReactAgent } from "@langchain/langgraph/prebuilt";
-
-    const model = new ChatAnthropic({
-      model: "claude-3-5-sonnet-20240620",
-    });
-
-    const tools = [
-      new TavilySearchResults({ maxResults: 3, }),
-    ];
-
-    export const graph = createReactAgent({ llm: model, tools });
-    ```
-
-3.  The `requirements.txt`/`package.json` file should contain any dependencies for your graph(s). In this case we only require four packages for our graph to run:
-
-=== "Python"
-
-      ```python
-      langgraph
-      langchain_anthropic
-      tavily-python
-      langchain_community
-      ```
-
-=== "Javascript"
-
-      ```js
-      {
-        "name": "my-app",
-        "packageManager": "yarn@1.22.22",
-        "dependencies": {
-          "@langchain/community": "^0.2.31",
-          "@langchain/core": "^0.2.31",
-          "@langchain/langgraph": "0.2.0",
-          "@langchain/openai": "^0.2.8"
-        }
-      }
-      ```
-
-4.  The [`langgraph.json`][langgraph.json] file is a configuration file that describes what graph(s) you are going to host. In this case we only have one graph to host: the compiled `graph` object from `agent.py`/`agent.ts`.
-
-=== "Python"
-
-    ```json
-    {
-      "dependencies": ["."],
-      "graphs": {
-        "agent": "./agent.py:graph"
-      },
-      "env": ".env"
-    }
-    ```
-
-=== "Javascript"
-
-    ```json
-    {
-      "node_version": "20",
-      "dockerfile_lines": [],
-      "dependencies": ["."],
-      "graphs": {
-        "agent": "./src/agent.ts:graph"
-      },
-      "env": ".env"
-    }
-    ```
-
-Learn more about the LangGraph CLI configuration file [here](./reference/cli.md#configuration-file).
-
-5.  The `.env` file should have any environment variables needed to run your graph. This will only be used for local testing, so if you are not testing locally you can skip this step. NOTE: if you do add this, you should NOT check this into git. For this graph, we need two environment variables:
-
-    ```shell
-    ANTHROPIC_API_KEY=...
-    TAVILY_API_KEY=...
-    ```
-
-Now that we have set everything up on our local file system, we are ready to host our graph.
-
-## Test the graph build locally
-
-### Using LangGraph Studio Desktop (recommended)
-
-![LangGraph Studio Desktop](./img/graph_video_poster.png)
-
-Testing your graph locally is easy with LangGraph Studio Desktop. LangGraph Studio offers a new way to develop LLM applications by providing a specialized agent IDE that enables visualization, interaction, and debugging of complex agentic applications
-
-With visual graphs and the ability to edit state, you can better understand agent workflows and iterate faster. LangGraph Studio integrates with [LangSmith](https://smith.langchain.com) so you can collaborate with teammates to debug failure modes.
-
-### Using the LangGraph CLI
-
-Before deploying to the cloud, we probably want to test the building of our graph locally. This is useful to make sure we have configured our [CLI configuration file][langgraph.json] correctly and our graph runs.
-
-In order to do this we can first install the LangGraph CLI
-
-```shell
-pip install langgraph-cli
-```
-
-We can then test our API server locally. This requires access to LangGraph closed beta. In order to run the server locally, you will need to add your `LANGSMITH_API_KEY` to the .env file so we can validate you have access to LangGraph closed beta.
-
-```shell
-langgraph up
-```
-
-This will start up the LangGraph API server locally. If this runs successfully, you should see something like:
-
-```shell
-Ready!
-- API: http://localhost:8123
-2024-06-26 19:20:41,056:INFO:uvicorn.access 127.0.0.1:44138 - "GET /ok HTTP/1.1" 200
-```
-
-You can now test this out! **Note: this local server is intended SOLELY for local testing purposes and is not performant enough for production applications, so please do not use it as such.** To test it out, you can go to another terminal window and run:
-
-```shell
-curl --request POST \
-    --url http://localhost:8123/runs/stream \
-    --header 'Content-Type: application/json' \
-    --data '{
-    "assistant_id": "agent",
-    "input": {
-        "messages": [
-            {
-                "role": "user",
-                "content": "How are you?"
-            }
-        ]
-    },
-    "metadata": {},
-    "config": {
-        "configurable": {}
-    },
-    "multitask_strategy": "reject",
-    "stream_mode": [
-        "values"
-    ]
-}'
-```
-
-If you get back a valid response, then all is functioning properly!
-
-## Deploy to Cloud
-
-### Push your code to GitHub
-
-Turn the `<my-app>` directory into a GitHub repo. You can use the GitHub CLI if you like, or just create a repo manually (if unfamiliar, instructions [here](https://docs.github.com/en/migrations/importing-source-code/using-the-command-line-to-import-source-code/adding-locally-hosted-code-to-github)).
-
-### Deploy from GitHub with LangGraph Cloud
-
-Once you have created your github repository with a Python file containing your compiled graph as well as a `langgraph.json` file containing the configuration for hosting your graph, you can head over to LangSmith and click on the 🚀 icon on the left navbar to create a new deployment. Then click the `+ New Deployment` button.
-
-![Langsmith Workflow](./img/cloud_deployment.png)
-
-**_If you have not deployed to LangGraph Cloud before:_** there will be a button that shows up saying Import from GitHub. You’ll need to follow that flow to connect LangGraph Cloud to GitHub.
-
-**_Once you have set up your GitHub connection:_** the new deployment page will look as follows:
-
-![Deployment before being filled out](./deployment/img/deployment_page.png)
-
-To deploy your application, you should do the following:
-
-1. Select your GitHub username or organization from the selector
-2. Search for your repo to deploy in the search bar and select it
-3. Choose any name
-4. In the `LangGraph API config file` field, enter the path to your `langgraph.json` file (which in this case is just `langgraph.json`)
-5. For Git Reference, you can select either the git branch for the code you want to deploy, or the exact commit SHA.
-6. If your chain relies on environment variables, add those in. They will be propagated to the underlying server so your code can access them. In this case, we need `ANTHROPIC_API_KEY` and `TAVILY_API_KEY`.
-
-Putting this all together, you should have something as follows for your deployment details:
-
-![Deployment filled out](./deployment/img/deploy_filled_out.png)
-
-Hit `Submit` and your application will start deploying!
-
-## Inspect Traces + Monitor Service
-
-### Deployments View
-
-After your deployment is complete, your deployments page should look as follows:
-
-![Deployed page](./deployment/img/deployed_page.png)
-
-You can see that by default, you get access to the `Trace Count` monitoring chart and `Recent Traces` run view. These are powered by LangSmith.
-
-You can click on `All Charts` to view all monitoring info for your server, or click on `See tracing project` to get more information on an individual trace.
-
-### Access the Docs
-
-You can access the docs by clicking on the API docs link, which should send you to a page that looks like this:
-
-![API Docs page](./deployment/img/api_page.png)
-
-You won’t actually be able to test any of the API endpoints without authorizing first. To do so, grab your Langsmith API key and add it at the top where it says `API KEY (X-API-KEY)`. You should now be able to select any of the API endpoints, click `Test Request`, enter the parameters you would like to pass, and then click `Send` to view the results of the API call.
-
-## Interact with your deployment via LangGraph Studio
-
-If you click on your deployment you should see a blue button in the top right that says `LangGraph Studio`. Clicking on this button will take you to a page that looks like this:
-
-![Studio UI before being run](./deployment/img/graph_visualization.png)
-
-On this page you can test out your graph by passing in starting states and clicking `Start Run` (this should behave identically to calling `.invoke`). You will then be able to look into the execution thread for each run and explore the steps your graph is taking to produce its output.
-
-![Studio UI once being run](./deployment/img/graph_run.png)
-
-## Use with the SDK
-
-Once you have tested that your hosted graph works as expected using LangGraph Studio, you can start using your hosted graph all over your organization by using the LangGraph SDK. Let's see how we can access our hosted graph and execute our run from a python file.
-
-First, make sure you have the SDK installed by calling `pip install langgraph_sdk`.
-
-Before using, you need to get the URL of your LangGraph deployment. You can find this in the `Deployment` view. Click the URL to copy it to the clipboard.
-
-You also need to make sure you have set up your API key properly so you can authenticate with LangGraph Cloud.
-
-```shell
-export LANGSMITH_API_KEY=...
-```
-
-The first thing to do when using the SDK is to setup our client, access our assistant, and create a thread to execute a run on:
-
-=== "Python"
-
-     ```python
-     from langgraph_sdk import get_client
-
-     client = get_client(url=<DEPLOYMENT_URL>)
-     # get default assistant
-     assistants = await client.assistants.search()
-     assistant = [a for a in assistants if not a["config"]][0]
-     # create thread
-     thread = await client.threads.create()
-     print(thread)
-     ```
-
-=== "Javascript"
-
-     ```js
-     import { Client } from "@langchain/langgraph-sdk";
-
-     const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
-     // get default assistant
-     const assistants = await client.assistants.search();
-     const assistant = assistants.find(a => !a.config);
-     // create thread
-     const thread = await client.threads.create();
-     console.log(thread)
-     ```
-
-=== "CURL"
-
-     ```bash
-     curl --request POST \
-         --url <DEPLOYMENT_URL>/assistants/search \
-         --header 'Content-Type: application/json' \
-         --data '{
-             "limit": 10,
-             "offset": 0
-         }' | jq -c 'map(select(.config == null or .config == {})) | .[0]' && \
-     curl --request POST \
-         --url <DEPLOYMENT_URL>/threads \
-         --header 'Content-Type: application/json' \
-         --data '{}'
-     ```
-
-We can then execute a run on the thread:
-
-=== "Python"
-
-    ```python
-    input = {"messages":[{"role": "user", "content": "Hello! My name is Bagatur and I am 26 years old."}]}
-
-    async for chunk in client.runs.stream(
-            thread['thread_id'],
-            assistant["assistant_id"],
-            input=input,
-            stream_mode="updates",
-        ):
-        if chunk.data and chunk.event != "metadata":
-            print(chunk.data)
-    ```
-
-=== "Javascript"
-
-    ```js
-    const input = { "messages":[{ "role": "user", "content": "Hello! My name is Bagatur and I am 26 years old." }] };
-
-    const streamResponse = client.runs.stream(
-      thread["thread_id"],
-      assistant["assistant_id"],
-      {
-        input,
-      }
-    );
-    for await (const chunk of streamResponse) {
-      if (chunk.data && chunk.event !== "metadata" ) {
-        console.log(chunk.data);
-      }
-    }
-    ```
-
-=== "CURL"
-
-    ```bash
-    curl --request POST \
-      --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-      --header 'Content-Type: application/json' \
-      --data "{
-        \"assistant_id\": <ASSISTANT_ID>,
-        \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"Hello! My name is Bagatur and I am 26 years old.\"}]},
-      }" | sed 's/\r$//' | awk '
-      /^event:/ { event = $2 }
-      /^data:/ {
-          json_data = substr($0, index($0, $2))
-
-          if (event != "metadata") {
-          print json_data
-          }
-      }'
-    ```
-
-
-Output:
-
-    {'agent': {'messages': [{'content': "Hi Bagatur! It's nice to meet you. How can I assist you today?", 'additional_kwargs': {}, 'response_metadata': {'finish_reason': 'stop', 'model_name': 'gpt-4o-2024-05-13', 'system_fingerprint': 'fp_9cb5d38cf7'}, 'type': 'ai', 'name': None, 'id': 'run-c89118b7-1b1e-42b9-a85d-c43fe99881cd', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}}
-
-## What's Next
-
-Congratulations! If you've worked your way through this tutorial you are well on your way to becoming a LangGraph Cloud expert. Here are some other resources to check out to help you out on the path to expertise:
-
-### LangGraph Cloud How-tos
-
-If you want to learn more about streaming from hosted graphs, check out the Streaming [how-to guides](how-tos/index.md#streaming).
-
-To learn more about double-texting and all the ways you can handle it in your application, read up on these [how-to guides](how-tos/index.md#double-texting).
-
-To learn about how to include different human-in-the-loop behavior in your graph, take a look at [these how-tos](how-tos/index.md#human-in-the-loop).
-
-### LangGraph Tutorials
-
-Before hosting, you have to write a graph to host. Here are some tutorials to get you more comfortable with writing LangGraph graphs and give you inspiration for the types of graphs you want to host.
-
-[This tutorial](../tutorials/customer-support/customer-support.ipynb) walks you through how to write a customer support bot using LangGraph.
-
-If you are interested in writing a SQL agent, check out [this tutorial](../tutorials/sql-agent.ipynb).
-
-Check out the [LangGraph tutorials](../tutorials/index.md) page to read about more exciting use cases.

docs/docs/cloud/reference/api/api_ref.html

@@ -1,19 +0,0 @@
-<!doctype html>
-<html>
-  <head>
-    <title>LangGraph Cloud API Reference</title>
-    <meta charset="utf-8" />
-    <meta
-      name="viewport"
-      content="width=device-width, initial-scale=1" />
-  </head>
-  <body>
-    <script id="api-reference" data-url="./openapi.json"></script>
-    <script>
-      var configuration = {}
-      document.getElementById('api-reference').dataset.configuration =
-        JSON.stringify(configuration)
-    </script>
-    <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"></script>
-  </body>
-</html>

docs/docs/cloud/reference/api/api_ref.md

@@ -1,22 +0,0 @@
-# API Reference
-
-The LangGraph Cloud API reference is available with each deployment at the `/docs` URL path (e.g. `http://localhost:8124/docs`).
-
-Click <a href="/langgraph/cloud/reference/api/api_ref.html" target="_blank">here</a> to view the API reference.
-
-## Authentication
-
-For deployments to LangGraph Cloud, authentication is required. Pass the `X-Api-Key` header with each request to the LangGraph Cloud API. The value of the header should be set to a valid LangSmith API key for the organization where the API is deployed.
-
-Example `curl` command:
-```shell
-curl --request POST \
-  --url http://localhost:8124/assistants/search \
-  --header 'Content-Type: application/json' \
-  --header 'X-Api-Key: LANGSMITH_API_KEY' \
-  --data '{
-  "metadata": {},
-  "limit": 10,
-  "offset": 0
-}'  
-```

docs/docs/cloud/reference/cli.md

@@ -1,127 +0,0 @@
-# LangGraph CLI
-The LangGraph CLI includes commands to build and run a LangGraph Cloud API server locally in [Docker](https://www.docker.com/). For development and testing, use the CLI to deploy a local API server.
-
-## Installation
-1. Ensure that Docker is installed (e.g. `docker --version`).
-2. Install the `langgraph-cli` Python package (e.g. `pip install langgraph-cli`).
-3. Run the command `langgraph --help` to confirm that the CLI is installed.
-
-[](){#langgraph.json}
-## Configuration File
-The LangGraph CLI requires a JSON configuration file with the following keys:
-
-| Key | Description |
-| --- | ----------- |
-| `dependencies` | **Required**. Array of dependencies for LangGraph Cloud API server. Dependencies can be one of the following: (1) `"."`, which will look for local Python packages, (2) `pyproject.toml`, `setup.py` or `requirements.txt` in the app directory `"./local_package"`, or (3) a package name. |
-| `graphs` | **Required**. Mapping from graph ID to path where the compiled graph or a function that makes a graph is defined. Example: <ul><li>`./your_package/your_file.py:variable`, where `variable` is an instance of `langgraph.graph.state.CompiledStateGraph`</li><li>`./your_package/your_file.py:make_graph`, where `make_graph` is a function that takes a config dictionary (`langchain_core.runnables.RunnableConfig`) and creates an instance of `langgraph.graph.state.StateGraph` / `langgraph.graph.state.CompiledStateGraph`.</li></ul> |
-| `env` | Path to `.env` file or a mapping from environment variable to its value. |
-| `python_version` | `3.11` or `3.12`. Defaults to `3.11`. |
-| `pip_config_file`| Path to `pip` config file. |
-| `dockerfile_lines` | Array of additional lines to add to Dockerfile following the import from parent image. |
-
-<div class="admonition tip">
-    <p class="admonition-title">Note</p>
-    <p>
-        The LangGraph CLI defaults to using the configuration file <strong>langgraph.json</strong> in the current directory.
-    </p>
-</div>
-
-Example:
-```json
-{
-    "dependencies": [
-        "langchain_openai",
-        "./your_package"
-    ],
-    "graphs": {
-        "my_graph_id": "./your_package/your_file.py:variable"
-    },
-    "env": "./.env"
-}
-```
-
-Example:
-```json
-{
-    "python_version": "3.11",
-    "dependencies": [
-        "langchain_openai",
-        "."
-    ],
-    "graphs": {
-        "my_graph_id": "./your_package/your_file.py:make_graph"
-    },
-    "env": {
-        "OPENAI_API_KEY": "secret-key"
-    }
-}
-```
-
-## Commands
-The base command for the LangGraph CLI is `langgraph`.
-
-**Usage**
-```
-langgraph [OPTIONS] COMMAND [ARGS]
-```
-
-### `build`
-Build LangGraph Cloud API server Docker image.
-
-**Usage**
-```
-langgraph build [OPTIONS]
-```
-
-**Options**
-
-| Option | Default | Description |
-| ------ | ------- | ----------- |
-| `--platform TEXT` | | Target platform(s) to build the Docker image for. Example: `langgraph build --platform linux/amd64,linux/arm64` |
-| `-t, --tag TEXT` | | **Required**. Tag for the Docker image. Example: `langgraph build -t my-image` |
-| `--pull / --no-pull` | `--pull` | Build with latest remote Docker image. Use `--no-pull` for running the LangGraph Cloud API server with locally built images. |
-| `-c, --config FILE` | `langgraph.json` | Path to configuration file declaring dependencies, graphs and environment variables. |
-| `--help` | | Display command documentation. |
-
-### `up`
-Start langgraph API server. For local testing, requires a LangSmith API key with access to LangGraph Cloud closed beta. Requires a license key for production use.
-
-**Usage**
-```
-langgraph up [OPTIONS]
-```
-
-**Options**
-
-| Option | Default | Description |
-| ------ | ------- | ----------- |
-| `--wait` | | Wait for services to start before returning. Implies --detach |
-| `--postgres-uri TEXT` | Local database | Postgres URI to use for the database. |
-| `--watch` | | Restart on file changes |
-| `--debugger-base-url TEXT` | `http://127.0.0.1:[PORT]` | URL used by the debugger to access LangGraph API. |
-| `--debugger-port INTEGER` | | Pull the debugger image locally and serve the UI on specified port |
-| `--verbose` | | Show more output from the server logs. |
-| `-c, --config FILE` | `langgraph.json` | Path to configuration file declaring dependencies, graphs and environment variables. |
-| `-d, --docker-compose FILE` | | Path to docker-compose.yml file with additional services to launch. |
-| `-p, --port INTEGER` | `8123` | Port to expose. Example: `langgraph test --port 8000` |
-| `--pull / --no-pull` | `pull` | Pull latest images. Use --no-pull for running the server with locally-built images. Example: `langgraph up --no-pull` |
-| `--recreate / --no-recreate` | `no-recreate` | Recreate containers even if their configuration and image haven't changed |
-| `--help` | | Display command documentation. | 
-
-### `test`
-Test your LangGraph in the cloud. The only function you can call from the SDK after testing your graph is `client.runs.stream(thread_id=None, ...)`
-
-**Usage**
-```
-langgraph test [OPTIONS]
-```
-
-**Options**
-
-| Option | Default | Description |
-| ------ | ------- | ----------- |
-| `--verbose` | | Show more output from the server logs. |
-| `-c, --config FILE` | `langgraph.json` | Path to configuration file declaring dependencies, graphs and environment variables. |
-| `-p, --port INTEGER` | `8123` | Port to expose. Example: `langgraph test --port 8000` |
-| `--pull / --no-pull` | `pull` | Pull latest images. Use --no-pull for running the server with locally-built images. Example: `langgraph up --no-pull` |
-| `--help` | | Display command documentation. |

docs/docs/cloud/reference/env_var.md

@@ -1,13 +0,0 @@
-# Environment Variables
-
-The LangGraph Cloud API supports specific environment variables for configuring a deployment.
-
-## `LANGGRAPH_AUTH_TYPE`
-
-Type of authentication for the LangGraph Cloud API deployment. Valid values: `langsmith`, `noop`.
-
-For deployments to LangGraph Cloud, this environment variable is set automatically. For local development or deployments where authentication is handled externally (e.g. self-hosted), set this environment variable to `noop`.
-
-## `N_JOBS_PER_WORKER`
-
-Number of jobs per worker for the LangGraph Cloud task queue. Defaults to `10`.

docs/docs/cloud/reference/sdk/python_sdk_ref.md

@@ -1,79 +0,0 @@
-# Python SDK Reference
-
-The Python SDK provides four underlying clients (`AssistantsClient`, `ThreadsClient`, `RunsClient`, `CronClient`) that correspond to each of the core API models and one top-level client (`LangGraphClient`) to access them.
-
-## get_client()
-
-The `get_client()` function returns the top-level `LangGraphClient` client.
-
-```python
-from langgraph_sdk import get_client
-
-# get top-level LangGraphClient
-client = get_client(url="http://localhost:8123")
-
-# example usage: client.<model>.<method_name>()
-assistants = await client.assistants.get(assistant_id="some_uuid")
-```
-
-::: langgraph_sdk.client.get_client
-    handler: python
-
-## LangGraphClient
-
-`LangGraphClient` is the top-level client for accessing `AssistantsClient`, `ThreadsClient`, `RunsClient`, and `CronClient`.
-
-::: langgraph_sdk.client.LangGraphClient
-    handler: python
-
-## AssistantsClient
-
-Access the `AssistantsClient` via the `LangGraphClient.assistants` attribute.
-```python
-from langgraph_sdk import get_client
-
-client = get_client(url="http://localhost:8123")
-await client.assistants.<method_name>()
-```
-
-::: langgraph_sdk.client.AssistantsClient
-    handler: python
-
-## ThreadsClient
-
-Access the `ThreadsClient` via the `LangGraphClient.threads` attribute.
-```python
-from langgraph_sdk import get_client
-
-client = get_client(url="http://localhost:8123")
-await client.threads.<method_name>()
-```
-
-::: langgraph_sdk.client.ThreadsClient
-    handler: python
-
-## RunsClient
-
-Access the `RunsClient` via the `LangGraphClient.runs` attribute.
-```python
-from langgraph_sdk import get_client
-
-client = get_client(url="http://localhost:8123")
-await client.runs.<method_name>()
-```
-
-::: langgraph_sdk.client.RunsClient
-    handler: python
-
-## CronClient
-
-Access the `CronClient` via the `LangGraphClient.crons` attribute.
-```python
-from langgraph_sdk import get_client
-
-client = get_client(url="http://localhost:8123")
-await client.crons.<method_name>()
-```
-
-::: langgraph_sdk.client.CronClient
-    handler: python

docs/docs/concepts/.meta.yml

@@ -1,4 +0,0 @@
-tags:
-  - concepts
-  - conceptual guide
-  - explanation

docs/docs/concepts/agentic_concepts.md

@@ -1,118 +0,0 @@
-# Common Agentic Patterns
-
-## Structured Output
-
-It's pretty common to want LLMs inside nodes to return structured output when building agents. This is because that structured output can often be used to route to the next step (e.g. choose between two different edges) or update specific keys of the state.
-
-Since LangGraph nodes can be arbitrary Python functions, you can do this however you want. If you want to use LangChain, [this how-to guide](https://python.langchain.com/v0.2/docs/how_to/structured_output/) is a starting point.
-
-## Tool calling
-
-It's extremely common to want agents to do tool calling. Tool calling refers to choosing from several available tools, and specifying which ones to call and what the inputs should be. This is extremely common in agents, as you often want to let the LLM decide which tools to call and then call those tools.
-
-Since LangGraph nodes can be arbitrary Python functions, you can do this however you want. If you want to use LangChain, [this how-to guide](https://python.langchain.com/v0.2/docs/how_to/tool_calling/) is a starting point.
-
-## Memory
-
-Memory is a key concept to agentic applications. Memory is important because end users often expect the application they are interacting with remember previous interactions. The most simple example of this is chatbots - they clearly need to remember previous messages in a conversation.
-
-LangGraph is perfectly suited to give you full control over the memory of your application. With user defined [`State`](./low_level.md#state) you can specify the exact schema of the memory you want to retain. With [checkpointers](./low_level.md#checkpointer) you can store checkpoints of previous interactions and resume from there in follow up interactions.
-
-See [this guide](../how-tos/persistence.ipynb) for how to add memory to your graph.
-
-## Human-in-the-loop
-
-Agentic systems often require some human-in-the-loop (or "on-the-loop") interaction patterns. This is because agentic systems are still not super reliable, so having a human involved is required for any sensitive tasks/actions. These are all easily enabled in LangGraph, largely due to [checkpointers](./low_level.md#checkpointer). The reason a checkpointer is necessary is that a lot of these interaction patterns involve running a graph up until a certain point, waiting for some sort of human feedback, and then continuing. When you want to "continue" you will need to access the state of the graph previous to getting interrupted, and checkpointers are a built in, highly convenient way to do that.
-
-There are a few common human-in-the-loop interaction patterns we see emerging.
-
-### Approval
-
-A basic one is to have the agent wait for approval before executing certain tools. This may be all tools, or just a subset of tools. This is generally recommend for more sensitive actions (like writing to a database). This can easily be done in LangGraph by setting a [breakpoint](./low_level.md#breakpoints) before specific nodes.
-
-See [this guide](../how-tos/human_in_the_loop/breakpoints.ipynb) for how do this in LangGraph.
-
-### Wait for input
-
-A similar one is to have the agent wait for human input. This can be done by:
-
-1. Create a node specifically for human input
-2. Add a breakpoint before the node
-3. Get user input
-4. Update the state with that user input, acting as that node
-5. Resume execution
-
-See [this guide](../how-tos/human_in_the_loop/wait-user-input.ipynb) for how do this in LangGraph.
-
-### Edit agent actions
-
-This is a more advanced interaction pattern. In this interaction pattern the human can actually edit some of the agent's previous decisions. This can be done either during the flow (after a [breakpoint](./low_level.md#breakpoints), part of the [approval](#approval) flow) or after the fact (as part of [time-travel](#time-travel))
-
-See [this guide](../how-tos/human_in_the_loop/edit-graph-state.ipynb) for how do this in LangGraph.
-
-### Time travel
-
-This is a pretty advanced interaction pattern. In this interaction pattern, the human can look back at the list of previous checkpoints, find one they like, optionally [edit it](#edit-agent-actions), and then resume execution from there.
-
-See [this guide](../how-tos/human_in_the_loop/time-travel.ipynb) for how to do this in LangGraph.
-
-## Review Tool Calls
-
-This is a specific type of human-in-the-loop interaction but it's worth calling out because it is so common. A lot of agent decisions are made via tool calling, so having a clear UX for reviewing tool calls is handy.
-
-A tool call consists of:
-- The name of the tool to call
-- Arguments to pass to the tool
-
-Note that these tool calls can obviously be used for actually calling functions, but they can also be used for other purposes, like to route the agent in a specific direction.
-You will want to review the tool call for both of these use cases.
-
-When reviewing tool calls, there are few actions you may want to take.
-
-1. Approve the tool call (and let the agent continue on its way)
-2. Manually change the tool call, either the tool name or the tool arguments (and let the agent continue on its way after that)
-3. Leave feedback on the tool call. This differs from (2) in that you are not changing the tool call directly, but rather leaving natural language feedback suggesting the LLM call it differently (or call a different tool). You could do this by either adding a `ToolMessage` and having the feedback be the result of the tool call, or by adding a `ToolMessage` (that simulates an error) and then a `HumanMessage` (with the feedback).
-
-See [this guide](../how-tos/human_in_the_loop/review-tool-calls.ipynb) for how to do this in LangGraph.
-
-## Map-Reduce
-
-A common pattern in agents is to generate a list of objects, do some work on each of those objects, and then combine the results. This is very similar to the common [map-reduce](https://en.wikipedia.org/wiki/MapReduce) operation. This can be tricky for a few reasons. First, it can be tough to define a structured graph ahead of time because the length of the list of objects may be unknown. Second, in order to do this map-reduce you need multiple versions of the state to exist... but the graph shares a common shared state, so how can this be?
-
-LangGraph supports this via the [Send](./low_level.md#send) api. This can be used to allow a conditional edge to Send multiple different states to multiple nodes. The state it sends can be different from the state of the core graph.
-
-See a how-to guide for this [here](../how-tos/map-reduce.ipynb)
-
-## Multi-agent
-
-A term you may have heard is "multi-agent" architectures. What exactly does this mean?
-
-Given that it is hard to even define an "agent", it's almost impossible to exactly define a "multi-agent" architecture. When most people talk about a multi-agent architecture, they typically mean a system where there are multiple different LLM-based systems. These LLM-based systems can be as simple as a prompt and an LLM call, or as complex as a [ReAct agent](#react-agent).
-
-The big question in multi-agent systems is how they communicate. This involves both the schema of how they communicate, as well as the sequence in which they communicate. LangGraph is perfect for orchestrating these types of systems. It allows you to define multiple agents (each one is a node) an arbitrary state (to encapsulate the schema of how they communicate) as well as the edges (to control the sequence in which they communicate).
-
-## Planning
-
-One of the big things that agentic systems struggle with is long term planning. A common technique to overcome this is to have an explicit planning this. This generally involves calling an LLM to come up with a series of steps to execute. From there, the system then tries to execute the series of tasks (this could use a sub-agent to do so). Optionally, you can revisit the plan after each step and update it if needed.
-
-## Reflection
-
-Agents often struggle to produce reliable results. Therefore, it can be helpful to check whether the agent has completed a task correctly or not. If it has - then you can finish. If it hasn't - then you can take the feedback on why it's not correct and pass it back into another iteration of the agent.
-
-This "reflection" step often uses an LLM, but doesn't have to. A good example of where using an LLM may not be necessary is in coding, when you can try to compile the generated code and use any errors as the feedback.
-
-## ReAct Agent
-
-One of the most common agent architectures is what is commonly called the ReAct agent architecture. In this architecture, an LLM is called repeatedly in a while-loop. At each step the agent decides which tools to call, and what the inputs to those tools should be. Those tools are then executed, and the outputs are fed back into the LLM as observations. The while-loop terminates when the agent decides it is not worth calling any more tools.
-
-One of the few high level, pre-built agents we have in LangGraph - you can use it with [`create_react_agent`](../reference/prebuilt.md#create_react_agent)
-
-This is named after and based on the [ReAct](https://arxiv.org/abs/2210.03629) paper. However, there are several differences between this paper and our implementation:
-
-- First, we use [tool-calling](#tool-calling) to have LLMs call tools, whereas the paper used prompting + parsing of raw output. This is because tool calling did not exist when the paper was written, but is generally better and more reliable.
-- Second, we use messages to prompt the LLM, whereas the paper used string formatting. This is because at the time of writing, LLMs didn't even expose a message-based interface, whereas now that's the only interface they expose.
-- Third, the paper required all inputs to the tools to be a single string. This was largely due to LLMs not being super capable at the time, and only really being able to generate a single input. Our implementation allows for using tools that require multiple inputs.
-- Forth, the paper only looks at calling a single tool at the time, largely due to limitations in LLMs performance at the time. Our implementation allows for calling multiple tools at a time.
-- Finally, the paper asked the LLM to explicitly generate a "Thought" step before deciding which tools to call. This is the "Reasoning" part of "ReAct". Our implementation does not do this by default, largely because LLMs have gotten much better and that is not as necessary. Of course, if you wish to prompt it do so, you certainly can.
-
-See [this guide](../how-tos/human_in_the_loop/time-travel.ipynb) for a full walkthrough of how to use the prebuilt ReAct agent.

docs/docs/concepts/faq.md

@@ -1,15 +0,0 @@
-# FAQ
-
-Common questions and their answers!
-
-## Do I need to use LangChain in order to use LangGraph?
-
-No! LangGraph is a general-purpose framework - the nodes and edges are nothing more than Python functions. You can use LangChain, raw HTTP requests, or even other frameworks inside these nodes and edges.
-
-## Does LangGraph work with LLMs that don't support tool calling?
-
-Yes! You can use LangGraph with any LLMs. The main reason we use LLMs that support tool calling is that this is often the most convenient way to have the LLM make its decision about what to do. If your LLM does not support tool calling, you can still use it - you just need to write a bit of logic to convert the raw LLM string response to a decision about what to do.
-
-## Does LangGraph work with OSS LLMs?
-
-Yes! LangGraph is totally ambivalent to what LLMs are used under the hood. The main reason we use closed LLMs in most of the tutorials is that they seamlessly support tool calling, while OSS LLMs often don't. But tool calling is not necessary (see [this section](#does-langgraph-work-with-llms-that-dont-support-tool-calling)) so you can totally use LangGraph with OSS LLMs.

docs/docs/concepts/high_level.md

@@ -1,55 +0,0 @@
-# LangGraph for Agentic Applications
-
-## What does it mean to be agentic?
-
-Other people may talk about a system being an "agent" - we prefer to talk about systems being "agentic". But what does this actually mean?
-
-When we talk about systems being "agentic", we are talking about systems that use an LLM to decide the control flow of an application. There are different levels that an LLM can be used to decide the control flow, and this spectrum of "agentic" makes more sense to us than defining an arbitrary cutoff for what is or isn't an agent.
-
-Examples of using an LLM to decide the control of an application:
-
-- Using an LLM to route between two potential paths
-- Using an LLM to decide which of many tools to call
-- Using an LLM to decide whether the generated answer is sufficient or more work is need
-
-The more times these types of decisions are made inside an application, the more agentic it is.
-If these decisions are being made in a loop, then its even more agentic!
-
-There are other concepts often associated with being agentic, but we would argue these are a by-product of the above definition:
-
-- [Tool calling](agentic_concepts.md#tool-calling): this is often how LLMs make decisions
-- Action taking: often times, the LLMs' outputs are used as the input to an action
-- [Memory](agentic_concepts.md#memory): reliable systems need to have knowledge of things that occurred
-- [Planning](agentic_concepts.md#planning): planning steps (either explicit or implicit) are useful for ensuring that the LLM, when making decisions, makes them in the highest fidelity way.
-
-## Why LangGraph?
-
-LangGraph has several core principles that we believe make it the most suitable framework for building agentic applications:
-
-- [Controllability](../how-tos/index.md#controllability)
-- [Human-in-the-Loop](../how-tos/index.md#human-in-the-loop)
-- [Streaming First](../how-tos/index.md#streaming)
-
-**Controllability**
-
-LangGraph is extremely low level. This gives you a high degree of control over what the system you are building actually does. We believe this is important because it is still hard to get agentic systems to work reliably, and we've seen that the more control you exercise over them, the more likely it is that they will "work".
-
-**Human-in-the-Loop**
-
-LangGraph comes with a built-in persistence layer as a first-class concept. This enables several different human-in-the-loop interaction patterns. We believe that "Human-Agent Interaction" patterns will be the new "Human-Computer Interaction", and have built LangGraph with built in persistence to enable this.
-
-**Streaming First**
-
-LangGraph comes with first class support for streaming. Agentic applications often take a while to run, and so giving the user some idea of what is happening is important, and streaming is a great way to do that. LangGraph supports streaming of both events ([like a tool call being taken](../how-tos/stream-updates.ipynb)) as well as of [tokens that an LLM may emit](../how-tos/streaming-tokens.ipynb).
-
-## Deployment
-
-So you've built your LangGraph object - now what?
-
-Now you need to deploy it. 
-There are many ways to deploy LangGraph objects, and the right solution depends on your needs and use case.
-We'll highlight two ways here: using [LangGraph Cloud](../cloud/index.md) or rolling your own solution.
-
-[LangGraph Cloud](../cloud/index.md) is an opinionated way to deploy LangGraph objects from the LangChain team. Please see the [LangGraph Cloud documentation](../cloud/index.md) for all the details about what it involves, to see if it is a good fit for you.
-
-If it is not a good fit, you may want to roll your own deployment. In this case, we would recommend using [FastAPI](https://fastapi.tiangolo.com/) to stand up a server. You can then call this graph from inside the FastAPI server as you see fit.

docs/docs/concepts/index.md

@@ -1,57 +0,0 @@
-# Conceptual Guides
-
-In this guide we will explore the concepts behind build agentic and multi-agent systems with LangGraph. We assume you have already learned the basic covered in the [introduction tutorial](../tutorials/introduction.ipynb) and want to deepen your understanding of LangGraph's underlying design and inner workings.
-
-There are three main parts to this concept guide. First, we'll discuss at a very high level what it means to be agentic. Next, we'll look at lower-level concepts in LangGraph that are core for understanding how to build your own agentic systems. Finally, we'll discuss common agentic patterns and how you can achieve those with LangGraph. These will be mostly conceptual guides - for more technical, hands-on guides see our [how-to guides](../how-tos/index.md)
-
-
-LangGraph for Agentic Applications
-
-- [What does it mean to be agentic?](high_level.md#what-does-it-mean-to-be-agentic)
-- [Why LangGraph](high_level.md#why-langgraph)
-- [Deployment](high_level.md#deployment)
-
-Low Level Concepts
-
-- [Graphs](low_level.md#graphs)
-    - [StateGraph](low_level.md#stategraph)
-    - [MessageGraph](low_level.md#messagegraph)
-    - [Compiling Your Graph](low_level.md#compiling-your-graph)
-- [State](low_level.md#state)
-    - [Schema](low_level.md#schema)
-    - [Reducers](low_level.md#reducers)
-    - [MessageState](low_level.md#working-with-messages-in-graph-state)
-- [Nodes](low_level.md#nodes)
-    - [`START` node](low_level.md#start-node)
-    - [`END` node](low_level.md#end-node)
-- [Edges](low_level.md#edges)
-    - [Normal Edges](low_level.md#normal-edges)
-    - [Conditional Edges](low_level.md#conditional-edges)
-    - [Entry Point](low_level.md#entry-point)
-    - [Conditional Entry Point](low_level.md#conditional-entry-point)
-- [Send](low_level.md#send)
-- [Checkpointer](low_level.md#checkpointer)
-- [Threads](low_level.md#threads)
-- [Checkpointer states](low_level.md#checkpointer-state)
-    - [Get state](low_level.md#get-state)
-    - [Get state history](low_level.md#get-state-history)
-    - [Update state](low_level.md#update-state)
-- [Configuration](low_level.md#configuration)
-- [Visualization](low_level.md#visualization)
-- [Streaming](low_level.md#streaming)
-
-Common Agentic Patterns
-
-- [Structured output](agentic_concepts.md#structured-output)
-- [Tool calling](agentic_concepts.md#tool-calling)
-- [Memory](agentic_concepts.md#memory)
-- [Human in the loop](agentic_concepts.md#human-in-the-loop)
-    - [Approval](agentic_concepts.md#approval)
-    - [Wait for input](agentic_concepts.md#wait-for-input)
-    - [Edit agent actions](agentic_concepts.md#edit-agent-actions)
-    - [Time travel](agentic_concepts.md#time-travel)
-- [Map-Reduce](agentic_concepts.md#map-reduce)
-- [Multi-agent](agentic_concepts.md#multi-agent)
-- [Planning](agentic_concepts.md#planning)
-- [Reflection](agentic_concepts.md#reflection)
-- [Off-the-shelf ReAct Agent](agentic_concepts.md#react-agent)

docs/docs/concepts/low_level.md

@@ -1,638 +0,0 @@
-# Low Level Conceptual Guide
-
-## Graphs
-
-At its core, LangGraph models agent workflows as graphs. You define the behavior of your agents using three key components:
-
-1. [`State`](#state): A shared data structure that represents the current snapshot of your application. It can be any Python type, but is typically a `TypedDict` or Pydantic `BaseModel`.
-
-2. [`Nodes`](#nodes): Python functions that encode the logic of your agents. They receive the current `State` as input, perform some computation or side-effect, and return an updated `State`.
-
-3. [`Edges`](#edges): Python functions that determine which `Node` to execute next based on the current `State`. They can be conditional branches or fixed transitions.
-
-By composing `Nodes` and `Edges`, you can create complex, looping workflows that evolve the `State` over time. The real power, though, comes from how LangGraph manages that `State`. To emphasize: `Nodes` and `Edges` are nothing more than Python functions - they can contain an LLM or just good ol' Python code.
-
-In short: _nodes do the work. edges tell what to do next_.
-
-LangGraph's underlying graph algorithm uses [message passing](https://en.wikipedia.org/wiki/Message_passing) to define a general program. When a Node completes its operation, it sends messages along one or more edges to other node(s). These recipient nodes then execute their functions, pass the resulting messages to the next set of nodes, and the process continues. Inspired by Google's [Pregel](https://research.google/pubs/pregel-a-system-for-large-scale-graph-processing/) system, the program proceeds in discrete "super-steps."
-
-A super-step can be considered a single iteration over the graph nodes. Nodes that run in parallel are part of the same super-step, while nodes that run sequentially belong to separate super-steps. At the start of graph execution, all nodes begin in an `inactive` state. A node becomes `active` when it receives a new message (state) on any of its incoming edges (or "channels"). The active node then runs its function and responds with updates. At the end of each super-step, nodes with no incoming messages vote to `halt` by marking themselves as `inactive`. The graph execution terminates when all nodes are `inactive` and no messages are in transit.
-
-### StateGraph
-
-The `StateGraph` class is the main graph class to uses. This is parameterized by a user defined `State` object.
-
-### MessageGraph
-
-The `MessageGraph` class is a special type of graph. The `State` of a `MessageGraph` is ONLY a list of messages. This class is rarely used except for chatbots, as most applications require the `State` to be more complex than a list of messages.
-
-### Compiling your graph
-
-To build your graph, you first define the [state](#state), you then add [nodes](#nodes) and [edges](#edges), and then you compile it. What exactly is compiling your graph and why is it needed?
-
-Compiling is a pretty simple step. It provides a few basic checks on the structure of your graph (no orphaned nodes, etc). It is also where you can specify runtime args like [checkpointers](#checkpointer) and [breakpoints](#breakpoints). You compile your graph by just calling the `.compile` method:
-
-```python
-graph = graph_builder.compile(...)
-```
-
-You **MUST** compile your graph before you can use it.
-
-## State
-
-The first thing you do when you define a graph is define the `State` of the graph. The `State` consists of the [schema of the graph](#schema) as well as [`reducer` functions](#reducers) which specify how to apply updates to the state. The schema of the `State` will be the input schema to all `Nodes` and `Edges` in the graph, and can be either a `TypedDict` or a `Pydantic` model. All `Nodes` will emit updates to the `State` which are then applied using the specified `reducer` function.
-
-### Schema
-
-The main documented way to specify the schema of a graph is by using `TypedDict`. However, we also support [using a Pydantic BaseModel](../how-tos/state-model.ipynb) as your graph state to add **default values** and additional data validation.
-
-By default, the graph will have the same input and output schemas. If you want to change this, you can also specify explicit input and output schemas directly. This is useful when you have a lot of keys, and some are explicitly for input and others for output. See the [notebook here](../how-tos/input_output_schema.ipynb) for how to use.
-
-By default, all nodes in the graph will share the same state. This means that they will read and write to the same state channels. It is possible to have nodes write to private state channels inside the graph for internal node communication - see [this notebook](../how-tos/pass_private_state.ipynb) for how to do that.
-
-### Reducers
-
-Reducers are key to understanding how updates from nodes are applied to the `State`. Each key in the `State` has its own independent reducer function. If no reducer function is explicitly specified then it is assumed that all updates to that key should override it. There are a few different types of reducers, starting with the default type of reducer:
-
-#### Default Reducer
-
-These two examples show how to use the default reducer:
-
-**Example A:**
-
-```python
-from typing import TypedDict
-
-class State(TypedDict):
-    foo: int
-    bar: list[str]
-```
-
-In this example, no reducer functions are specified for any key. Let's assume the input to the graph is `{"foo": 1, "bar": ["hi"]}`. Let's then assume the first `Node` returns `{"foo": 2}`. This is treated as an update to the state. Notice that the `Node` does not need to return the whole `State` schema - just an update. After applying this update, the `State` would then be `{"foo": 2, "bar": ["hi"]}`. If the second node returns `{"bar": ["bye"]}` then the `State` would then be `{"foo": 2, "bar": ["bye"]}`
-
-**Example B:**
-
-```python
-from typing import TypedDict, Annotated
-from operator import add
-
-class State(TypedDict):
-    foo: int
-    bar: Annotated[list[str], add]
-```
-
-In this example, we've used the `Annotated` type to specify a reducer function (`operator.add`) for the second key (`bar`). Note that the first key remains unchanged. Let's assume the input to the graph is `{"foo": 1, "bar": ["hi"]}`. Let's then assume the first `Node` returns `{"foo": 2}`. This is treated as an update to the state. Notice that the `Node` does not need to return the whole `State` schema - just an update. After applying this update, the `State` would then be `{"foo": 2, "bar": ["hi"]}`. If the second node returns `{"bar": ["bye"]}` then the `State` would then be `{"foo": 2, "bar": ["hi", "bye"]}`. Notice here that the `bar` key is updated by adding the two lists together.
-
-#### Context Reducer
-
-You can use `Context` channels to define shared resources (such as database connections) that are managed outside of your graph's nodes and excluded from checkpointing. The context manager provided to the Context channel is entered before the first step of the graph execution and exited after the last step, allowing you to set up and clean up resources for the duration of the graph invocation. Read this [how to](https://langchain-ai.github.io/langgraph/how-tos/state-context-key) to see an example of using the `Context` channel in your graph.
-
-### Working with Messages in Graph State
-
-#### Why use messages?
-
-Most modern LLM providers have a chat model interface that accepts a list of messages as input. LangChain's [`ChatModel`](https://python.langchain.com/v0.2/docs/concepts/#chat-models) in particular accepts a list of `Message` objects as inputs. These messages come in a variety of forms such as `HumanMessage` (user input) or `AIMessage` (LLM response). To read more about what message objects are, please refer to [this](https://python.langchain.com/v0.2/docs/concepts/#messages) conceptual guide.
-
-#### Using Messages in your Graph
-
-In many cases, it is helpful to store prior conversation history as a list of messages in your graph state. To do so, we can add a key (channel) to the graph state that stores a list of `Message` objects and annotate it with a reducer function (see `messages` key in the example below). The reducer function is vital to telling the graph how to update the list of `Message` objects in the state with each state update (for example, when a node sends an update). If you don't specify a reducer, every state update will overwrite the list of messages with the most recently provided value. If you wanted to simply append messages to the existing list, you could use `operator.add` as a reducer.
-
-However, you might also want to manually update messages in your graph state (e.g. human-in-the-loop). If you were to use `operator.add`, the manual state updates you send to the graph would be appended to the existing list of messages, instead of updating existing messages. To avoid that, you need a reducer that can keep track of message IDs and overwrite existing messages, if updated. To achieve this, you can use the prebuilt `add_messages` function. For brand new messages, it will simply append to existing list, but it will also handle the updates for existing messages correctly.
-
-#### Serialization
-
-In addition to keeping track of message IDs, the `add_messages` function will also try to deserialize messages into LangChain `Message` objects whenever a state update is received on the `messages` channel. See more information on LangChain serialization/deserialization [here](https://python.langchain.com/v0.2/docs/how_to/serialization/). This allows sending graph inputs / state updates in the following format:
-
-```python
-# this is supported
-{"messages": [HumanMessage(content="message")]}
-
-# and this is also supported
-{"messages": [{"type": "human", "content": "message"}]}
-```
-
-Since the state updates are always deserialized into LangChain `Messages` when using `add_messages`, you should use dot notation to access message attributes, like `state["messages"][-1].content`. Below is an example of a graph that uses `add_messages` as it's reducer function.
-
-```python
-from langchain_core.messages import AnyMessage
-from langgraph.graph.message import add_messages
-from typing import Annotated, TypedDict
-
-class GraphState(TypedDict):
-    messages: Annotated[list[AnyMessage], add_messages]
-```
-
-#### MessagesState
-
-Since having a list of messages in your state is so common, there exists a prebuilt state called `MessagesState` which makes it easy to use messages. `MessagesState` is defined with a single `messages` key which is a list of `AnyMessage` objects and uses the `add_messages` reducer. Typically, there is more state to track than just messages, so we see people subclass this state and add more fields, like:
-
-```python
-from langgraph.graph import MessagesState
-
-class State(MessagesState):
-    documents: list[str]
-```
-
-## Nodes
-
-In LangGraph, nodes are typically python functions (sync or `async`) where the **first** positional argument is the [state](#state), and (optionally), the **second** positional argument is a "config", containing optional [configurable parameters](#configuration) (such as a `thread_id`).
-
-Similar to `NetworkX`, you add these nodes to a graph using the [add_node][langgraph.graph.StateGraph.add_node] method:
-
-```python
-from langchain_core.runnables import RunnableConfig
-from langgraph.graph import StateGraph
-
-builder = StateGraph(dict)
-
-
-def my_node(state: dict, config: RunnableConfig):
-    print("In node: ", config["configurable"]["user_id"])
-    return {"results": f"Hello, {state['input']}!"}
-
-
-# The second argument is optional
-def my_other_node(state: dict):
-    return state
-
-
-builder.add_node("my_node", my_node)
-builder.add_node("other_node", my_other_node)
-...
-```
-
-Behind the scenes, functions are converted to [RunnableLambda's](https://api.python.langchain.com/en/latest/runnables/langchain_core.runnables.base.RunnableLambda.html#langchain_core.runnables.base.RunnableLambda), which add batch and async support to your function, along with native tracing and debugging.
-
-If you add a node to graph without specifying a name, it will be given a default name equivalent to the function name.
-
-```python
-builder.add_node(my_node)
-# You can then create edges to/from this node by referencing it as `"my_node"`
-```
-
-### `START` Node
-
-The `START` Node is a special node that represents the node sends user input to the graph. The main purpose for referencing this node is to determine which nodes should be called first.
-
-```python
-from langgraph.graph import START
-
-graph.add_edge(START, "node_a")
-```
-
-### `END` Node
-
-The `END` Node is a special node that represents a terminal node. This node is referenced when you want to denote which edges have no actions after they are done.
-
-```
-from langgraph.graph import END
-
-graph.add_edge("node_a", END)
-```
-
-## Edges
-
-Edges define how the logic is routed and how the graph decides to stop. This is a big part of how your agents work and how different nodes communicate with each other. There are a few key types of edges:
-
-- Normal Edges: Go directly from one node to the next.
-- Conditional Edges: Call a function to determine which node(s) to go to next.
-- Entry Point: Which node to call first when user input arrives.
-- Conditional Entry Point: Call a function to determine which node(s) to call first when user input arrives.
-
-A node can have MULTIPLE outgoing edges. If a node has multiple out-going edges, **all** of those destination nodes will be executed in parallel as a part of the next superstep.
-
-### Normal Edges
-
-If you **always** want to go from node A to node B, you can use the [add_edge][langgraph.graph.StateGraph.add_edge] method directly.
-
-```python
-graph.add_edge("node_a", "node_b")
-```
-
-### Conditional Edges
-
-If you want to **optionally** route to 1 or more edges (or optionally terminate), you can use the [add_conditional_edges][langgraph.graph.StateGraph.add_conditional_edges] method. This method accepts the name of a node and a "routing function" to call after that node is executed:
-
-```python
-graph.add_conditional_edges("node_a", routing_function)
-```
-
-Similar to nodes, the `routing_function` accept the current `state` of the graph and return a value.
-
-By default, the return value `routing_function` is used as the name of the node (or a list of nodes) to send the state to next. All those nodes will be run in parallel as a part of the next superstep.
-
-You can optionally provide a dictionary that maps the `routing_function`'s output to the name of the next node.
-
-```python
-graph.add_conditional_edges("node_a", routing_function, {True: "node_b", False: "node_c"})
-```
-
-### Entry Point
-
-The entry point is the first node(s) that are run when the graph starts. You can use the [`add_edge`][langgraph.graph.StateGraph.add_edge] method from the virtual [`START`][start] node to the first node to execute to specify where to enter the graph.
-
-```python
-from langgraph.graph import START
-
-graph.add_edge(START, "node_a")
-```
-
-### Conditional Entry Point
-
-A conditional entry point lets you start at different nodes depending on custom logic. You can use [`add_conditional_edges`][langgraph.graph.StateGraph.add_conditional_edges] from the virtual [`START`][start] node to accomplish this.
-
-```python
-from langgraph.graph import START
-
-graph.add_conditional_edges(START, routing_function)
-```
-
-You can optionally provide a dictionary that maps the `routing_function`'s output to the name of the next node.
-
-```python
-graph.add_conditional_edges(START, routing_function, {True: "node_b", False: "node_c"})
-```
-
-## `Send`
-
-By default, `Nodes` and `Edges` are defined ahead of time and operate on the same shared state. However, there can be cases where the exact edges are not known ahead of time and/or you may want different versions of `State` to exist at the same time. A common of example of this is with `map-reduce` design patterns. In this design pattern, a first node may generate a list of objects, and you may want to apply some other node to all those objects. The number of objects may be unknown ahead of time (meaning the number of edges may not be known) and the input `State` to the downstream `Node` should be different (one for each generated object).
-
-To support this design pattern, LangGraph supports returning [`Send`](../reference/graphs.md#send) objects from conditional edges. `Send` takes two arguments: first is the name of the node, and second is the state to pass to that node.
-
-```python
-def continue_to_jokes(state: OverallState):
-    return [Send("generate_joke", {"subject": s}) for s in state['subjects']]
-
-graph.add_conditional_edges("node_a", continue_to_jokes)
-```
-
-## Checkpointer
-
-LangGraph has a built-in persistence layer, implemented through [checkpointers][basecheckpointsaver]. When you use a checkpointer with a graph, you can interact with the state of that graph. When you use a checkpointer with a graph, you can interact with and manage the graph's state. The checkpointer saves a _checkpoint_ of the graph state at every super-step, enabling several powerful capabilities:
-
-First, checkpointers facilitate [human-in-the-loop workflows](agentic_concepts.md#human-in-the-loop) workflows by allowing humans to inspect, interrupt, and approve steps.Checkpointers are needed for these workflows as the human has to be able to view the state of a graph at any point in time, and the graph has to be to resume execution after the human has made any updates to the state.
-
-Second, it allows for ["memory"](agentic_concepts.md#memory) between interactions. You can use checkpointers to create threads and save the state of a thread after a graph executes. In the case of repeated human interactions (like conversations) any follow up messages can be sent to that checkpoint, which will retain its memory of previous ones.
-
-See [this guide](../how-tos/persistence.ipynb) for how to add a checkpointer to your graph.
-
-## Threads
-
-Threads enable the checkpointing of multiple different runs, making them essential for multi-tenant chat applications and other scenarios where maintaining separate states is necessary. A thread is a unique ID assigned to a series of checkpoints saved by a checkpointer. When using a checkpointer, you must specify a `thread_id` or `thread_ts` when running the graph.
-
-`thread_id` is simply the ID of a thread. This is always required
-
-`thread_ts` can optionally be passed. This identifier refers to a specific checkpoint within a thread. This can be used to kick of a run of a graph from some point halfway through a thread.
-
-You must pass these when invoking the graph as part of the configurable part of the config.
-
-```python
-config = {"configurable": {"thread_id": "a"}}
-graph.invoke(inputs, config=config)
-```
-
-See [this guide](../how-tos/persistence.ipynb) for how to use threads.
-
-## Checkpointer state
-
- When interacting with the checkpointer state, you must specify a [thread identifier](#threads).Each checkpoint saved by the checkpointer has two properties:
-
-- **values**: This is the value of the state at this point in time.
-- **next**: This is a tuple of the nodes to execute next in the graph.
-
-### Get state
-
-You can get the state of a checkpointer by calling `graph.get_state(config)`. The config should contain `thread_id`, and the state will be fetched for that thread.
-
-### Get state history
-
-You can also call `graph.get_state_history(config)` to get a list of the history of the graph. The config should contain `thread_id`, and the state history will be fetched for that thread.
-
-### Update state
-
-You can also interact with the state directly and update it. This takes three different components:
-
-- config
-- values
-- `as_node`
-
-**config**
-
-The config should contain `thread_id` specifying which thread to update.
-
-**values**
-
-These are the values that will be used to update the state. Note that this update is treated exactly as any update from a node is treated. This means that these values will be passed to the [reducer](#reducers) functions that are part of the state. So this does NOT automatically overwrite the state. Let's walk through an example.
-
-Let's assume you have defined the state of your graph as:
-
-```python
-from typing import TypedDict, Annotated
-from operator import add
-
-class State(TypedDict):
-    foo: int
-    bar: Annotated[list[str], add]
-```
-
-Let's now assume the current state of the graph is
-
-```
-{"foo": 1, "bar": ["a"]}
-```
-
-If you update the state as below:
-
-```
-graph.update_state(config, {"foo": 2, "bar": ["b"]})
-```
-
-Then the new state of the graph will be:
-
-```
-{"foo": 2, "bar": ["a", "b"]}
-```
-
-The `foo` key is completely changed (because there is no reducer specified for that key, so it overwrites it). However, there is a reducer specified for the `bar` key, and so it appends `"b"` to the state of `bar`.
-
-**`as_node`**
-
-The final thing you specify when calling `update_state` is `as_node`. This update will be applied as if it came from node `as_node`. If `as_node` is not provided, it will be set to the last node that updated the state, if not ambiguous.
-
-The reason this matters is that the next steps in the graph to execute depend on the last node to have given an update, so this can be used to control which node executes next.
-
-## Graph Migrations
-
-LangGraph can easily handle migrations of graph definitions (nodes, edges, and state) even when using a checkpointer to track state.
-
-- For threads at the end of the graph (i.e. not interrupted) you can change the entire topology of the graph (i.e. all nodes and edges, remove, add, rename, etc)
-- For threads currently interrupted, we support all topology changes other than renaming / removing nodes (as that thread could now be about to enter a node that no longer exists) -- if this is a blocker please reach out and we can prioritize a solution.
-- For modifying state, we have full backwards and forwards compatibility for adding and removing keys
-- State keys that are renamed lose their saved state in existing threads
-- State keys whose types change in incompatible ways could currently cause issues in threads with state from before the change -- if this is a blocker please reach out and we can prioritize a solution.
-
-## Configuration
-
-When creating a graph, you can also mark that certain parts of the graph are configurable. This is commonly done to enable easily switching between models or system prompts. This allows you to create a single "cognitive architecture" (the graph) but have multiple different instance of it.
-
-You can optionally specify a `config_schema` when creating a graph.
-
-```python
-class ConfigSchema(TypedDict):
-    llm: str
-
-graph = StateGraph(State, config_schema=ConfigSchema)
-```
-
-You can then pass this configuration into the graph using the `configurable` config field.
-
-```python
-config = {"configurable": {"llm": "anthropic"}}
-
-graph.invoke(inputs, config=config)
-```
-
-You can then access and use this configuration inside a node:
-
-```python
-def node_a(state, config):
-    llm_type = config.get("configurable", {}).get("llm", "openai")
-    llm = get_llm(llm_type)
-    ...
-```
-
-See [this guide](../how-tos/configuration.ipynb) for a full breakdown on configuration.
-
-### Recursion Limit
-
-The recursion limit sets the maximum number of [super-steps](#graphs) the graph can execute during a single execution. Once the limit is reached, LangGraph will raise `GraphRecursionError`. By default this value is set to 25 steps. The recursion limit can be set on any graph at runtime, and is passed to `.invoke`/`.stream` via the config dictionary. Importantly, `recursion_limit` is a standalone `config` key and should not be passed inside the `configurable` key as all other user-defined configuration. See the example below:
-
-```python
-graph.invoke(inputs, config={"recursion_limit": 5, "configurable":{"llm": "anthropic"}})
-```
-
-Read [this how-to](https://langchain-ai.github.io/langgraph/how-tos/recursion-limit/) to learn more about how the recursion limit works.
-
-## Breakpoints
-
-It can often be useful to set breakpoints before or after certain nodes execute. This can be used to wait for human approval before continuing. These can be set when you ["compile" a graph](#compiling-your-graph). You can set breakpoints either _before_ a node executes (using `interrupt_before`) or after a node executes (using `interrupt_after`.)
-
-You **MUST** use a [checkpoiner](#checkpointer) when using breakpoints. This is because your graph needs to be able to resume execution.
-
-In order to resume execution, you can just invoke your graph with `None` as the input.
-
-```python
-# Initial run of graph
-graph.invoke(inputs, config=config)
-
-# Let's assume it hit a breakpoint somewhere, you can then resume by passing in None
-graph.invoke(None, config=config)
-```
-
-See [this guide](../how-tos/human_in_the_loop/breakpoints.ipynb) for a full walkthrough of how to add breakpoints.
-
-## Visualization
-
-It's often nice to be able to visualize graphs, especially as they get more complex. LangGraph comes with several built-in ways to visualize graphs. See [this how-to guide](../how-tos/visualization.ipynb) for more info.
-
-## Streaming
-
-LangGraph is built with first class support for streaming. There are several different ways to stream back results
-
-### `.stream` and `.astream`
-
-`.stream` and `.astream` are sync and async methods for streaming back results.
-There are several different modes you can specify when calling these methods (e.g. `graph.stream(..., mode="...")):
-
-- [`"values"`](../how-tos/stream-values.ipynb): This streams the full value of the state after each step of the graph.
-- [`"updates"`](../how-tos/stream-updates.ipynb): This streams the updates to the state after each step of the graph. If multiple updates are made in the same step (e.g. multiple nodes are run) then those updates are streamed separately.
-- `"debug"`: This streams as much information as possible throughout the execution of the graph.
-
-The below visualization shows the difference between the `values` and `updates` modes:
-
-![values vs updates](../static/values_vs_updates.png)
-
-
-### `.astream_events` (for streaming tokens of LLM calls)
-
-In addition, you can use the [`astream_events`](../how-tos/streaming-events-from-within-tools.ipynb) method to stream back events that happen _inside_ nodes. This is useful for [streaming tokens of LLM calls](../how-tos/streaming-tokens.ipynb).
-
-This is a standard method on all [LangChain objects](https://python.langchain.com/v0.2/docs/concepts/#runnable-interface). This means that as the graph is executed, certain events are emitted along the way and can be seen if you run the graph using `.astream_events`. 
-
-All events have (among other things) `event`, `name`, and `data` fields. What do these mean?
-
-- `event`: This is the type of event that is being emitted. You can find a detailed table of all callback events and triggers [here](https://python.langchain.com/v0.2/docs/concepts/#callback-events).
-- `name`: This is the name of event.
-- `data`: This is the data associated with the event.
-
-What types of things cause events to be emitted?
-
-* each node (runnable) emits `on_chain_start` when it starts execution, `on_chain_stream` during the node execution and `on_chain_end` when the node finishes. Node events will have the node name in the event's `name` field
-* the graph will emit `on_chain_start` in the beginning of the graph execution, `on_chain_stream` after each node execution and `on_chain_end` when the graph finishes. Graph events will have the `LangGraph` in the event's `name` field
-* Any writes to state channels (i.e. anytime you update the value of one of your state keys) will emit `on_chain_start` and `on_chain_end` events
-
-Additionally, any events that are created inside your nodes (LLM events, tool events, manually emitted events, etc.) will also be visible in the output of `.astream_events`.
-
-To make this more concrete and to see what this looks like, let's see what events are returned when we run a simple graph:
-
-```python
-from langchain_openai import ChatOpenAI
-from langgraph.graph import StateGraph, MessagesState, START, END
-
-model = ChatOpenAI(model="gpt-3.5-turbo")
-
-
-def call_model(state: MessagesState):
-    response = model.invoke(state['messages'])
-    return {"messages": response}
-
-workflow = StateGraph(MessagesState)
-workflow.add_node(call_model)
-workflow.add_edge(START, "call_model")
-workflow.add_edge("call_model", END)
-app = workflow.compile()
-
-inputs = [{"role": "user", "content": "hi!"}]
-async for event in app.astream_events({"messages": inputs}, version="v2"):
-    kind = event["event"]
-    print(f"{kind}: {event['name']}")
-```
-```shell
-on_chain_start: LangGraph
-on_chain_start: __start__
-on_chain_end: __start__
-on_chain_start: call_model
-on_chat_model_start: ChatOpenAI
-on_chat_model_stream: ChatOpenAI
-on_chat_model_stream: ChatOpenAI
-on_chat_model_stream: ChatOpenAI
-on_chat_model_stream: ChatOpenAI
-on_chat_model_stream: ChatOpenAI
-on_chat_model_stream: ChatOpenAI
-on_chat_model_stream: ChatOpenAI
-on_chat_model_stream: ChatOpenAI
-on_chat_model_stream: ChatOpenAI
-on_chat_model_stream: ChatOpenAI
-on_chat_model_stream: ChatOpenAI
-on_chat_model_end: ChatOpenAI
-on_chain_start: ChannelWrite<call_model,messages>
-on_chain_end: ChannelWrite<call_model,messages>
-on_chain_stream: call_model
-on_chain_end: call_model
-on_chain_stream: LangGraph
-on_chain_end: LangGraph
-```
-
-We start with the overall graph start (`on_chain_start: LangGraph`). We then write to the `__start__` node (this is special node to handle input).
-We then start the `call_model` node (`on_chain_start: call_model`). We then start the chat model invocation (`on_chat_model_start: ChatOpenAI`),
-stream back token by token (`on_chat_model_stream: ChatOpenAI`) and then finish the chat model (`on_chat_model_end: ChatOpenAI`). From there, 
-we write the results back to the channel (`ChannelWrite<call_model,messages>`) and then finish the `call_model` node and then the graph as a whole.
-
-This should hopefully give you a good sense of what events are emitted in a simple graph. But what data do these events contain?
-Each type of event contains data in a different format. Let's look at what `on_chat_model_stream` events look like. This is an important type of event
-since it is needed for streaming tokens from an LLM response.
-
-These events look like:
-
-```shell
-{'event': 'on_chat_model_stream',
- 'name': 'ChatOpenAI',
- 'run_id': '3fdbf494-acce-402e-9b50-4eab46403859',
- 'tags': ['seq:step:1'],
- 'metadata': {'langgraph_step': 1,
-  'langgraph_node': 'call_model',
-  'langgraph_triggers': ['start:call_model'],
-  'langgraph_task_idx': 0,
-  'checkpoint_id': '1ef657a0-0f9d-61b8-bffe-0c39e4f9ad6c',
-  'checkpoint_ns': 'call_model',
-  'ls_provider': 'openai',
-  'ls_model_name': 'gpt-3.5-turbo',
-  'ls_model_type': 'chat',
-  'ls_temperature': 0.7},
- 'data': {'chunk': AIMessageChunk(content='Hello', id='run-3fdbf494-acce-402e-9b50-4eab46403859')},
- 'parent_ids': []}
-```
-We can see that we have the event type and name (which we knew from before).
-
-We also have a bunch of stuff in metadata. Noticeably, `'langgraph_node': 'call_model',` is some really helpful information
-which tells us which node this model was invoked inside of.
-
-Finally, `data` is a really important field. This contains the actual data for this event! Which in this case
-is an AIMessageChunk. This contains the `content` for the message, as well as an `id`.
-This is the ID of the overall AIMessage (not just this chunk) and is super helpful - it helps
-us track which chunks are part of the same message (so we can show them together in the UI).
-
-This information contains all that is needed for creating a UI for streaming LLM tokens. You can see a 
-guide for that [here](../how-tos/streaming-tokens.ipynb).
-
-
-!!! warning "ASYNC IN PYTHON<=3.10"
-    You may fail to see events being emitted from inside a node when using `.astream_events` in Python <= 3.10. If you're using a Langchain RunnableLambda, a RunnableGenerator, or Tool asynchronously inside your node, you will have to propagate callbacks to these objects manually. This is because LangChain cannot automatically propagate callbacks to child objects in this case. Please see examples [here](../how-tos/streaming-content.ipynb) and [here](../how-tos/streaming-events-from-within-tools.ipynb).
-
-#### Only stream tokens from specific nodes/LLMs
-
-
-There are certain cases where you have multiple nodes in your graph that make LLM calls, and you do not wish to stream the tokens from every single LLM call. For example, you may use one LLM as a planner for the next steps to take, and another LLM somewhere else in the graph that actually responds to the user. In that case, you most likely WON'T want to stream tokens from the planner LLM but WILL want to stream them from the respond to user LLM. Below we show two different ways of doing this, one by streaming from specific nodes only and the second by streaming from specific LLMs only.
-
-First, let's define our graph:
-
-```python
-from langchain_openai import ChatOpenAI
-from langgraph.graph import StateGraph, MessagesState, START, END
-
-model_1 = ChatOpenAI(model="gpt-3.5-turbo", name="model_1")
-model_2 = ChatOpenAI(model="gpt-3.5-turbo", name="model_2")
-
-def call_first_model(state: MessagesState):
-    response = model_1.invoke(state['messages'])
-    return {"messages": response}
-
-def call_second_model(state: MessagesState):
-    response = model_2.invoke(state['messages'])
-    return {"messages": response}
-
-workflow = StateGraph(MessagesState)
-workflow.add_node(call_first_model)
-workflow.add_node(call_second_model)
-workflow.add_edge(START, "call_first_model")
-workflow.add_edge("call_first_model", "call_second_model")
-workflow.add_edge("call_second_model", END)
-app = workflow.compile()
-```
-
-**Streaming from specific node**
-
-In the case that we only want the output from a single node, we can use the event metadata to filter node names:
-
-```python
-inputs = [{"role": "user", "content": "hi!"}]
-
-async for event in app.astream_events({"messages": inputs}, version="v2"):
-    # Get chat model tokens from a particular node 
-    if event["event"] == "on_chat_model_stream" and event['metadata'].get('langgraph_node','') == "call_second_model":
-     print(event["data"]["chunk"].content, end="|", flush=True)
-```
-
-```shell
-|Hello|!| How| can| I| help| you| today|?||
-```
-
-As we can see only the response from the second LLM was streamed (you can tell because we only received a single response, if we had streamed both we would have received two "Hello! How can I help you today?" messages).
-
-**Streaming from specific LLM**
-
-Sometimes you might want to stream from specific LLMs instead of specific nodes. This could be the case if you have multiple LLM calls inside a single node, and only want to stream the output of a specific one or if you use the same LLM in different nodes and want to stream it's output anytime it is called. We can do this by using the `name` parameter for LLMs and events:
-
-```python
-inputs = [{"role": "user", "content": "hi!"}]
-async for event in app.astream_events({"messages": inputs}, version="v2"):
-    # Get chat model tokens from a particular LLM inside a particular node
-    if event["event"] == "on_chat_model_stream" and event['name'] == "model_2":
-        print(event["data"]["chunk"].content, end="|", flush=True)
-```
-
-```shell
-|Hello|!| How| can| I| assist| you| today|?||
-```
-
-As expected, we only see a single LLM response since the response from `model_1` was not streamed. 

docs/docs/how-tos/.meta.yml

@@ -1,5 +0,0 @@
-tags:
-  - how-tos
-  - how-to
-  - howto
-  - how to