langgraph 0.2.23

sdk: Add support for scheduled runs

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -1,5 +1,5 @@
 name: "\U0001F41B Bug Report"
-description: Report a bug in LangChain. To report a security issue, please instead use the security option below. For questions, please use the GitHub Discussions.
+description: Report a bug in LangGraph. To report a security issue, please instead use the security option below. For questions, please use the GitHub Discussions.
 labels: ["02 Bug Report"]
 body:
   - type: markdown
@@ -15,11 +15,11 @@ body:
         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/).
         [LangChain documentation with the integrated search](https://python.langchain.com/docs/get_started/introduction),
-        [API Reference](https://api.python.langchain.com/en/stable/),
-        [GitHub search](https://github.com/langchain-ai/langchain),
-        [LangChain Github Discussions](https://github.com/langchain-ai/langchain/discussions),
-        [LangChain Github Issues](https://github.com/langchain-ai/langchain/issues?q=is%3Aissue),
+        [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
@@ -54,13 +54,13 @@ body:
         * 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 langchain_core.runnables import RunnableLambda
+        from langgraph.graph import StateGraph
 
         def bad_code(inputs) -> int:
           raise NotImplementedError('For demo purpose')
           
-          chain = RunnableLambda(bad_code)
-          chain.invoke('Hello!')
+        chain = StateGraph(list)
+        chain.invoke('Hello!')
       render: python
   - type: textarea
     id: error
@@ -82,7 +82,7 @@ body:
 
         Write a short description telling what you are doing, what you expect to happen, and what is currently happening.
       placeholder: |
-        * I'm trying to use the `langchain` library to do X.
+        * I'm trying to use the `langgraph` library to do X.
         * I expect to see Y.
         * Instead, it does Z.
     validations:
@@ -102,7 +102,7 @@ body:
         
         python -m langchain_core.sys_info
       placeholder: |
-        "pip freeze | grep langchain"
+        "pip freeze | grep langgraph"
         platform
         python version
         

.github/ISSUE_TEMPLATE/config.yml

@@ -3,13 +3,13 @@ version: 2.1
 contact_links:
   - name: 🤔 Question or Problem
     about: Ask a question or ask about a problem in GitHub Discussions.
-    url: https://www.github.com/langchain-ai/langchain/discussions/categories/q-a
-  - name: Discord
-    url: https://discord.gg/6adMQxSpJS
-    about: General community discussions
+    url: https://github.com/langchain-ai/langgraph/discussions/categories/q-a
   - name: Feature Request
-    url: https://www.github.com/langchain-ai/langchain/discussions/categories/ideas
+    url: https://github.com/langchain-ai/langgraph/discussions/categories/ideas
     about: Suggest a feature or an idea
   - name: Show and tell
     about: Show what you built with LangChain
-    url: https://www.github.com/langchain-ai/langchain/discussions/categories/show-and-tell
+    url: https://github.com/langchain-ai/langgraph/discussions/categories/show-and-tell
+  - name: Slack
+    url:  https://www.langchain.com/join-community
+    about: General community discussions

.github/ISSUE_TEMPLATE/documentation.yml

@@ -1,5 +1,5 @@
 name: Documentation
-description: Report an issue related to the LangChain documentation.
+description: Report an issue related to the LangGraph documentation.
 title: "DOC: <Please write a comprehensive title after the 'DOC: ' prefix>"
 labels: [03 - Documentation]
 

.github/workflows/_integration_test.yml

@@ -12,6 +12,7 @@ jobs:
     strategy:
       matrix:
         python-version:
+          - "3.10"
           - "3.11"
     name: "CLI integration test"
     defaults:
@@ -21,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 }}

.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 }}
@@ -44,7 +43,7 @@ jobs:
           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,38 +21,31 @@ jobs:
           - "3.10"
           - "3.11"
           - "3.12"
+
     name: "test #${{ matrix.python-version }}"
     steps:
       - uses: actions/checkout@v4
-      - name: Get changed files
-        id: changed-files
-        uses: Ana06/get-changed-files@v2.2.0
-        with:
-          filter: "${{ inputs.working-directory }}/**"
       - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
-        if: steps.changed-files.outputs.all
         uses: "./.github/actions/poetry_setup"
         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: Install dependencies
-        if: steps.changed-files.outputs.all
         shell: bash
         working-directory: ${{ inputs.working-directory }}
-        run: poetry install --with dev
+        run: |
+          poetry install --with dev
 
-      - name: Run core tests
-        if: steps.changed-files.outputs.all
+      - name: Run tests
         shell: bash
         working-directory: ${{ inputs.working-directory }}
         run: |
           make test
 
       - name: Ensure the tests did not create any additional files
-        if: steps.changed-files.outputs.all
         shell: bash
         working-directory: ${{ inputs.working-directory }}
         run: |

.github/workflows/_test_langgraph.yml

@@ -0,0 +1,59 @@
+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"
+        core-version:
+          - ">=0.2.39,<0.3.0"
+          - "latest"
+
+    defaults:
+      run:
+        working-directory: libs/langgraph
+    name: "test #${{ matrix.python-version }} (langchain-core: ${{ matrix.core-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: Install dependencies
+        shell: bash
+        run: |
+          poetry install --with dev
+          if [ "${{ matrix.core-version }}" != "latest" ]; then
+            poetry run pip install "langchain-core${{ matrix.core-version }}"
+          fi
+
+      - name: Run tests
+        shell: bash
+        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/_test_scheduler_kafka.yml

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

.github/workflows/codespell.yml

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

.github/workflows/deploy_docs.yml

@@ -39,12 +39,45 @@ jobs:
       - name: Install dependencies
         run: |
           poetry install --with docs
+          poetry run pip install -U pytest pytest-check-links langsmith langchain GitPython
 
       - name: Build site
         run: make build-docs
         env:
           MKDOCS_GIT_COMMITTERS_APIKEY: ${{ secrets.MKDOCS_GIT_COMMITTERS_APIKEY }}
 
+      - name: Check links in notebooks
+        env:
+          LANGCHAIN_API_KEY: test
+        run: |
+          if [ "${{ github.event_name }}" == "schedule" ] || [ "${{ github.event_name }}" == "workflow_dispatch" ] || ([ "${{ github.event_name }}" == "push" ] && [ "${{ github.ref }}" == "refs/heads/main" ]); then
+            echo "Running link check on all HTML files matching notebooks in docs directory..."
+            poetry run pytest -v \
+              --check-links-ignore "https://(api|web|docs)\.smith\.langchain\.com/.*" \
+              --check-links-ignore "https://x.com/.*" \
+              --check-links-ignore "https://github\.com/.*" \
+              --check-links-ignore "/.*\.(ipynb|html)$" \
+              --check-links $(find docs/site -name "index.html" | grep -v 'storm/index.html')
+          else
+            echo "Fetching changes from origin/main..."
+            git fetch origin main
+            echo "Checking for changed notebook files..."
+            CHANGED_FILES=$(git diff --name-only --diff-filter=d origin/main | grep 'docs/docs/.*\.ipynb$' | grep -v 'storm.ipynb' | sed -E 's|^docs/docs/|docs/site/|; s/\.ipynb$/\/index.html/' || true)
+            echo "Changed files: ${CHANGED_FILES}"
+            if [ -n "${CHANGED_FILES}" ]; then
+              echo "Running link check on HTML files matching changed notebook files..."
+              poetry run pytest -v \
+                --check-links-ignore "https://(api|web|docs)\.smith\.langchain\.com/.*" \
+                --check-links-ignore "https://x.com/.*" \
+                --check-links-ignore "https://github\.com/.*" \
+                --check-links-ignore "/.*\.(ipynb|html)$" \
+                --check-links ${CHANGED_FILES} \
+                || ([ $? = 5 ] && exit 0 || exit $?)
+            else
+              echo "No notebook files changed."
+            fi
+          fi
+
       - name: Configure GitHub Pages
         if: github.ref == 'refs/heads/main'
         uses: actions/configure-pages@v4
@@ -59,10 +92,3 @@ jobs:
         if: github.ref == 'refs/heads/main'
         id: deployment
         uses: actions/deploy-pages@v4
-
-      - name: Deploy Pull Request Preview
-        if: github.event_name == 'pull_request'
-        uses: actions/upload-artifact@v2
-        with:
-          name: pr-preview-${{ github.event.number }}
-          path: ./docs/site/

.github/workflows/link_check.yml

@@ -1,4 +1,4 @@
-name: Check Links
+name: Check Docs & Links
 
 on:
   pull_request:
@@ -26,52 +26,24 @@ jobs:
       - name: Check links in Markdown files
         uses: gaurav-nelson/github-action-markdown-link-check@v1
         with:
-          folder-path: "examples/"
+          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:
+  check-readmes-synced:
+    # This checks that the repo README.md is identical to the libs/langgraph/README.md
     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
+          fetch-depth: 1
 
-      - name: Install dependencies
+      - name: Check README.md is in sync
         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 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}
-              PYTEST_EXIT_CODE=$?
-              echo "pytest exit code: ${PYTEST_EXIT_CODE}"
-              if [ ${PYTEST_EXIT_CODE} -ne 0 ]; then
-                echo "pytest failed with exit code ${PYTEST_EXIT_CODE}"
-                exit ${PYTEST_EXIT_CODE}
-              fi
-            else
-              echo "No notebook files changed."
+            if ! diff -q README.md libs/langgraph/README.md >/dev/null; then
+            echo "README.md is out of sync with libs/langgraph/README.md"
+            diff -C 3 README.md libs/langgraph/README.md
+            exit 1
             fi
-          fi

.github/workflows/release.yml

@@ -6,7 +6,7 @@ on:
       working-directory:
         required: true
         type: string
-        default: 'libs/langgraph'
+        default: "libs/langgraph"
 
 env:
   PYTHON_VERSION: "3.11"
@@ -19,6 +19,7 @@ jobs:
 
     outputs:
       pkg-name: ${{ steps.check-version.outputs.pkg-name }}
+      short-pkg-name: ${{ steps.check-version.outputs.short-pkg-name }}
       version: ${{ steps.check-version.outputs.version }}
       tag: ${{ steps.check-version.outputs.tag }}
 
@@ -68,6 +69,7 @@ jobs:
             TAG="${SHORT_PKG_NAME}==${VERSION}"
           fi
           echo pkg-name="$PKG_NAME" >> $GITHUB_OUTPUT
+          echo short-pkg-name="$SHORT_PKG_NAME" >> $GITHUB_OUTPUT
           echo version="$VERSION" >> $GITHUB_OUTPUT
           echo tag="$TAG" >> $GITHUB_OUTPUT
 
@@ -92,12 +94,18 @@ jobs:
         working-directory: langgraph/${{ inputs.working-directory }}
         env:
           PKG_NAME: ${{ needs.build.outputs.pkg-name }}
+          SHORT_PKG_NAME: ${{ needs.build.outputs.short-pkg-name }}
           VERSION: ${{ needs.build.outputs.version }}
           TAG: ${{ needs.build.outputs.tag }}
         run: |
-          REGEX="^$PKG_NAME==\\d+\\.\\d+\\.\\d+\$"
+          if [ -z $SHORT_PKG_NAME ]; then
+            REGEX="^\\d+\\.\\d+\\.\\d+((a|b|rc)\\d+)?\$"
+          else
+            REGEX="^$SHORT_PKG_NAME==\\d+\\.\\d+\\.\\d+((a|b|rc)\\d+)?\$"
+          fi
           echo $REGEX
-          PREV_TAG=$(git tag --sort=-creatordate | grep -P $REGEX || true | head -1)
+          PREV_TAG=$(git tag --sort=-creatordate | grep -P $REGEX | head -1 || echo "")
+          echo $PREV_TAG
           if [ "$TAG" == "$PREV_TAG" ]; then
             echo "No new version to release"
             exit 1
@@ -114,13 +122,12 @@ jobs:
         run: |
           {
             echo 'release-body<<EOF'
-            echo "# Release $TAG"
             if [ -z "$PREV_TAG" ]; then
               echo "Initial release"
             else
               echo "Changes since $PREV_TAG"
               echo
-              git log --format="%s" "$PREV_TAG"..HEAD -- $WORKING_DIR
+              git log --format="%s" "$PREV_TAG"..HEAD -- $WORKING_DIR | awk '{print "* " $0}'
             fi
             echo EOF
           } >> "$GITHUB_OUTPUT"
@@ -129,8 +136,8 @@ jobs:
     needs:
       - build
       - release-notes
-    uses:
-      ./.github/workflows/_test_release.yml
+    permissions: write-all
+    uses: ./.github/workflows/_test_release.yml
     with:
       working-directory: ${{ inputs.working-directory }}
     secrets: inherit
@@ -190,9 +197,15 @@ jobs:
               "$PKG_NAME==$VERSION" \
           )
 
-          # Replace all dashes in the package name with underscores,
-          # since that's how Python imports packages with dashes in the name.
-          IMPORT_NAME="$(echo "$PKG_NAME" | sed s/-/_/g)"
+          if [[ "$PKG_NAME" == *checkpoint* ]]; 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)"
+          else
+            # Replace all dashes in the package name with underscores,
+            # since that's how Python imports packages with dashes in the name.
+            IMPORT_NAME="$(echo "$PKG_NAME" | sed s/-/_/g)"
+          fi
 
           poetry run python -c "import $IMPORT_NAME; print(dir($IMPORT_NAME))"
 

.github/workflows/run_notebooks.yml

@@ -0,0 +1,61 @@
+name: Run notebooks
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: '0 13 * * *'
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        lib-version:
+          - "development"
+          - "latest"
+
+    name: "test (langgraph: ${{ matrix.lib-version }})"
+    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
+          if [ "${{ matrix.lib-version }}" = "latest" ]; then
+            poetry add chromadb pandas langchain_nomic
+            poetry remove langchain-openai langchain-anthropic langchain-community
+            poetry add langchain-openai@latest langchain-anthropic@latest langchain-community@latest
+          fi
+
+      - name: Start services
+        run: make start-services
+
+      - name: Prepare notebooks
+        run: |
+          if [ "${{ matrix.lib-version }}" = "development" ]; then
+            poetry run python docs/_scripts/prepare_notebooks_for_ci.py --comment-install-cells
+          else
+            poetry run python docs/_scripts/prepare_notebooks_for_ci.py
+          fi
+
+      - name: Run notebooks
+        env:
+          # these won't actually be used because of the VCR cassettes
+          # but need to set them to avoid triggering getpass()
+          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          TAVILY_API_KEY: ${{ secrets.TAVILY_API_KEY }}
+          LANGSMITH_API_KEY: ${{ secrets.LANGSMITH_API_KEY }}
+          NOMIC_API_KEY: ${{ secrets.NOMIC_API_KEY }}
+        run: |
+          ./docs/_scripts/execute_notebooks.sh
+
+      - name: Stop services
+        run: make stop-services

.github/workflows/size.yml

@@ -0,0 +1,29 @@
+name: Check File Size
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+  workflow_dispatch:
+
+jobs:
+  file-size-check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Get changed files
+        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 | 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
+            echo "$large_added_files" >> $GITHUB_STEP_SUMMARY
+            exit 1
+          fi

.gitignore

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

CONTRIBUTING.md

@@ -0,0 +1,293 @@
+# Contributing to LangGraph
+
+Thank you for being interested in contributing to LangGraph!
+
+## General guidelines
+
+Here are some things to keep in mind for all types of contributions:
+
+- Follow the ["fork and pull request"](https://docs.github.com/en/get-started/exploring-projects-on-github/contributing-to-a-project) workflow.
+- Fill out the checked-in pull request template when opening pull requests. Note related issues and tag relevant maintainers.
+- Ensure your PR passes formatting, linting, and testing checks before requesting a review.
+  - If you would like comments or feedback, please open an issue or discussion and tag a maintainer.
+- Backwards compatibility is key. Your changes must not be breaking, except in case of critical bug and security fixes.
+- Look for duplicate PRs or issues that have already been opened before opening a new one.
+- Keep scope as isolated as possible. As a general rule, your changes should not affect more than one package at a time.
+
+### Bugfixes
+
+For bug fixes, please open up an issue before proposing a fix to ensure the proposal properly addresses the underlying problem. In general, bug fixes should all have an accompanying unit test that fails before the fix.
+
+### New features
+
+For new features, please start a new [discussion](https://github.com/langchain-ai/langgraph/discussions), where the maintainers will help with scoping out the necessary changes.
+
+## Contribute Documentation
+
+Documentation is a vital part of LangGraph. We welcome both new documentation for new features and
+community improvements to our current documentation. Please read the resources below before getting started:
+
+- [Documentation style guide](#documentation-style-guide)
+- [Documentation setup](#setup)
+
+## Documentation Style Guide
+
+As LangGraph continues to grow, the surface area of documentation required to cover it continues to grow too.
+This page provides guidelines for anyone writing documentation for LangGraph, as well as some of our philosophies around organization and structure.
+
+## Philosophy
+
+LangGraph's documentation follows the [Diataxis framework](https://diataxis.fr).
+Under this framework, all documentation falls under one of four categories: [Tutorials](#tutorials),
+[How-to guides](#how-to-guides),
+[References](#references), and [Explanations (aka conceptual guides)](#conceptual-guide).
+
+### Tutorials
+
+Tutorials are lessons that take the reader through a practical activity. Their purpose is to help the user
+gain understanding of concepts and how they interact by showing one way to achieve some goal in a hands-on way.
+
+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.
+
+To quote the Diataxis website:
+
+> A tutorial serves the user’s *acquisition* of skills and knowledge - their study. Its purpose is not to help the user get something done, but to help them learn.
+
+In LangGraph, these are often higher level guides that show off end-to-end use cases.
+
+Some examples include:
+
+- [Build a Customer Support Bot](https://langchain-ai.github.io/langgraph/tutorials/customer-support/customer-support/)
+- [Build a SQL Agent](https://langchain-ai.github.io/langgraph/tutorials/sql-agent/)
+
+Here are some high-level tips on writing a good tutorial:
+
+- Focus on guiding the user to get something done, but keep in mind the end-goal is more to impart principles than to create a perfect production system.
+- Be specific, not abstract and follow one path.
+  - No need to go deeply into alternative approaches, but it’s ok to reference them, ideally with a link to an appropriate how-to guide.
+- Get "a point on the board" as soon as possible - something the user can run that outputs something.
+  - You can iterate and expand afterwards.
+  - Try to frequently checkpoint at given steps where the user can run code and see progress.
+- Focus on results, not technical explanation.
+  - Crosslink heavily to appropriate conceptual/reference pages
+- The first time you mention a LangGraph concept, use its full name (e.g. "human-in-the-loop"), and link to its conceptual/other documentation page.
+  - It's also helpful to add a prerequisite callout that links to any pages with necessary background information.
+- End with a recap/next steps section summarizing what the tutorial covered and future reading, such as related how-to guides.
+- Use phrases like "Next we can run X & Y. We will expect Z.". Then afterwards, use language like "Notice Z" that recalls our expectations and directs the reader's attention to the topic we are trying to teach.
+- Do not shy away from repetition.
+
+### How-to guides
+
+A how-to guide, as the name implies, demonstrates how to do something discrete and specific.
+It should assume that the user is already familiar with underlying concepts, and is trying to solve an immediate problem, but
+should still give some background or list the scenarios where the information contained within can be relevant.
+They can and should discuss alternatives if one approach may be better than another in certain cases.
+
+To quote the Diataxis website:
+
+> A how-to guide serves the work of the already-competent user, whom you can assume to know what they want to do, and to be able to follow your instructions correctly.
+
+Some examples include:
+
+- [How to add persistence to your graph](https://langchain-ai.github.io/langgraph/how-tos/persistence/)
+- [How to view and update past graph state](https://langchain-ai.github.io/langgraph/how-tos/human_in_the_loop/time-travel/)
+
+Here are some high-level tips on writing a good how-to guide:
+
+- Clearly explain what you are guiding the user through at the start
+- Assume higher intent than a tutorial and show what the user needs to do to get that task done
+- Assume familiarity of concepts, but explain why suggested actions are helpful
+  - Crosslink heavily to conceptual/reference pages
+- Discuss alternatives and responses to real-world tradeoffs that may arise when solving a problem
+- Use lots of example code, ideally within complete code blocks that the reader can copy and run.
+- End with a recap/next steps section summarizing what the tutorial covered and future reading, such as other related how-to guides
+
+### Conceptual guides
+
+LangGraph's conceptual guides fall under the **Explanation** quadrant of Diataxis. They should cover LangChain terms and concepts
+in a more abstract way than how-to guides or tutorials, and should be geared towards curious users interested in
+gaining a deeper understanding of the framework. Try to avoid excessively large code examples. The goal here is to
+impart perspective to the user rather than to finish a practical project. These guides should cover **why** things work they way they do.
+
+
+To quote the Diataxis website:
+
+> The perspective of explanation is higher and wider than that of the other types. It does not take the user’s eye-level view, as in a how-to guide, or a close-up view of the machinery, like reference material. Its scope in each case is a topic - “an area of knowledge”, that somehow has to be bounded in a reasonable, meaningful way.
+
+Some examples include:
+
+- [What does it mean to be agentic?](https://langchain-ai.github.io/langgraph/concepts/high_level/)
+- [Tool calling](https://langchain-ai.github.io/langgraph/concepts/agentic_concepts/#tool-calling)
+
+Here are some high-level tips on writing a good conceptual guide:
+
+- Explain design decisions. Why does concept X exist and why was it designed this way?
+- Use analogies and reference other concepts and alternatives
+- Avoid blending in too much reference content
+- You can and should reference content covered in other guides, but make sure to link to them
+
+### References
+
+References contain detailed, low-level information that describes exactly what functionality exists and how to use it.
+In LangGraph, this is mainly our API reference pages, which are populated from docstrings within code.
+References pages are generally not read end-to-end, but are consulted as necessary when a user needs to know
+how to use something specific.
+
+To quote the Diataxis website:
+
+> The only purpose of a reference guide is to describe, as succinctly as possible, and in an orderly way. Whereas the content of tutorials and how-to guides are led by needs of the user, reference material is led by the product it describes.
+
+Many of the reference pages in LangChain are automatically generated from code,
+but here are some high-level tips on writing a good docstring:
+
+- Be concise
+- Discuss special cases and deviations from a user's expectations
+- Go into detail on required inputs and outputs
+- Light details on when one might use the feature are fine, but in-depth details belong in other sections.
+
+Each category serves a distinct purpose and requires a specific approach to writing and structuring the content.
+
+## General guidelines
+
+Here are some other guidelines you should think about when writing and organizing documentation.
+
+We generally do not merge new tutorials from outside contributors without an actue need.
+We welcome updates as well as new integration docs, how-tos, and references.
+
+### Avoid duplication
+
+Multiple pages that cover the same material in depth are difficult to maintain and cause confusion. There should
+be only one (very rarely two), canonical pages for a given concept or feature. Instead, you should link to other guides.
+
+### Link to other sections
+
+Because sections of the docs do not exist in a vacuum, it is important to link to other sections as often as possible
+to allow a developer to learn more about an unfamiliar topic inline.
+
+This includes linking to the API references as well as conceptual sections!
+
+### Be concise
+
+In general, take a less-is-more approach. If a section with a good explanation of a concept already exists, you should link to it rather than
+re-explain it, unless the concept you are documenting presents some new wrinkle.
+
+Be concise, including in code samples.
+
+### General style
+
+- Use active voice and present tense whenever possible
+- Use examples and code snippets to illustrate concepts and usage
+- Use appropriate header levels (`#`, `##`, `###`, etc.) to organize the content hierarchically
+- Use fewer cells with more code to make copy/paste easier
+- Use bullet points and numbered lists to break down information into easily digestible chunks
+- Use tables (especially for **Reference** sections) and diagrams often to present information visually
+- Include the table of contents for longer documentation pages to help readers navigate the content, but hide it for shorter pages
+
+## Setup
+
+LangChain documentation consists of two components:
+
+1. Main Documentation: Hosted at [https://langchain-ai.github.io](https://langchain-ai.github.io/langgraph/),
+this comprehensive resource serves as the primary user-facing documentation.
+It covers a wide array of topics, including tutorials, use cases, integrations,
+and more, offering extensive guidance on building with LangGraph.
+The content for this documentation lives in the `/docs` directory of the monorepo.
+2. In-code Documentation: This is documentation of the codebase itself, which is also
+used to generate the externally facing [API Reference](https://langchain-ai.github.io/langgraph/reference/graphs/).
+The content for the API reference is autogenerated by scanning the docstrings in the codebase. For this reason we ask that developers document their code well.
+
+We appreciate all contributions to the documentation, whether it be fixing a typo,
+adding a new tutorial or example and whether it be in the main documentation or the API Reference.
+
+### 📜 Main Documentation
+
+The content for the main documentation is located in the `/docs` directory of the monorepo.
+
+The documentation is written using a combination of ipython notebooks (`.ipynb` files)
+and markdown (`.md` files). The notebooks are converted to markdown
+and then built using [MkDocs](https://www.mkdocs.org/).
+
+Feel free to make contributions to the main documentation! 🥰
+
+After modifying the documentation:
+
+1. Run the linting and formatting commands (see below) to ensure that the documentation is well-formatted and free of errors.
+2. Optionally build the documentation locally to verify that the changes look good.
+3. Make a pull request with the changes.
+
+### ⚒️ Linting and Building Documentation Locally
+
+After writing up the documentation, you may want to lint and build the documentation
+locally to ensure that it looks good and is free of errors.
+
+If you're unable to build it locally that's okay as well, as you will be able to
+see a preview of the documentation on the pull request page.
+
+From the **monorepo root**, run the following command to install the dependencies:
+
+```bash
+poetry install --with docs --no-root
+```
+
+#### Building
+
+The code that builds the documentation is located in the `/docs` directory of the monorepo.
+
+Before building the documentation, it is always a good idea to clean the build directory:
+
+```bash
+make clean-docs
+```
+
+You can build and preview the documentation as outlined below:
+
+```bash
+make serve-docs
+```
+
+#### Linting
+
+The documentation is linted from the **monorepo root**. To lint it, run the following from there:
+
+```bash
+make spellcheck
+```
+
+### ️In-code Documentation
+
+The in-code documentation is autogenerated from docstrings.
+
+For the API reference to be useful, the codebase must be well-documented. This means that all functions, classes, and methods should have a docstring that explains what they do, what the arguments are, and what the return value is. This is a good practice in general, but it is especially important for LangChain because the API reference is the primary resource for developers to understand how to use the codebase.
+
+We generally follow the [Google Python Style Guide](https://google.github.io/styleguide/pyguide.html#38-comments-and-docstrings) for docstrings.
+
+Here is an example of a well-documented function:
+
+```python
+
+def my_function(arg1: int, arg2: str) -> float:
+    """This is a short description of the function. (It should be a single sentence.)
+
+    This is a longer description of the function. It should explain what
+    the function does, what the arguments are, and what the return value is.
+    It should wrap at 88 characters.
+
+    Examples:
+        This is a section for examples of how to use the function.
+
+        .. code-block:: python
+
+            my_function(1, "hello")
+
+    Args:
+        arg1: This is a description of arg1. We do not need to specify the type since
+            it is already specified in the function signature.
+        arg2: This is a description of arg2.
+
+    Returns:
+        This is a description of the return value.
+    """
+    return 3.14
+```

Makefile

@@ -1,15 +1,18 @@
-.PHONY: build-docs serve-docs serve-clean-docs clean-docs codespell
+.PHONY: build-docs serve-docs serve-clean-docs clean-docs codespell build-typedoc
 
-build-docs:
-	poetry run python docs/_scripts/copy_notebooks.py
+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 -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:
-	poetry run python docs/_scripts/copy_notebooks.py
+serve-docs: build-typedoc
 	poetry run python -m mkdocs serve -f docs/mkdocs.yml -w ./libs/langgraph --dirty
 
 clean-docs:
@@ -17,4 +20,10 @@ clean-docs:
 	rm -rf docs/site
 
 codespell:
-	./docs/codespell_notebooks.sh .
+	./docs/codespell_notebooks.sh .
+
+start-services:
+	docker compose -f docs/test-compose.yml up -V --force-recreate --wait --remove-orphans
+
+stop-services:
+	docker compose -f docs/test-compose.yml down

README.md

@@ -3,7 +3,6 @@
 ![Version](https://img.shields.io/pypi/v/langgraph)
 [![Downloads](https://static.pepy.tech/badge/langgraph/month)](https://pepy.tech/project/langgraph)
 [![Open Issues](https://img.shields.io/github/issues-raw/langchain-ai/langgraph)](https://github.com/langchain-ai/langgraph/issues)
-[![](https://dcbadge.vercel.app/api/server/6adMQxSpJS?compact=true&style=flat)](https://discord.com/channels/1038097195422978059/1170024642245832774)
 [![Docs](https://img.shields.io/badge/docs-latest-blue)](https://langchain-ai.github.io/langgraph/)
 
 ⚡ Building language agents as graphs ⚡
@@ -17,6 +16,8 @@
 
 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.
 
+To learn more about LangGraph, check out our first LangChain Academy course, *Introduction to LangGraph*, available for free [here](https://academy.langchain.com/courses/intro-to-langgraph).
+
 ### Key Features
 
 - **Cycles and Branching**: Implement loops and conditionals in your apps.
@@ -36,40 +37,49 @@ pip install -U langgraph
 
 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 search the web using [Tavily Search API](https://tavily.com/).
+Let's take a look at a simple example of an agent that can use a search tool.
 
 ```shell
-pip install langchain_openai langchain_community
+pip install langchain-anthropic
 ```
 
 ```shell
-export OPENAI_API_KEY=sk-...
-export TAVILY_API_KEY=tvly-...
+export ANTHROPIC_API_KEY=sk-...
 ```
 
 Optionally, we can set up [LangSmith](https://docs.smith.langchain.com/) for best-in-class observability.
 
 ```shell
-export LANGCHAIN_TRACING_V2="true"
-export LANGCHAIN_API_KEY=ls__...
+export LANGSMITH_TRACING=true
+export LANGSMITH_API_KEY=lsv2_sk_...
 ```
 
 ```python
 from typing import Annotated, Literal, TypedDict
 
 from langchain_core.messages import HumanMessage
-from langchain_community.tools.tavily_search import TavilySearchResults
-from langchain_openai import ChatOpenAI
-from langgraph.checkpoint import MemorySaver
-from langgraph.graph import END, StateGraph, MessagesState
+from langchain_anthropic import ChatAnthropic
+from langchain_core.tools import tool
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.graph import END, START, StateGraph, MessagesState
 from langgraph.prebuilt import ToolNode
 
 
 # Define the tools for the agent to use
-tools = [TavilySearchResults(max_results=1)]
+@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]
+
 tool_node = ToolNode(tools)
 
-model = ChatOpenAI(temperature=0).bind_tools(tools)
+model = ChatAnthropic(model="claude-3-5-sonnet-20240620", temperature=0).bind_tools(tools)
 
 # Define the function that determines whether to continue or not
 def should_continue(state: MessagesState) -> Literal["tools", END]:
@@ -99,7 +109,7 @@ workflow.add_node("tools", tool_node)
 
 # Set the entrypoint as `agent`
 # This means that this node is the first one called
-workflow.set_entry_point("agent")
+workflow.add_edge(START, "agent")
 
 # We now add a conditional edge
 workflow.add_conditional_edges(
@@ -132,7 +142,7 @@ final_state["messages"][-1].content
 ```
 
 ```
-'The current weather in San Francisco is as follows:\n- Temperature: 60.1°F (15.6°C)\n- Condition: Partly cloudy\n- Wind: 5.6 mph (9.0 kph) from SSW\n- Humidity: 83%\n- Visibility: 9.0 miles (16.0 km)\n- UV Index: 4.0\n\nFor more details, you can visit [Weather API](https://www.weatherapi.com/).'
+"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 `"thread_id"`, the conversation context is retained via the saved state (i.e. stored list of messages)
@@ -146,7 +156,7 @@ final_state["messages"][-1].content
 ```
 
 ```
-'The current weather in New York is as follows:\n- Temperature: 20.3°C (68.5°F)\n- Condition: Overcast\n- Wind: 2.2 mph from the north\n- Humidity: 65%\n- Cloud Cover: 100%\n- UV Index: 5.0\n\nFor more details, you can visit [Weather API](https://www.weatherapi.com/).'
+"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?"
 ```
 
 ### Step-by-step Breakdown
@@ -154,8 +164,8 @@ final_state["messages"][-1].content
 1. <details>
     <summary>Initialize the model and tools.</summary>
 
-    - we use `ChatOpenAI` 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 web 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).
+    - 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>
 
 2. <details>
@@ -214,6 +224,10 @@ final_state["messages"][-1].content
 
 * [Tutorials](https://langchain-ai.github.io/langgraph/tutorials/): Learn to build with LangGraph through guided examples.
 * [How-to Guides](https://langchain-ai.github.io/langgraph/how-tos/): Accomplish specific things within LangGraph, from streaming, to adding memory & persistence, to common design patterns (branching, subgraphs, etc.), these are the place to go if you want to copy and run a specific code snippet.
-* [Conceptual Guides](https://langchain-ai.github.io/langgraph/concepts/): In-depth explanations of the key concepts and principles behind LangGraph, such as nodes, edges, state and more.
+* [Conceptual Guides](https://langchain-ai.github.io/langgraph/concepts/high_level/): In-depth explanations of the key concepts and principles behind LangGraph, such as nodes, edges, state and more.
 * [API Reference](https://langchain-ai.github.io/langgraph/reference/graphs/): Review important classes and methods, simple examples of how to use the graph and checkpointing APIs, higher-level prebuilt components and more.
-* [Cloud (alpha)](https://langchain-ai.github.io/langgraph/cloud/): With one click, deploy LangGraph applications to LangGraph Cloud.
+* [Cloud (beta)](https://langchain-ai.github.io/langgraph/cloud/): With one click, deploy LangGraph applications to LangGraph Cloud.
+
+## Contributing
+
+For more information on how to contribute, see [here](https://github.com/langchain-ai/langgraph/blob/main/CONTRIBUTING.md).

docs/.gitignore

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

docs/README.md

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

docs/_scripts/copy_notebooks.py

@@ -1,211 +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": [
-        "async.ipynb",
-        "stream-values.ipynb",
-        "stream-updates.ipynb",
-        "stream-multiple.ipynb",
-        "streaming-tokens.ipynb",
-        "streaming-content.ipynb",
-        "streaming-events-from-within-tools.ipynb",
-        "persistence.ipynb",
-        "visualization.ipynb",
-        "state-model.ipynb",
-        "subgraph.ipynb",
-        "force-calling-a-tool-first.ipynb",
-        "pass-run-time-values-to-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/time-travel.ipynb",
-        "human_in_the_loop/edit-graph-state.ipynb",
-        "human_in_the_loop/wait-user-input.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"}
-_MAP = {
-    "persistence_postgres.ipynb": "tutorial",
-}
-_HIDE = set(
-    str(examples_dir / f)
-    for f in [
-        "persistence_postgres.ipynb",
-        "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",
-        "pass-run-time-values-to-tools.ipynb",
-        "respond-in-format.ipynb",
-        "quickstart.ipynb",
-        "human-in-the-loop.ipynb",
-        "learning.ipynb",
-        "managing-conversation-history.ipynb",
-        "docs/quickstart.ipynb",
-        "tutorials/rag-agent-testing.ipynb",
-        "state-context-key.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")):
-                if file in _MAP:
-                    dst_dir = os.path.join(dst_dir, _MAP[file])
-                src_path = os.path.join(root, file)
-                if src_path in _HIDE:
-                    print("Hiding:", src_path)
-                    continue
-                dst_path = os.path.join(
-                    dst_dir, os.path.relpath(src_path, examples_dir)
-                )
-                for k in _MANUAL_INVERSE:
-                    if src_path.endswith(k):
-                        overridden_dir = _MANUAL_INVERSE[k]
-                        dst_path = os.path.join(
-                            overridden_dir, os.path.relpath(src_path, examples_dir)
-                        )
-                        print(f"Overriding: {src_path} to {dst_path}")
-                        break
-                # Avoid double nesting.
-                dst_path = dst_path.replace("tutorials/tutorials", "tutorials").replace(
-                    "how-tos/how-tos", "how-tos"
-                )
-                os.makedirs(os.path.dirname(dst_path), exist_ok=True)
-                print(f"Copying: {src_path} to {dst_path}")
-                shutil.copy(src_path, dst_path)
-                # Convert all ./img/* to ../img/*
-                if file.endswith(".ipynb"):
-                    with open(dst_path, "r") as f:
-                        content = f.read()
-                    content = content.replace("(./img/", "(../img/")
-                    content = content.replace('src=\\"./img/', 'src=\\"../img/')
-                    with open(dst_path, "w") as f:
-                        f.write(content)
-                    update_notebook_links(dst_path)
-                dst_dir = dst_dir_
-
-
-if __name__ == "__main__":
-    clean_notebooks()
-    copy_notebooks()

docs/_scripts/execute_notebooks.sh

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

docs/_scripts/prepare_notebooks_for_ci.py

@@ -0,0 +1,205 @@
+"""Preprocess notebooks for CI. Currently adds VCR cassettes and optionally removes pip install cells."""
+
+import logging
+import os
+import json
+import click
+import nbformat
+
+logger = logging.getLogger(__name__)
+NOTEBOOK_DIRS = ("docs/docs/how-tos","docs/docs/tutorials")
+DOCS_PATH = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+CASSETTES_PATH = os.path.join(DOCS_PATH, "cassettes")
+
+NOTEBOOKS_NO_CASSETTES = (
+    "docs/docs/how-tos/visualization.ipynb",
+    "docs/docs/how-tos/many-tools.ipynb"
+)
+
+NOTEBOOKS_NO_EXECUTION = [
+    "docs/docs/tutorials/customer-support/customer-support.ipynb",
+    "docs/docs/tutorials/usaco/usaco.ipynb",
+]
+
+
+def comment_install_cells(notebook: nbformat.NotebookNode) -> nbformat.NotebookNode:
+    for cell in notebook.cells:
+        if cell.cell_type != "code":
+            continue
+
+        if "pip install" in cell.source:
+            # Comment out the lines in cells containing "pip install"
+            cell.source = "\n".join(
+                f"# {line}" if line.strip() else line
+                for line in cell.source.splitlines()
+            )
+
+    return notebook
+
+
+def is_magic_command(code: str) -> bool:
+    return code.strip().startswith("%") or code.strip().startswith("!")
+
+
+def is_comment(code: str) -> bool:
+    return code.strip().startswith("#")
+
+
+def add_vcr_to_notebook(
+    notebook: nbformat.NotebookNode, cassette_prefix: str
+) -> nbformat.NotebookNode:
+    """Inject `with vcr.cassette` into each code cell of the notebook."""
+
+    # Inject VCR context manager into each code cell
+    for idx, cell in enumerate(notebook.cells):
+        if cell.cell_type != "code":
+            continue
+
+        lines = cell.source.splitlines()
+        # skip if empty cell
+        if not lines:
+            continue
+
+        are_magic_lines = [is_magic_command(line) for line in lines]
+
+        # skip if all magic
+        if all(are_magic_lines):
+            continue
+
+        if any(are_magic_lines):
+            raise ValueError(
+                "Cannot process code cells with mixed magic and non-magic code."
+            )
+
+        # skip if just comments
+        if all(is_comment(line) or not line.strip() for line in lines):
+            continue
+
+        cell_id = cell.get("id", idx)
+        cassette_name = f"{cassette_prefix}_{cell_id}.msgpack.zlib"
+        cell.source = f"with custom_vcr.use_cassette('{cassette_name}', filter_headers=['x-api-key', 'authorization'], record_mode='once', serializer='advanced_compressed'):\n" + "\n".join(
+            f"    {line}" for line in lines
+        )
+
+    # Add import statement
+    vcr_import_lines = [
+        "import vcr",
+        "import msgpack",
+        "import nest_asyncio",
+        "import base64",
+        "import zlib",
+        "import re",
+        "",
+        "custom_vcr = vcr.VCR()",
+        "",
+        "def compress_data(data, compression_level=9):",
+        "    packed = msgpack.packb(data, use_bin_type=True)",
+        "    compressed = zlib.compress(packed, level=compression_level)",
+        "    return base64.b64encode(compressed).decode('utf-8')",
+        "",
+        "def decompress_data(compressed_string):",
+        "    try:",
+        "        decoded = base64.b64decode(compressed_string)",
+        "        decompressed = zlib.decompress(decoded)",
+        "        return msgpack.unpackb(decompressed, raw=False)",
+        "    except (ValueError, zlib.error, msgpack.exceptions.ExtraData, msgpack.exceptions.UnpackValueError):",
+        "        return {\"requests\": [], \"responses\": []}",
+        "",
+        "def filter_cassette_data(cassette_dict):",
+        "    for interaction in cassette_dict['interactions']:",
+        "        if len(interaction['response']['body']['string']) > 1000:",
+        "            interaction['response']['body']['string'] = interaction['response']['body']['string'][:1000] + '... (truncated)'",
+        "        for req_or_res in [interaction['request'], interaction['response']]:",
+        "            headers_to_remove = ['date', 'server', 'content-length']",
+        "            for header in headers_to_remove:",
+        "                req_or_res['headers'].pop(header, None)",
+        "    return cassette_dict",
+        "",
+        "class AdvancedCompressedSerializer:",
+        "    def serialize(self, cassette_dict):",
+        "        filtered_dict = filter_cassette_data(cassette_dict)",
+        "        return compress_data(filtered_dict)",
+        "",
+        "    def deserialize(self, cassette_string):",
+        "        return decompress_data(cassette_string)",
+        "",
+        "custom_vcr.register_serializer('advanced_compressed', AdvancedCompressedSerializer())",
+        "",
+        "def custom_matcher(r1, r2):",
+        "    return (r1.method == r2.method and",
+        "            r1.url == r2.url and",
+        "            normalize_body(r1.body) == normalize_body(r2.body))",
+        "",
+        "def normalize_body(body):",
+        "    return re.sub(r'\\s+', '', body.lower()) if body else ''",
+        "",
+        "nest_asyncio.apply()",
+        "",
+        "custom_vcr.serializer = 'advanced_compressed'",
+        "custom_vcr.record_mode = 'new_episodes'",
+        "custom_vcr.match_on = ['custom']",
+        "custom_vcr.register_matcher('custom', custom_matcher)",
+        "custom_vcr.filter_headers = ['authorization', 'user-agent', 'date', 'server']",
+        "custom_vcr.filter_post_data_parameters = ['password', 'token']",
+    ]
+    import_cell = nbformat.v4.new_code_cell(source="\n".join(vcr_import_lines))
+    import_cell.pop("id", None)
+    notebook.cells.insert(0, import_cell)
+    return notebook
+
+
+def process_notebooks(should_comment_install_cells: bool) -> None:
+    for directory in NOTEBOOK_DIRS:
+        for root, _, files in os.walk(directory):
+            for file in files:
+                if not file.endswith(".ipynb") or "ipynb_checkpoints" in root:
+                    continue
+
+                notebook_path = os.path.join(root, file)
+                try:
+                    notebook = nbformat.read(notebook_path, as_version=4)
+
+                    if should_comment_install_cells:
+                        notebook = comment_install_cells(notebook)
+
+                    base_filename = os.path.splitext(os.path.basename(file))[0]
+                    cassette_prefix = os.path.join(CASSETTES_PATH, base_filename)
+                    if notebook_path not in NOTEBOOKS_NO_CASSETTES:
+                        notebook = add_vcr_to_notebook(
+                            notebook, cassette_prefix=cassette_prefix
+                        )
+
+                    if notebook_path in NOTEBOOKS_NO_EXECUTION:
+                        # Add a cell at the beginning to indicate that this notebook should not be executed
+                        warning_cell = nbformat.v4.new_markdown_cell(
+                            source="**Warning:** This notebook is not meant to be executed automatically."
+                        )
+                        notebook.cells.insert(0, warning_cell)
+
+                        # Add a special tag to the first code cell
+                        if notebook.cells and notebook.cells[1].cell_type == "code":
+                            notebook.cells[1].metadata["tags"] = notebook.cells[1].metadata.get("tags", []) + ["no_execution"]
+
+                    nbformat.write(notebook, notebook_path)
+                    logger.info(f"Processed: {notebook_path}")
+                except Exception as e:
+                    logger.error(f"Error processing {notebook_path}: {e}")
+    
+    with open(os.path.join(DOCS_PATH, "notebooks_no_execution.json"), "w") as f:
+        json.dump(NOTEBOOKS_NO_EXECUTION, f)
+
+
+@click.command()
+@click.option(
+    "--comment-install-cells",
+    is_flag=True,
+    default=False,
+    help="Whether to comment out install cells",
+)
+def main(comment_install_cells):
+    process_notebooks(should_comment_install_cells=comment_install_cells)
+    logger.info("All notebooks processed successfully.")
+
+
+if __name__ == "__main__":
+    main()

docs/cassettes/LLMCompiler_0b3a0916-d8ca-4092-b91c-d9e2b05259d8.msgpack.zlib

@@ -0,0 +1 @@
+eNrlWUlzG8cVtis3X3LKvYNSSpSNGWIAECCp0DbNLZS5WSS1WFSBPTMNYISZ7uH0DBapdIizHFOF/IRIIhOVLNtll8tx4pxzSH6AfMiPyCXXvNfdg0Wk7FxTZrEIYrr79Vu+997XPR+ddVkiA8FffxbwlCXUS+GL/P1HZwk7yZhMf30asbQt/Md7u/sHj7IkePFmO01juTg7S+PAFjHjNLA9Ec12nVmvTdNZ+D8OmRLz2BX+4Nsfv/ugEDEpaYvJwiK586DgCdiLp/ClsBF0GSeUZJIlBHZMBkXiJYymDB7GIeUkFUSKsMtIkJJekLZJ2mYkSyMhUxLThIYhC4P71A3CIB3YZI16bb1QtkUW+gT1SQIJ8mAfZR5pJiJSYpoiDEUv4C1SIekgZnLxiDs2SWk3CAcNyWjitRsJk1mYysY9KfiMUnHpqICr9bjW+qhwhVigsnnGeCvgzD7iR7xsk4im7Zk4EW7IokUi0wRsRBf000WyG6NKNLwTBjK9A2N374Kkt0kzFDQFdUDqPpovlcIgpBv4zFciiRFpq1nH5tsx8cBSlxEGzgKngk4BRmRqCZlhdssmRwWHvEUqqLzAmT2R+OemtEUP1vIBoTGIkYQmDHWBv0HT/IOPKqNx7pOy+QKStXa3RYZ6cZHCR+hlIUY4Ar8GqBrrx+BlxKEkASeCM5wV2mQd1Aq4TCn3WJEcK0deVjoXYY+3SPXylWPiC9gVJYP6HZtsNskAduMM3ATg+e7tii/PDdGkCOKI2EpZOCBh0GFTW+OeaCRM5PlArowydjvgQRTcV24iPItcCINo6qnHBoTgJwkaAVbgMxagDTj9ZYPxP0Z9XIyqIVBzOB0VepBtJNC4cEo/w0mXHAzlSDdlTmW04BJqf6kMU7TV24f7B3rOK4ROSTW6FEmvHYDWvQDWJczPvJfNVDgzRk4FnwiDdXCqATJgDnGPywD6YJ9yy7HJjmOMSZuFsdoB6gdPTS0wuaDQjwEfw3AUZCNDTgWYctkDLXG5Km+gjvYFqpfrpAAAapzTzSTaZBi1HxB8kmm1RJbGmVqllWTdQGRyFPWMQ1popfL9oLBNGm0rf6ngTGj0fXKn3BZMp4AvdFBA3SAdh0RtsbN2Y+36aKNjXb+OVTU0si9Ls7fUTunSJKDgecxUVGVceGjSyiIIkk0O2oAh+HWZR6G0j+UmLM0SVJegpsQNhQtCAHOoOwWMKZEBb4oEVEYHUxd2V09BMpT4ovI2HQEuAYXCjOGegAFYxxCigP5JD4zgxif8OFJK2zmRFNORoROezU1EoVNA0KnL+hRrbZFAF9HSIafeg0ridciuSyM6lZ/jtANsT2SaNFGh2J2Yb5NDcOG5ydNiRy1l6Q5m+lHh7ihldcRv5j6hsgMm5fA3/h1ZWCQyZl7QHOg+y4NUvlyVxlWi30cQtFnQaqfvHBUwGC8PRpAfCFAcnihnk9NgCBslFKp7IuAzVxbJCvRl5qW6l0ADd6GZSmIasW7f0NOxZY3KjLJxmZOtrW1TKUA2FjcAQBYj8nlXdLCC6k0wgKZDNgOoSXm5HhMRtKZHAQIZ4C7UWQe8QjdA1mdeljLjWxSZ8w0a9ugAka9WhBQqiCkVJl9QSFFZpmqHy3I1cbwHbMcDTgXWIRkhhMzQK6bR5tXL9HefAWGLwDM+cQekRdEWtG9cLIyrUoi4RHvBLQybmuY+aDX6FJwjkargXu4Fe2G6TW83YQjHHeM2BYC6KvkUxIx3xj6zyUYGCRViHDWpUTzNOMZn0ksCFyQDGLtsXAsCDlbMmoxVBE35Tc9XzUTrbQpalIGzsVZ7KbQY6qumAHbrkoIycPWUuCYm7ViVkbiDNpvWLtZl1qimRLZGJk2U7NH2mlvCRCEnp45rE9bFdLSNaS6Tbplwcw6ukXQICLIk0w2025RFmKxmY0b2BrA9R6W7WDzRgAsMnt5VWdGmXezNkP6QCmRzNe/6kFMjFQKORF0CALSQTa4hN05LhVSTZK4KK5YQmANTphAK3cxjPkIpdwZIM/mTpgqGEgpP7jHdHMilQHc3BgjVA5urr+iPoD6GwYQ+z7sRLrQByzpzFSNSGU3ld+WwTfbpgFz++drOamN3vbG3tbzz9mVCm6ivphRGjnYxl1kyzgio5X3FEeUFhxi1YJeDj3OLR7zfqGFCDcyHmmI1TlTq+8huse5JUw+k4pJQ/7Q0bZw5CwlNhzi2YyjPsQHiDoOTISxKE6E4Hme9UViFiii0be0MgbDONbShExUSETI83ckBSIwKD4tk6tB3E0r/Ze1bEUJ6qYNcgl09hOOgro3q1IH0OBS8hZpIzRNGuwJCEyj070zuh8X73G7XWcSQKhTJ7s7WbVPx/PFZEsujZnomuJ5IAI+pgdlPyRqcg6BoBX4fjoZChDNAAhqcRmwJ/pFXLjL4LjyLBKQ8PmzFqVW1gPe4wlK4ZD1cw2HMgU9IKEYj+JImGRhfAAExlmmACzws2fWHZ23omnBO/91jQHE6fD598v6Eeh6DLRj3BObQ8OPW/SAuQl408djzFFzBmYrc8GmHsdhSXj7Vq4af4kEt8BTXmsUj7jPjOgsxdn74KfrYUh12+MUuKLG8OWvKjGNX63bp074lsUQizbUA6a3haazG/zI5EAN1ASGWuX4YnurFzyfnCDl8sk293f0pkUiqhk9oEtWqn08+T7BNR2x4trJ3fjszON6uYjtlu/rZlGA54N7wSZOGkp16AsgCG774d6PhNRtutLTputfae5trjeRaaeVmt14/adgbwV6fdUW4atedhfu9k8Pd3Zv83rzl1Mu1+WqtXqlbjl2yHdux7i3v3qwF6S2x3V9xNvi1lVtbJ956ttXZGmy8f5/b1U4s3Q+zObdVTfo3SkmJr2R7vijNu9u8F21u1LfDD8KDlbSz/t7y/Mleb7Dh2d3lqwS0yyDvlubWA17arW18EFbr8xXf79X9cq1tr6WrvRu7rdp6VD5Zr3duzMn4cEK9ysK8VTIa1krV+RL+/DHnBL86BeekmfzoMQCL/ePvZ+YW5w+77+eI/NdrP3m8CiAbfrOeBHAkL5F9FsNHuUqcucXKwqJTJhvbB89WDKYOEFMvFPefZdiTLI3+q8Rr00SydClLm9b8ZwcJkIYmAG0tB/WZ1854h/lPVy6E8zcIZwgigheS0YIjPhR8y6g5fHbLuq4vtKzN1c917lgiaVEOVVfJ+hNCFZQI+BdmGCoaioTNrUgOH1UX5p+bkRxFT8HQkuWUrJLzZ90WrRQVj0UChgEFSqCaD18UodZjxiw5c3NzZfDwVeydYeaz/cxdFRFSnavYsUJB/a/7lrp3gOaQWvqvuYqDbHAwPl+dn5FCZedyeFZWASz9bXJGwnADtGIk5/EC/Pz14km5KAemlGr1r6dnQYTGYh7VIvnV+XEj4XG5Hsln/Xy6FfjDF5fgS6NaqcyxZqXs0tqc7yyUHafuMFavL1DqlOcq7icr69YKEBJm7Sv4Dc9Wb+8sb2+ufHnLmsSRpa/OYJwLyYNm83SfJRCa4VMvFJkPxS9hpyDr+vLt4RfzXq3M5st1x681Af8g+9rKGQ0hTF1v+Hm7slRYrFYrhavQl5fma9VSSd1d/vJUn/y//dF/fJrSRWgsgV9YLOBFpwcHPWt5gZbSX5x0WhuHYdSkyUHJ9/ofVk52awvZTqFYEO49wKpZYY+vRm2FZpig7zpBZp6Uc04x7xymcZTAK+O+YVpMA+g7tEU4BWGT41kYgqy2CDy8Y70DanKf9QuLpWIBRKW0sPjA9KgCBUgrGoa7512yAF/g8JxJGmppD4uFULTwZC9z8bBjIPE6lEIbMLPuPnzjjf9/z4zd4BR+oIbbP1TD8bJ/0nbbtskMMDHuoS5XXv0i5JvJ9yD6jYF6D6KvffSrj9dfe1CA4UaHDZAIpt1wYO3V71Vkp7pVdueCinu4fr2/t3FS2xnsrRxuXPMGLlJDRelxxQX0GMehoeSvJXISqd9V+EDp2riQ+l28rPFxtmk2DV+3GnwHg/yU9S98nM/WFwDwVBGiiYGE9hpjev3yaBCZ9zxqYERdf/v0EHnjsuKNX2pCOOoks2W7Ar+fLGsiu3YxkT3Vw8NHb86++QoW8DzvD1uMt9L28FF5rjbNPc7x2VewnX++/nFOdz47EIJs4wsQQyFkbtRvvof7VM9zn/N8+n+0xCnV8/72BF8u9aca1IvOAwA3UNkQ0c0ALRC5wh4eNJf3NuEgiHeGqknD+Qd7q2+TvZDhtU0WtxKwBo+siT6awolQXXPAEUhmMZKZd8f4Ljx8+F+u1RTM

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

@@ -0,0 +1 @@
+eNrtVkFv3EQUVsUfGVkcErT2ene92c2iCkVRVKQ2KlILlwZZ4/Fbe5rxjDszjrOJcqD0xmn5BUCipIpa4IC4ABI3OPAHwh/hyht7N4EQVOgRcVjt7nvz3vveN+999tOzPdCGK3nrBZcWNGUW/5hPn55peFKBsc9OC7C5So/vbD08rjS/eDO3tjSTbpeWPDAFt3kgqMxYTrkMmCq6XE7VSaLS2Y9nOdAU0z87f9+A9jcykHb+jTvdxPnlrBsGvaDXH361wRiU1t+STKVcZvOX2QEvOySFqaAWTlv3/GtaloIz6jB2HxslzzeVlNBgnp/vApQ+FXwPnmswJbYBH58aS21lnp5gXvjl57MCjKEZfHH/7hLcJ9+55Mb4mMpqJfwNIVTt39c843L+2QuGZsTt21kJfwXw/Y3B2w1lZv75Wy8ZZTn4rHXPn0vlN5YvNxdp74HMbD4/jobD4w84nZ8jHyRTKhNwtiGs/2CPzS+CfHDbm0TRwHubFPR2f7jeD8Owkw/8/voNjm+vgdqm+478+fFaGN4M+N2WCwR8QW48sKkhRbicCjM/sbqCH64d29ovlYE/JGpG4CPkX+N9/nrrp0NvMWnexAuDUTAIvY6HXAJeUwz7JdcNq7HlBXgTWQnR8RJqWR5jPA5ijBxOeeZNDj3DqIC4KuMnhh9AjBWyDLQ36TlSrrzS5hrhmFhwHDd0ry2dqaplLKEo7ewqOkKvS7c83eS6NMTJzILxJv1wfdQb9sOjjsclDpdkEOOMZsYBwwHHFbIQUx7j9uhZDJImAlJv4jjreEpnMUNQTacpNwvnFGlFr8lVHVsr4oovAyxuJHbIQcdptWAopbOmmlAyc9OOCaIGbK60XRh6EQI0QDXydw1DrfSuKV1aw1QJscPE5R5v2lsiGcTGKo2b8ufoo6O/F4Z3XiUM+EGr6dbTvCtEgUtRlFyA7roVN/Z/zfiXmnHSH43D/7JovPHbodcOTZxTk6Nw9KO1/iAd96PRkPUYQJpEo/XBsM9YFPbSwXiYjEa9iPYH43SchMm4N16HNGKj8Tgarw2nCUpOQSWf4ri5DeI41o+8yylFb6lxKK3BX2ix+LWJX+81xoeoF26wvA9RtxiuGG4n3i+iwptCxBXDjcGI3ZrqVg4Wg4O/H/2jWg9mxkKx3Ua9btE266u6W5zqeK9bxi4jJt4d3B5JKKlwYUkjex3SiBygEQ9JYhUxSuwB4ZbUuMXE5kAqWyhjSUk1FQIEP6AJF9zOArKF094GoqRVIiVOKTQ3mA/rNJtLpoi7STNVbtZwXMihrIrYKiXMEXHozWRHHrr/cQqGaV42rzZHaLw6GJDHisuV1QnZxDyoCgZrNAUTLsEQFIVKoLEphxiUXgAwwY7ckcQnG5Lcu7dNqBMqwg1hrpuUVKglBGVV7TpobRHHA2D7SNOUS1SdA2iZuCSOYP6aIksVro1onI4HBKWBwD6wykIaNHVdyiU/VNT4TCBJm05QpHVBE55ZJuk0ndVcCHdwAdP5a7wdfAxT7M5RRghZoauET5tILF4jOobMY1QK+I5YIDMpSWYko64X1587qSpbVkuqLDW7xvW7fCS2d+W6JkuhDdpaCdYKgoCs4JhJlElIV38HB1H0IA==

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

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

docs/cassettes/LLMCompiler_38d3ea91-59ba-4267-8060-ed75bbc840c6.msgpack.zlib

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

docs/cassettes/LLMCompiler_391d6931.msgpack.zlib

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

docs/cassettes/LLMCompiler_55142257-2674-4a47-988e-0d2810917329.msgpack.zlib

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

docs/cassettes/LLMCompiler_5bc4584a-e31c-4065-805e-76a6db30676a.msgpack.zlib

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

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

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

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

@@ -0,0 +1 @@
+eNrtVs2O3EQQVsSLtCwkfjT2eP52dgdyWK0CiSAKYhcuCbLa7bLd2Xa309We2UmUA0tunIYnAHaVjVYJcEBcAIkbHHiB8CJcqfbMbCBsFMgRcbA801X19Vd/n3x4MgWL0ugLD6V2YLlw9Ac/OzyxcKsBdPfuV+BKkx29fWnvqLHy8culczVOul1eywgr6cpIcV2IkksdCVN1pc7NcWqy+U8nJfCM4O+dfoBgw+0CtFt8673buLCed+OoF/X6o6+3hYDahZe0MJnUxeJRcVvWHZZBrriD+0vz4hte10oK7jl2b6LRpztGa2g5L073AeqQKzmFBxawpjTgk/vouGvw8Jhw4ddfTipA5AV8ee2dNblPv/fgiCFBOWtUuK2UmYXXrCykXnz+UNAx8Q7dvIa/E/jh3OCrbclw8cXrjwQXJYRiaV480CZsT77aWcG+C7pw5eJoOBodfSj54pTqwQpjCgUn28qFu1OxeByVg4vBZDgcBG+wil/sj7b6cRx3ykHY3zrH8N1TpK7yA1/8xdFGHJ9P+PKyFkT4MTvXYcdCRnQlV7g4draBH59yu3RQG4Q/AbUj8DHV31I/f7vw851gNWnBJIijcTSIg05AtQRqUwIHtbRtVRMnKwgmulGqE6TciTKheBrEhGqYyyKY3AlQcAVJUye3UN6GhG4oCrDBpOeL8sSqXWmJDiZK0riReWNtzMxMJxqq2s2fRA/J6uHW3i3W2UGSzh1gMOnHW+PeqB/f7QRS03BpAQnNaIGeGA04rZCDhMuEtsfOE9A8VZAFE1+zTmBskQgi1WaaSVwZcyorWbE0s8Q5lTRyHeBoIylDCTbJmlWFMj5vb1NGF37aCWDYki2NdauD3pAIInBL9XuKw8zYfaw9LApTQ+I5ST2VbXprJoMEnbG0KX+Nvnv32cLw1vOEgR46xe4sL7tKVbQUVS0VCcNNI6luXb/p6P6Xjn8pHcf9/jD+L2vHS7/fCZazk5QcS9KPDOI0zgVPB7AVQy8GGOf9kdgY51u9za047Y1G6XAz7Y8gG6RpL8s3xj0x3tzs9TZHYpz2SXkqrmVO4+YXSdJ0Xw/OhpWstaXZdEi/6MTRa4de77WHeyQbfrCCj0i+BG0aLSn1l1hRp4hxI2hxKGJ/xu1SFVaDQ7+v/6O7dufooLq6jHrRS5eoz8tu5dUJXvQat46YBLtGTYFx1qoDDTnjGmfgO8gcx/2IXQZLdnrQVMCKRmagaPFxckOzkF3RzJXAthGll1XHdoX18l/zrMPmpmEzqRRLKZC2VDNa00Y5ZCanK4mCbn1KThTgAETjIGPOrDi0yA0JySt4Ri9qb90rTVOUjmmADH0AiTN67qlpXBt2lk7KkTDNkua1lNCm7TIjk5r1wj5D8HtJk72EvlJoQ8lKa0HB1Ge0/LhaU1955S2eF1VJe8L815OtWmAmkdXkTLCdNmvKlPogJAJLiZ3XTwWOjnXGSlB13qizhM2zc6Yrfa18J5pW3L33Ch/pZsy57/Oc5VJLLH0Dl6gdotmW2vuDeybxiL3fiqg/bJ1y44XAAy19qOM39Kr0E/bmWc2jKGKv0phpkknIXvsDevT4DA==

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

@@ -0,0 +1 @@
+eNp1VHtwE0UY7wMGRAahTFV0GLZxeE4uuSRtEio+QugLrK1tmCki4OZukztyub3ebdIGrNhKBQXrHCgIiLxCw2QKbQcRkUfBEQtSXxQcQAf4Q0RmoFRxGMFxcJM+AIv3z+3u9/h93+/37dbFwkjVRCynNokyQSrkCN1oel1MRZUhpJGljUFEBMxHS0vKPdtCqnh2vECIouWazVARTVAmgooVkTNxOGgOW8xBpGnQj7SoF/ORc6kdiw1BWL2A4ACSNUMusLDWbCMw9HnRk7mLDSqWEF0ZQhpSDdTKYVqKTBJHgpgFiiYGgRd7DTVGcNcXapqoEQr/n4BCJEkYTMdeGkcmakAWOQQIBkGECIjgkAm4NABl4CoC/SmMSQgBqUlPAUlKwhNUiUSgrhGQJCJBC8AqIFALaEl7EEaAAMPIBEolBDUEJAoRRCAg4yog+gBJZJyYQIsQQZT9oAhwFLkHth/BdH9fAzmgBJGIkjQSVJ3sN/mn+yoBJnoMRoAMg+i5nkz/5ywCSQwgINDigiFOSJQXoRXIhpp5NfMSmmAeSQlHToIhHjE2RoBiIMRYqWSsjXUYamICgjwdl4aogDWitw4YgGbIcUghDJI5zNOO9Z3+RaJiBDzySZCgOG1KRskJ0+MBhBQGSmIYNfZE6S1QUSSRgwm7eaGG5aZeEphESwPN8QRXDB0jmeh7XX11mEsp21gGrMmWbbK2VDNUYlGW6MAxEqQlNSpJ+/57DQrkAjQP03sX9Mae4F33+mBN314MuZLy+1JClRP07VAN2rN333uuhmQiBpEec5cOhOs13oWzmSxWU3brfYm1iMzp231Q0lBrP8n9IXGqio1h7Qxr2aEiTaHDid5spOEkpNVFKfuo41is95ZtLZnVp9zK6Ayqg34wXxWNwMqCcqSAhL7AkpNrm5prnQoKij1N7l7aPQ+kvdWjQlnzUerz+mSOcUJIDiA+7n6gwPHet4QRef0AXS9gLfZie0HYay9dFClwCS84IrPlsnKUv6ea4SQc4hlCHyLEJOWvJvpZ4HOwTi6b5a3QxtudOayVtcAcm8PLOTgvO9XGbwuLUI9bTBbgx9gvoWZ3PuOGnICY8iQlemzGnBddxUXupgqmDHsx0RgP9OtRGcuosRyplFY9noSmg6qiRhpe5pqjf+Lk7FbkdPIIQQvPWnKY8pnulj56+tuPJqY8+eDVUglUenQ0NT5uxdCU5JfuKTvS0Pn88H8yT6ydfzIujap/pdSVVun6+Uzmirj4lZhffPXUTckRv3190pWu+Ef5r3+6adOmyysne9/eeG3viaoN19s72y+EPr/wzIxb3YEb1/wn/14++Pb3nRV5PlhSsXnm02lHjOuGhI0tqwuZNRV7sgrWN/9aXLhsWtvc8wcX7FoTMLZkhL3tf3x364MfrkSubvw4Y0lHLvvS2GFn0DILX9nSNCg2wTl8VaaTDDr+aDcYk7F/Zkfm0cniqR9HDj90rKs+fWt3x5aHSgbVDhmJC7MqmXODS74YGV6FdzzWfey9A5YdeVv00WTfwsNPPnHx/c8+9NS/7H7nzurRs847WObW1YtpQ9Z0buhalzHpdHR99SOmh/+asm+jx32hjK2bf2lyXtrqhs2jxy//JWvPTcPv706ZvmFEdsPy43HpZqTs9NJD4/JPhd44PGrX5TFz53/z6tahqeHjzelyjVLboZNpv50udvpOwtq1bYPXz2qbPWzCyvEZ7Tv96LWix8faKvMqVPmntBt/lnxtm9C1G88b8eVblxbN3sy31T+707x2CRXlzp30lKbzT31bn5aS8i8i5std

docs/cassettes/add-summary-conversation-history_0a1a0fda-5309-45f0-9465-9f3dff604d74.msgpack.zlib

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

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

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

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

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

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

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

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

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

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

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

docs/cassettes/agent_supervisor_45a92dfd-0e11-47f5-aad4-b68d24990e34.msgpack.zlib

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

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

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

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

@@ -0,0 +1 @@
+eNrNVV9vG0UQV8VbPsXqJCSQfLbPTtLYCKHUSYGGkMSOClUTWeu9sW/j8+51dy9/GvmBwBsS0n0FmtqVldBG8EZ554Ev0H4RXpm9OycxSXlCgjzEdzO/nfnNb2bnTsb7oDSX4s4ZFwYUZQZfdHIyVvAkBm2+Gw3ABNI/3dxobT+LFX/zfmBMpOulEo14kQoTKBlxVmRyUNr3SgPQmvZAn3akf/T2zifHzoAeto3sg9BOnXjlynyBOFMUWh4fO0qGgE9OrEE56GUSqQhjTQcBNYRrYgIgB0DxRxEuiO46w10bR/oQWhwLaeyDW3UDyvuxW8E05Wr5ro2mjQI6QJBRMeC7kTLMEws6SBNroIoFFuyDZopHVgTraNAwJEYSHatuzqFTtDguoti0NQtgQBF47ESoAijD05qOHdROHaVP5ijKchjFRc8ZDvG01ZYr8C2LHGqrmUJlZw+YQejucBwA9bFDP5wGUpvk4obmLyljEBkXBJM+JkjOe095VCA+dENqYIJaCkibmkz6AJFLQ74Po+xU8opGUcgZtf7SnpbiLNfetVxuuie2RS52Tpjk9bI+Emx5Sqa0eYRzIki5WJ0vVl4dutpQLkJstBtS5DWKUv+v1x0RZX0M5uYzmIyywz9dx0idPF+nbKM1E9L2K3lO1WBx/ufrdhULwweQjBubN9Plzqt01aJXKc5fzAS2RSXn6U89/c/lxaXil0cnOGFVt7zolr0XCnSEdwa+HWEYE+uTU2wF/PH7OJ/yHzfWpm38/nQFm5L8dl/xAqmUSQsiYmeVeAv1aq0+XyOfrm+fNfIebNsevCEGDk0J9q0lm+WPCAuo0mA+jk3XXbrYVlToLjZmdToEYxbEog/+pHFr+88bFCfXtXnw7iUvhHSZtUzyS+9yP3mNz+2yN7+1ZhYXvJ5uHTx8Wmm2OPvioHbwbJ/TZOIVPdKTshfCy8Z9N4vZSiVIxiuPvlxe/7xx9rXblB1ptLtNe8mpkAJGLVAoYzJhoYx9nFIFIzzeXH6U/LLEFitQK3dZd2Fh8S5ddFsPGukm+WaU3Z+37/2ZKlEnubht1FyZOZ8aenXbnBmnU5i+O/Vjh/vWr3tYm7faXPnsoHpountb/MFgrbbQ86pbCJ+NgoZsQzlUa44hRRoyWz3v3jxXa+zxbgGvv4za2DxtF4uIwzA3aau4YDA1xpc80w0zXZzVylLBkbG5bvOGQ0KGc3O5IHm6dieUrH+7LLdAkCcXPhw69XJh1m9J5Ofsymzj1bdgP3+PUcDVWnBv+cm9Zu2rjmpx6nkPmy0MVcgX6+VezYrBgJZx+ndFO8Ku/o0ncaJ0Vb6jNNTd0H8uLYXMlJZZrkrK5LU77RIcoRychqkREc6UK/mPiRzvZN+IHavM8P/Bace5+hpnnP51QsVikXyA32yB3x/wP/wL9s8k4A==

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

@@ -0,0 +1 @@
+eNptVFtsFFUYbqkGayKRBEPCC+OiiSadvc10t12NYTNQLE0vsqu0kHU9nTm7O+3snOk5Z0q3TVEqaoyCGV5UsDyU7a5ZW+hNE6UaDKikaWIIXlKLJammCpio4ZFoPTPdrSVlHmbOnv/y/f/3/f8O5LshJirSy0dUnUIMZMp+EGsgj2GXCQk9mktDmkJKtqU5Ej1jYnXu8RSlBgl5PMBQ3UCnKYwMVXbLKO3p9nnSkBCQhCTbjpTMT+WePlca9MQp6oQ6cYU4n9cvVnGukhe7OdjnwkiD7OQyCcQuZpURK0Wn9tWhFKCcSjiagtwhCNgHc6rOkYSrP2bnQQrUbD9ZA6YCeYFPAbXT5P0Mxit4g3Y2ipBWBNJB2gEiEGA5ZRsVSGSsGnbTtkECmsZRxBETJ4qY7W7bT9UNk8aJnIJpwBz7XAbrGmKqOj30uRhXOOOcaMZYwaBY1ZOu/n4WbXOpYqjYVRRd7epLrqi9A8qUucb68ykIFKbI8WwKEWqNr+P4HJBlaFAe6jJSGIA1muxVjSpOgQkNUFhg3OnQEdEqdEJo8EBTu2FuJcoaA4ahqTKw7Z4OgvSRIte8Xct6c8GWhGdK6dSaDpOMLodLxXhaMmwudM7rFkS3f6yHJxSousaE5TXA6soZjv38WoMB5E6WjC/OnJVbCT671gcRa7gRyM2Ru1LaelnDAKcD4uTae2zqVE1DKy+1rIcrGv+HE9w+v1scvyux3ZQ16nxCzltF46uMr4YW2EQJvDfAe30fYkgMtiPw1RxLQ00ykGVSwNnL+eJUDzU3lGR8O7uLiWJ9XofVKs7v5SLQ4OzZ5HzVIaE2JAa4PY3REamoQfSeGoxHMdBJgumwu6R5Xk6ZeidUCtI91S4Ud5dXFWuaneNen7Qv09RVjbsUYraGGw40ib1i9/MdH/fwsoZMhads8SHvzEIPteY4QUx4g9WBQFCoDiiiD8hCQhS8ohCUE7VCtdJ+plsFVsHn9nFJhJIaPCfV8RJg28FHHEqs/K62pnBjvTTSyu9D7YgSPgqSVlZHOsxFIGa0WgUHmk0thjkWvi/cZk3VyAE/rEnUJqDsCwRBgI/slcZK9Ky2n7VH3vmDOZJbWbOvyiu2v/VAmfNURN8JN1zc+fBry3szvz2UrY/cWjj6yhuL4S1Tj1Q2+AO+Uz8/Nnlw9NHlWMD1e9fC7J2FU5WN9795vHn39OEW6d3I/NTN9/6YkE/eufhprXQh1vvg/ksjTfcduXKTe2Lp9UH/pg2Do89KQ9/N7N8y/NzoyR/21H+gLYpfDOxUj+34hYvn4kOTL2w9XYFvbE7EL92aPn994Vps+8Q/z/QtX1s4fOXq7aXNG+rML7/Jfj2xyX21b2Mt+Et8kfs7PPO9eHbb5GJw9vZHZU/Nb93x5CdLL/868dK2p98/wR378cAFj2fmxsZYzfwJcFmcq2z989+OttC311m3y8sVZYONn8XD5WVl/wGbeE5l

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

@@ -0,0 +1 @@
+eNqNVQ1wFOUZPkkVanWowbGMtPFjTQU1e7n/XNKqJJcfQzlIvQNDQubY2/0ut9ze7ma/3SRnhIGrWLFTytbQnzgFlctdegVM5AgdQX5Cg2IgQCmOKZUhCBraFKW/gGXSbzd3SSAMejP3933vz/M+7/O+G000QgmxAn/HVpaXoUTRMv6D1GhCgg0KRPIL8TCUgwITq1rk8W5RJHbgu0FZFlFRfj4lskaKl4OSILK0kRbC+Y3m/DBEiKqHKOYXmMifs1a0EGGq2ScLIcgjogiYTRZbHiAyVviktoWQBA7iX4SCoETgW1rAUHhZO0KQkuggCAgSkIMQNEEKf0mA5QEKAF5oIlbmgfEAFEIskjGmG6PgFDJs1uO5oCRTLM9FZoPKORwHbopPK5KEfSbm8VA8KJconmYRLeiGEUExggVQBmEIMGTdMRNH4XUCgYxNWZ7BdyzCUbBbmNIujBoyOSLqcHVQegFjJ4LA+XBMzYqnwnCcAu2E5UVFq6KFwK2RItrllwHWwhMsk4mt+Exmb+niErPkfY518UvsQb6qef4SscpNrKy7gcrJvai9CaYEkcLdxDRRu4yolOcggBSej0xCkwf8iqzxB/xQxmoDnCCEgIDP2IB2PEeCgAIVMMzyLFimME4rgz+hyWlcRtTpzKX58X2lkrTSkQ9KkiBh6wDFIYirrNP0JzCQ0/njKJyAtJJ2Egk8D2XSghVqclhMmXRpjU7uBgMRLbGi1lVdWRSWE247UqRAWqt+41jXfIgOwjClN0/EA4NlyOryH+/lOL1Illi+nlip9U4bQ1aCWrm1adO6CRIS/CsgjUWE60oEIcXgYV4fCwpIVrsmjeebFE1DUSYhTwsMTqBuq3+OFfMAAwMcJcMkrRGgy1dNhiAUSYpjG2F81EvtpESRY2ldxfkrMFlb020nNSyTr5Oagkg85Lys7irO4MiviuBtwgOT0WozWjqbSaSPI14HJEdhSHFRv9898UKk6BCOQ6Y3lRofdd4+0UZAarubohd5bgiptUptp6Sww7Zj4rmk8DIbhmrCVTU5XfpyPJ3VaLYYbV03BEYRnlbbdUl1jZE85pLEIrKSJgdpMnfgMRHxRoU/imN3WUHRGGYfHnkvkd6Bbyz6QaZzZwzZsVLcCfWdconNAxYT8EARaIIEZnuRtbDI7AAVbu9WV5p47y2J7/LicUMBTH5ZptEJOqjwIcgkXbds8QAxXoKE83NsmJXJ9AMAN0b7q8ZsJpNp4JHbWkpY4nh0ccaYtbCw8EviYmagrKa0+khTIR4872iVdlvNALiV5+hTJI0nruHBiHJvYzmOJ2MNbmt9azxmR00yDZpkGXUP/o13TkW9s6TAaX6abyxujDiY4qVVDU/Pb97ZTNKcoDCkjB+lkNRHpFlWBwAdcDpopwM6TAUOu9PutDgKTAG7n/HjzwKn1balkaXUpNloBvWCUM/BN13lpIvCS4P06LJRE6VLFxa7K11bq8lnBL+A+fNSmGde4GHcAyUsPTWpp8bDLME4dn+meKmactIOC3RaTQE/fhcWBEjPfFdnRkBjAolpm0B/ZK+Jj26f3ikLH/rJNIP+ypJfOcDfb77nRV/v++2/ZE/9otuLis9VvXw22rHhm2WPC+c+6nLQ07tOwo5rl+ae/CMxe+GW3O6RkR1P/HeNZ+hg8PSpy4f/fcxXcAU+2288l+j72cWDdd/Zd809FD02Y+dcy0FyrfH+o3+fcvTDb/e6vlXubnU95D/UNvT5qcGrr/922tXBi5cvDlzuvdgwVOJtyJ5+fdcXT5X9ZlX3vy6c/PGuYOu8O58Hpp7sqXMZ+27l8xzi7gVlnznvO1JDHXvS0Ffe91L/Y6tD2/bmvltz97qDm45PfWz/lM0/PJt8rbS74/q2v7x/dN7Ivat7Th8olqdzyxczT0ZfXXNveYl5+VOmeS/9unNez9UTR1orn7/ro9Q9s6qHOr5e97dNlzpsd81KffK1Nxaezbq2r2N/NnK3Gu5Men/3q9l/dTo2VfT42mY+PFPoLepcRwhOf781NXcJNdDzvQeXfriJ+9h23wNZz1bP8D7aeuLRnWjH6hOv9m9uLN34h20b7pgfbWAPtRkGKy68FXphpH9aan8ssKffuqB6z9pBdPSnD7wcPLP8g7zWnJYXPynbwc8yLFib/W7ZlWnbU4ZD1d8oIh3ZhRK/7pinJWfV1OFOX9vuR6pfibgeb/20u+rtAfH8PoM7tC5VnXO40pc3zIaHmb7zZ2o/znOv+s/rysa3yNNNG8A/17e9tz18uO/S9ab2B9cfea0v9MHvr6yakbO36cCyxOLZto3Hp/489Y+a3O8/MfN6R65akm//1PinCxXDn2X1eVdeePvhruOb39k7HF0y8sWl8/87PzhYgIUzMpJlGIn6s4eyDIb/A30/Ijo=

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

@@ -0,0 +1 @@
+eNqFVGtsFFUU3gVCxFhB/INodNjwEOzMzuyr3RqCzVLetaVdeRlobmfOdofOzh1m7vaxtRVKiVFizTRCfKQJbfdR1iItRUBQAiYQxEcIIlpRo5EYgkSj0YiSFu9sdymEBvfP3rnnO6/vO/e0pupAN2Ss2vtklYCOREI/DLM1pcOWKBikLRkBEsZSvLysMtgT1eWhOWFCNKPI6USazCGVhHWsySIn4oizTnBGwDBQDRjxaiw1fmP3NzkiqKGK4FpQDUcRI/AuTz7jyKHozfNNDh0rQE+OqAG6g1pFTEtRiXVlANLFMBPCOkPCwNQDon86I6uMEWJUXO9o3miFwxIoFlxUUFQC1s16WQOrKhDWRRPyPhdvxSUYK9mUKorAWHzLKIEh6rJmtW8ZAkhRGIIZI6qHsqmrOQsnq1qUVBliGCKIApscGu0fdCJnumlyUNb0xsyJNGqjOYguqzWO5mbqbbEq6yBZVWShVgM5KK7eDCKh0I3NqTAgiWrTHg9jg5gDd7G9H4kiaIQFVcQSTWDuq4nJWj4jQUhBBNKiRUBGTjNdC6CxSJHrIDnqZfYjTVNkEVl252ZKVl+Wddaq5W5z2hKHpZqpxDxcnKvDWd5Ih0NleM7t4Vz9DaxBkKwqVF1WQbSkpJaxH7vdoCGxlsZhs4NnJked370dgw0zUYrEsso7QlpSmQmkR3yewdvv9ahK5AiYqUD53emyxrF0bk5wcZ6BOwIbjapoJkJIMWDgFsm3XNJ0iNws72N5oVcHQ6MPBLYnqTuJGq1xyj58eiaVHenuspU55b63TY8vpkqYHy7R5XzGxTOVoDHWQDKCt8jtLxLczNLSYF8gS3xwXOIHgjpSjRAlvyQndEoMR9VakNKBcSUecoy1oNP8ihyRCZt9z1QY69OMe3ieH5p7T6ROR1xWrYxxt9/v/5+4lBkg5kGrP5b304cXHO3S69kwxIznOboUsvUkrXpoRbPvgRyrJ4dm7okevx7BvSGdLZqVJfMDeq7iheA6/5qlXrFwxbr1K+pKnkPLfFJ5cO17Dayo4KjEEroZgc08kQZiDjG8y+dyIx65+QLgwSdQxT0icnsReMET8kJPnYzMtMAJTA3GNQrsDyxhA4guDbYyMzZmavH6Z4tLlwf61rEVuBpT/oKI8qxiFZKVoNPRM9OZ1PQx65Ck7hXF682DhaLPBYUub0EhXx3yF4TYyhWB/twA3RqQuLUJMht4W3J0+5yyb3hi5322zG9i2+rSsgnFDww/JTo3TR7c+uSvpULLtOXLgg/OHHwzf0cnf+mjVfMOdAz/Fro446/Le+Ubm278G7Mda3vsaj93YKThSOyRMu6X70KxTZ/F3+98u/74xLzzitDFTxpccu6HoUTrlJOThdl7un6eU3Smi8zlBgquvRrb9nJ5bLuivdWZ5zpX7prS8cxI7PrjC46U/cld5oudpztq2y8MDxgL9vwOiTXXdgV7z15Z2NFb76noWrv7Qs+s6E95u3yvf2t/tH3eVXvJl73VJ9qvL5xXMX/38inv7EokOs5OBvnUcd/eLRP2jZinr70y4/zJzpXzXyu5+OLRluNXb6SmPt11qrf7n5ajX39es2fbqs6Gqk+m7zy0mll0guvGHf6bV1461PzFtLbDO5Y+/MZI+spMe/1DexefmV+UmlW36OOpVZfu/zGvYusLhUfPnVjd8tXp7YeGJ9lsN29OtP29qsr7h91m+w++IeQI

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

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

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

@@ -0,0 +1 @@
+eNqFVM1vG0UUd9UiISBSU4kgcYCtocAhs95dr11vBALLaUJJ86HYqDQBVePZZ+8m693N7tgkqSrUhAtCKloOXEBAiGO3rqExtCoiCRWBShTxD1gqSIiPCA4op96qMOvYSapEYS4z8z5/7/fezEy5AI6rW+aBqm5ScDCh7OJ6M2UHJvLg0rdLOaCapRaHBpOp+byj149plNpuVyiEbZ3HJtUcy9YJT6xcqCCGcuC6OAtuMW2pU/XXzwVzePIstcbBdINdnChIcicXbBkxyei5oGMZwE7BvAtOkGmJxZCY1BdpevD8G76DpYLhC4iB8yogiReD58saYJWhv1jULJd6tV14rmJCwKYITGKpupn1Ps9O63Ynp0LGwBQqLJEJjYK9yjiAjbChF6C06eUtYts2dIJ9fWjMtcxqExiiUzbsVld8/IiVZVLvRryFIzQ0xegzOYEPy7y0OIlcinXTYAQgAzNIJbuhX9qpsDEZZ3FQszVeadP5i502lust9GMymLwvJHaI5i1gJxeVv9opd/Im1XPglRNDu9M1ldvpwrwo8XLtvsDulEm8hQw2XKhtkbzlUpEEKYyEKBLESw64NhshmC0xd5p3Z4qMffj5x3Kz658N9rU692vgSLGbdcJb6XH0Tk4SuCTYbJNkTox0hZWusMz19qeqiSbxqT2Jr6UcbLoZRv6JVqPLRMub46BWEnu2uB7cLsFh+Q09p1PUnHjWGP/qFSVBEOrP7GvpQI4x5Gcsioqi/E9cxgxQ75pfHxIUJAmpzSoj8kid28tz89008ZRkwV/1p/ex3MbTsub2td4bT1geqTRBI131ltn5rCD2T3er4qtDPQP2yIDimtLpnGmp2vVJRAwrryLK/g5AjScySb06pxBFiZFMVJAEEhFikI4oongcRCwpGTUmwnxBx15F5EUua1lZA64melACEw1QsjE2Xrn7zEC8/2Si+hoattIW4y+FGc+mZUIpCQ4bPa/SSM0eswMl5j4cP+Ndi5GoBDEMGaJGCMgxlHwlsdgaoK0BKfo/QeOPusDG1GGiH1affPfBQGMdPHWx9tDqS4e7b966PCh2dJweI/hotCP426mOto+XxKVe+egG3/7AlQvH38PTqWPP/zt9e60+N/rojeg71cLa3W9+efPDe2RldnZl7HE03PbYTOKpiUPx68MPG/bXfSfbnzjxyOXi3+kPvps7HE3Pvnj3Zvv82qW3VklC/OnQ97fj/f8sz326us7xbl/b76PPvXBkIr7+UZq+/Mmz3/beyn9554+e6nr9Tvz9e/N/CssHAoGNjYOB7KIz+hcD/h8xL0q+

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

@@ -0,0 +1 @@
+eNqFVE1sG0UUTimqQFCEKorg1MWCSoGMvbveuHYOQLBpRIKbEFuUpKLVZPfZXrKe2e6MQ0xThYYKEIGgvaOipI5dWYYmIlUrChI0kQoih5YDyJcGDuVHINGgiHIrs46dpEpU9rIz7/d733tvxkpD4DCTkm0Vk3BwsM7FhbljJQeO5oDxk8Us8Aw1Cj3dieTpnGNWn8hwbrO2QADbph8TnnGobep+nWYDQ0ogC4zhNLDCADXy1ZFjviwePsLpIBDma5MUWdVaJF/DSEgOHfM51AJx8uUYOD6h1alAQrgnypi+4696DtQAyxPoFs4ZgFS/4lmyPOOQ9eQOMJsSQzKJZHJsmZj4jpcygA1R3UQhQxl3ZzfhPYt1HWyOgOjUMEna/ST9hmm3SAakLMyhLIAQqBHilgcBbCQCD0Fx1cudwbZtmTr29IHXGCWVOnDE8zZsVpe9+pAom3D3fHsDR6AnL+glkuwPan51Zhgxjk1iCYKQhQWkol3TX9yosLE+KOKgeuvc4qrzpxttKHOn41jvTtwWEjt6xp3GTjakfbZR7uQIN7PglqI9m9PVlevpgn5F9WuztwVmeaK70ylsMZhdI3nNpazKahDJISQrZ1ZbxeCtonDnOTZWEOzD4jel+lRMdXc1OnetaVchJjrhfrnfMVskVZYSYIufqklKa1sw0hbUpI54shKtE5/ckvjZpIMJSwnyn280uqRncmQQjHJ0yxZXfeslOCK/ZWZNjuobIRrjXd2CKstyde8dLR3ICoa8jAUlEon8T1zBDHB3zqsPyRGkysnVKlu1/qq0lefqXtXxFDXZ+6qP38FyHU/DWrqj9dZ4glp/uQ4amYb7hTgfkZX4yynQSIy29mqxjvxLaiqU68v3nBtGukVzBuLibQFUW5Fh7lZFFwGCmqwoMugQ0iPhfRhSqSBEQiEtEh5InR4ysVtW/IqUpjRtwdnofhTFegZQojY2binWd6A9/kK08grqpQNU8JfEgmdCCRQT4IjRc8u11GKZHSgK9972PncurIdUCA+o+8LhsA5aGCU6ozONAVobkIL3EtTesBNiTB0hWri8Z/yeptq3/cWJ+OC8/GBstOvXyskn9+z8rb/3uXdp5O5O5dLhhxL568MHJz9YHg08cO+KduMXZfHN4tvRpyZHzr0ztfTR/PLn6M+//7l66oeL53+6KV9Zmtg7HhuRHllpPvDVuDZ1aveObLn50uR7T/+oHVpE95cXOiv2x/Ms9nv6+79+vnHt35Wx5e+e1XLQfXjX/IkL/tab73c8xr9d2P310Ymr0tKHF7btfL2vK760cFf64I7mP0bnHr38jEB869b2poevtNx3XZz/A80lXQw=

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

@@ -0,0 +1 @@
+eNqFVF1oHFUUjhRF1OpaKpS+ZBg0fcndnZmd/YuChN1ETbsmza6atJV4d+bszrizc8eZuzHbUiSJqJAamKKoKIrpZreuscnSSEANiBWtYATBly1Ugw/F+Bqs4ku9u9lNUhLifZm555zvnu9859w7UR4F29GJececblKwsULZxnEnyja8lAeHvlrKAdWIWhzoTyQv5G299ohGqeV0+XzY0r3YpJpNLF3xKiTnGxV9OXAcnAGnmCJqoXbqDJ/DYyOUZMF0+C5OFCS5k+NbQcxy8gxvEwPYH593wOaZVyGMiUnrJk3nzz5fBxAVjLpBMXBeBSR5Rf5sWQOsMvbTRY041K3u4DOPFQUsisBUiKqbGfezzGnd6uRUSBuYQoUlMqFRsFvJAlgIG/oolDZQ7gK2LENXcN3ve9Eh5lyTGKIFC3a6K3X+iJVlUnepu8XDN1Bg8pmc4PXLXmlhDDkU66bBBEAGZpRKVsP/5XaHhZUsOwc1W+OWNsCXtscQx52NY6U/cduR2FY0dxbbuaB8ebvdzptUz4Fbjg7sTNd0bqXze0XJK1dvO9gpmIo7m8aGA9VNkTchFUmQ/EgIIkG8aINjsRGCyRKD07wzUWTqw49Xy82uz/QfbXXu17YDxRjrhLvca+udnCRwCbDYR5I5MdDlj3T5Je6JeHIu2hQ+uavw1aSNTSfNxO9pNbqsaHkzC2olumuLa/xWCTbLb+g5naLmxLPG1LduURIEodaxZ6QNOaZQPWNRjEQi/3MuUwaou1ivDwkRJAnJjSoD8okatxty4940+ZRkob5qD+8RucWnFc3tGb07H790otIkjXTV/Yr9jwjik9ogTavqEEjhHjGfCUaO4cCA+PkYUgySVxFlbwegxhUZo26NU0OiPxxgANUvCXIqEoJQOhiQZb+qAI4EIxdGdexWRK/IZQjJGDAf7UVRrGiAEo2xccux4ae7409F54bQIEkRpl8SM51NYkIpATYbPbfSSM0usw0lBh/sHnYXw0pQgjAOpSAkKSCHUaIvutAaoM0BKdZfgsYbNc7G1Gamb6+0T93d1lj7jk3H7/1G8MRemXKmUw8ddNaL3BtH7uzpM94ZPPf+tev/PPPvb7Mzq/rqivLuXXD/1NTBNWHY9+z89bXHlt8sjLy1vnLpQ7T08qE/Ls/8xD/4nOe+P1cfXY31Hf/+nsmjV3+4wq97b/zSvv/AIXX87SH8wAqJrf289tHC0Pm/P379psYdrix2HBnH3R+UD2e/W/J80fv7uRcip4nn8X5j8vynFz95zV/9uiM66fmrPX7t5v62tlu39rUt546/d4Mx/w804E3g

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

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

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+eNptU31sE2Uc3kZAMuZHiAkiCmfNUJdde72WazvjstFtsK1bR9sYYOJ8e/de7+j13tvdtWwQMJv6F2I8MILRmUy6K2umW7M58GMaxBkhRhdnyJYQFdRojAaYU1mi4NvSzZFxf733e97n9/E8v7c7lYCqJiK5cECUdagCVsc/mtGdUmF7HGr682YM6gLiki3+YOh4XBWnSwVdV7QKmw0oohXIuqAiRWStLIrZEnZbDGoaiEAtGUZc57S6zxIDHW06ikJZs1QQdop2lhOW+Us40rrPoiIJ4pMlrkHVglEW4U5kPRsSxIeI+kdiRBiFLft3ZZmIg1IWYSUQ5yDpIAUgRuMkjRNTDspl2Z8SIODwTC8lBaTpRmZJl4OAZaGik1BmESfKEePtyF5RKSc4yEtAh2lcXoY5GYx0FEKFBJKYgOZNljEEFEUSWZDFbbs1JA/k2yX1TgUuhdPZqUg8rKwbJ6vn+7C1dGJRZYKyOpxWeqiD1HQgyhKWhZQAbslUcvgHiwEFsFGch8wbZpg3ye8svoM0o68JsP7gLSmBygpGH1BjjHN4cVyNy7oYg0bK27K0XB78v5zDaqetzswtibVOmTX6eCBpMLMg8gIljV1xkBRDUvYTKtQUvFjwORPT9bjWncTqwy8+T+V34S1/47xzLyZrsA/GWJ0qlhM0RQShQmT9JeybKhyeCgdNbGkKDXjzsoduK3smpAJZ47H0tfM2p1ghLkchl/be1uB0fuFJkTM+xOc2yr4tsTUe4Lw7t0fd3JPBhMfD1O5sYN/tIFkJxTlSx68Fkjn7O3RjmmAZ2g2ZMMNSPM/SIEy5KFfYztgZN7+JhmH+eEIERtputRMRhCISHPTWkV7ACpAM5iQxUjU7mqub6r0D28kACiNdI0MgYiRlJEMzCFUsq5HOlcaLqkIT0wPVO4wRNy4M3cDpApzLw7h4MtjgHZqXZ2H8ZHbLc6+yC1ug4tB4Yc2GgysLct8y38v+xjNV94x/fM599OnRw6MNpUcDtWJV8s2amk84x8bMWflCT5/Z990u5vrpSery2NwTxx5mSs2puTI/v+ffS39tG3390pUDf+pDf7eOtVauKnul9+dj4cv94dAv0rrlMx9d3byRr2hVDz7266ubz06Oj5j8GvMP7oBRfri07JvzK9ednv3pWuO91x+Ya09emxBWZCbsq0qYR0+Njq/ljtwl16WL6KEvvx9cM8Kutvbe90wsmRhFsx6Ovlo1cdJXecroj66ecgW2XPFIv63fPdPe3vJ1wfLhrnOMWYQuHrpQTN8dGGYJx9YHe0qca0+89/sPF13NUv2ZYv9g8dhU5R7ft/f7jKbXGpUVz5Z8taHrEO9rElpfAP/AvZ9+NlutZh5n1k9OP9V750zb+2/0NLdhuW7cWFZQ9OP5O/oLCwr+A+PrJuI=

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

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

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

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

docs/cassettes/hierarchical_agent_teams_6b8badbf-d728-44bd-a2a7-5b4e587c92fe.msgpack.zlib

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

docs/cassettes/hierarchical_agent_teams_9860fd46-c24d-40a5-a6ba-e8fddcd43369.msgpack.zlib

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

docs/cassettes/introduction_03a09bfc-3d90-4e54-878f-22e3cb28a418.msgpack.zlib

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

docs/cassettes/introduction_11d5b934-6d8b-4f52-a3bc-b3daa7207e00.msgpack.zlib

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

docs/cassettes/introduction_35c8978e-c07d-4dd0-a97b-0ce3a723eea5.msgpack.zlib

@@ -0,0 +1 @@
+eNqFU81u00AQVq88xcqXSFWTtEl/UC4QBRqB2mK1iTggFE28U3sbe3e7u05jqh4oP3c/Q0KCqpafC7c+Ag8AT8O4aQQSRUiWVv5mZr/5vpk9nw3RWKHk0qWQDg0Ejn5sfj4zeJyidW+nCbpI8Yn/7KAzTo24jpzTtlGtghYVB0MRZ5VAJVWLYIJo0lc8+7l079SjcG+AmddgnhvGWdnfOqrbwfpOrb8h6v3u9v7Ibx9v7mV+q9t+GmR9b4V5xGhuKp5H4EqWAStJxbHEhGQ7IMO2AR09KDITGPUM2jR2lvJrhMz5exy1i4orgA9BBsiLbCGDOOXY4yoBIYuKFy8JxtGd8CIbpD1BQ+ghxBb/CBg46QWK7JLujqhIIES7CJzNIgROHr+/6Fo05WZIVfk3nZGpsnxrsq3WKnX6PjeDgPovP5aB4kKG+VX4SugVxvEwBofTeTgfL1eXL1pKSryZVn4xQNRliMUQP7XmfZV3UIYuyse1zc3LBdbJNOZfQOtYBFBUVo+skh/JR00zxzdT68Cl9nxC7Ph96WqWoLUk5mtHKbYLMmP7t/0uRL37i29tdWt6gIa2Kv8gQyFH/2GfPCJh+fW2ESustsoOUNNRW2drG436/cb6Bmvvdv6h9WbXXlPThqz6MTj1ODoQsdc49dAYRZPz/Bgka/pPWFroYLFIhGMGIYiQV5gfI1hkqQ4NqWGZSg3TRYUyrJgvPQZmU62VcQ9/b7p3dvYLLAw34A==

docs/cassettes/introduction_4527cf9a-b191-4bde-858a-e33a74a48c55.msgpack.zlib

@@ -0,0 +1 @@
+eNptVGtsFFUUbikxkgBNSDQBFC4bMFQ7++7utqJQFkEgpY9dVLSlvTtzd3e6s3OHmTtLl1J5iQYrxZEgojXGso9mKdAGCJJWRJCmxlKIEh4SScBYm9QgCERiLPXOdotF3B+bO/ec7zy+8527ORlBssJjMbuNFwmSIUvoh6JtTspojYoU8lYijEgQc7GyUo93ryrzl+cECZGUIpMJSrwRiiQoY4lnjSwOmyIWUxgpCgwgJebDXPTH7Pv1hjCsqyY4hETFUAQsZqs9HxhGvejNG/UGGQuIngyqgmQDtbKYliIS/aoChVHYh2QQjgIRhtF8Q0OVjsccEnQ7K0CVQ4yNCUI+pDJWGt5sMzv1KARjIZNAR+reBEZ4IVqtICizwWoZKapAlOpaBYs6gEMKK/OSToDuXAxG/AASA7yIAKaWML8OccCPZUDblWQUpF3xEZQPIMuqMiT6SeQAkVWFUMdMBiNYqSC/KqSBaykGRLEKREQ9CKYAZS1tMM22zj2APqwSQOPJlASAIvSfhlgqSvRWCWJV4IAPAThaHgXKUaPeAK+7VCtsEIUh7aDeINHRIJnwaaLrDWnP9Ok/rY6NpJckYBwCqpRmMSqlqVOIzIsBQ0MDvdOlwcuI08nNBK0a44p9tYgl1LWqIRlEkKMCa4oFsUK0jkckc5AShyTCIJHFHE2g7Q+s46V8wCG/QOlMUSmIKK1JLRVCSGKgQPlOjKC0dihJAs9C3W7Sx9iWkQ6j1/KoOaUrjKHCE4l2tHi0DlNZlCpcBGajzW60ttcxCoG8KFCJMgKkJSWktL1zrEGCbIjGYTLboyVGwAfG+mBFi5dAttTzUEidaS0O5bDDfmjsvayKVF9IS7rLHk2XMf6bzma0WI32jocCK1GR1eJ+KCio4wHJDyApuhs2xuxgzJZWqkuJKg1tSVA4UZXNMco+6u1JZvaypXT56OTeiy2ic9C+XCzz+cBqBh4kAX3LgKWgyOYqsrvAkhJvmztDu/d/ae/wylTkfkr9S6NjTrJBVQwhLuX+3wGnMq8Pw3NaFz1Xmy1ex8t268oQWqYqK2whe7lYUFDo8B2pY1gBqxxD6NOFmPT464h2GZidkPM7EXLaC212p8Xm5Ao4n9/qZJ2sFRVaC/dGeKilLEYLCGAcENBB92LGDenqMJ40JVpy0aoVxSVL3W2vMRXYh4nCeGFAi4lYRAkPkimtWiqdmgpVRgkKryhepR12sQ4rcro4J1tgcTj9VsazzN0+Ss+D9mO6ytNP5KbEyGadzk7MbHw8K/3LqawoabyyYOLQcwt3V3bN6sz75PqVk6vHvZAf37owr/hWz6129tun+Q8+fn949TNh98DSm7E/Z31u697INEUu7Z/hPDhoupO3Inl0qH9w0LzhRve1KzbHwO1v1HfPDJy4VHPBm21t7J/dNKlpmgs2VrVMuQeHzGXrTbml+5K5++7WbpkUebbv+qU35w97yP2Vxy5+fz1iGXd3j28jM37X1hx19dz4VOuOeTcKT7XN2XKup6a86LGZLcX2VmnmocJFa/rOR72rTjZmT+gSrn145Ni2XMKBj1wXn2w81bO3f+rhd/JuW2otA96m5u2p5k3+ud2Xazpdf5zZltPckru8dfpEe4nti1cSS/LWb4+Yfjhx/N6GPO7tvCVnbhrXLXtqcqWn9/XULz/1HdhzasrVKTstd3on/NVbOdRSd6Gs6Hjf9OSMgQXl08CE9qrY+GLYDM/277r56+xXd5bvKJ98LvRi+eTlXX8Hz1Umq/zWJwRtzm9d3NdfTfr5s61xVojHztccO764vnuu59ang883ws6r8xytp3/v2HF293eYDmR4OCerWssVo+Oysv4BX4fntA==

docs/cassettes/introduction_69071b02-c011-4b7f-90b1-8e89e032322d.msgpack.zlib

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

docs/cassettes/introduction_6b32914d-4d60-491f-8e11-1e6867e38ffd.msgpack.zlib

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

docs/cassettes/introduction_9f318020-ab7e-415b-a5e2-eddec6d9f3a6.msgpack.zlib

@@ -0,0 +1 @@
+eNptVG1sFEUYLh8JmGBSNEiMCQyXqIl0727vrh80ESlHW6i0FO6IIDaXud33bpfuzSw7s0eP0oiFSEBAF/n4Bwm93pFLKVRETZCIGqJYQqIESCGKMQFDqAl/NMoP6uz2ikW4H5d35/2c53ne6S1mwWI6JVMGdMLBwgoXH8zpLVqwyQbGdxQywDWq5ttXxeJ9tqWPvKxxbrL6QACbuh8TrlnU1BW/QjOBrBzIAGM4DSyfpGruxlSp25fBXQlOO4EwXz2Sg6FIFfJNRImTDd0+ixogLJ/NwPIJr0LFKIS7RytezSADsEV0kkYrMUk3W9jU/ChKbUNFOWojlSJGM4AsYCJO0RAlSOcoRS2UgTd8PR1uO6qC4ZZTDGyrIIUlDeudthQS0wTDwVq3KafUKM9DcMabh+OsbuQS43UTooFtcJbYyChxE1RgiqWbLl5ucAMq9weS1gkgKjwZfQuo3igCHdMCTYCgZ6EKYUWxLcxdi6iIWzbjIrDcwY/WMkjZhpe4WeR49yQgIjgVCWwzWMgjx6UK4SS1ORL1LIEZgqz4FyVWEFOcMs3DKQkIT4wnEq2c372A7oYkmKJBBosbdPtMwSRYXPd46fZ5kZ71v6tOruSOZFDaiWzTQzFnetAxbgnGfD094sxVkm6B6oJbLtoxKZQmN4LCRWhHT1EDrAo97strlHFn6AmFnRTAgcklIApVRQPnRHqLblYhFVKGgLMklEPAk7BT6gQwJWwIvAvjWc4pbJqGrmDXH3BpHCgrTXJnedJdcgUpCZ0S7nzeMDFHoD0nFoKgoD8c8YdOdUmMY50YQtGSIQTqFEzPf3ayw8RKp6gjlZfNKYwnD06Ooczpb8XKqthjJV2knX5sZWoipyefWzYR+gKnGG1/sl3Z+V+7sF8O+SNDjxVmOaI4/SlsMBh6BPKjlJLYjbAUrJGC8nGhS1MoDbYXRDq3WW9eoA+Xvi+W1/jYqjcnmNuTXyZ4cM41WXoVCgVRDEzkbhmSq+vDdfWRRai5NT4QLcMefyrsQ3FLiDwloG+coLmoaDbpBLUUfSrBpfJjJemq86WwE0F53Vq7sa29q3qpFkvJjct5XFkKa94+0yUpBrVViYuXDiSP/i7ujCBVVuVaqE7Kak0kGApFksIMYqVOTtXVhqEO92V17JRkv4zSlKYNOBltkqJYrI4U8yBxisvWtzW0rogOrJPW0CTlTIrjtJMnlEAhBpaA1Sl5rYVQLSiI9DUN651P65SaENQuilSDUpPCoRop1hI9NQHPo+vnXZV7L+p7hfHNujBl1vwPZlZ4v2nxD4fJN8HKxrHbg3sPVO7v3fzzkrlVux8cO/HacGuhMjn669DCxtUPz7WUWiA3n/Fic0fDb5dmHMwP3/xi+Kez++a1Xbj3EK6e67mW2DBzx2D/UOOlB0sq71/e835qcJH2EjKzc15cfqDpu92pkdHj9165fOfiVke9+Oz0lvS0kYp/fhmbvZ01Nc5zruxb3Xwwf/bOj7cCR49c+XPx0Z31ibmHt57u3Xb197tt714vxFbeONx8e1ffMwNto6PLP8nM+uh1v7N1xq4Tn+3ce/2P2d/eX3D+6zM/fDzv5lvPF7bdfe7ioel6nzx105b1f321bs470UMLTt9eev7C/VsL9+O/p1RUjI1Nq1j8wrX5q4X9L+rYruU=

docs/cassettes/introduction_9fc99c7e-b61d-4aec-9c62-042798185ec3.msgpack.zlib

@@ -0,0 +1 @@
+eNptVG1sFEUYbsUE00gkMUFDSpicImq6d7f3RSkolCuQ0pZ+3BGBBs653bnb5fZm1pnZ0qOpgRaspCiuionBAJHrHR4t0AIxBgwJKhpCVEIk4heJGEH8AeGP/lBxdnvFItyPy+y838/zvNNX7EKU6QRXDuuYIwoVLj6Y3Vek6CULMb61kEVcI2q+rTUW329R/dIcjXOT1fl80NS9EHONElNXvArJ+rpkXxYxBtOI5ZNEzX33gNTjycLuBCcZhJmnDsj+QKgGeCa8xE1nj4cSA4mTx2KIeoRVIaIVzJ2rxrlZYCBIsY7ToBni9HIKTc0LosQyVJAjFlAJYCSLAEVM+CkaIBjoHKQIBVm0yNO7zilHVGQ46RQDWiqSgpIG9YwlBUQ3/qB/nlOUE2KU+8Ew6/bDYZdu5BLjeROigGVwltjACHYCVMQUqpsOXo5zPSjXRzitYwSIsGT1TUh1WxHomBRpAgS9C9UAqCgWhdw5YRVwajEuHMsVvGAVQynLcAM3ihh3ToyEBycigG1EFLjkOFQBmCQWByIfFZgB1CX+RYpGbIpbprk4JRGAE+2JQJrzOgPojkuCKRrKQjFBj8cUTCLKdZeXHo/r6Z7+N+rkTE5LBiEZYJkuijnThY5xKhjz9PaKO0dJOkWqA2456bpJriS5ASlcuK7rLWoIqkKPr+c1wrg9eo/CDgvgkMklhBWiigL2SHqTbtYAFaUMAWdJKAcjV8J2KYOQKUFD4F0Yj7KPQNM0dAU6dp9D43BZaZLTy73mkiNISegUc/vD+ok+fG05sRAY+L3BkDdwpFtiHOrYEIqWDCFQu2C69hOTDSZUMiKPVF42uzAefGiyD2H2UAtUWmN3pXSQtocgzUZCRyffUwsLfSG7GG27t1zZ+F+5oFcOeEOjdyVmOazYQyloMDR6B+Q7ISWxG0HJH5H88gGhS1MoDfUXRDi3WF9eoI/OfVEsr/H7rU0TzO3INwge7I+XUb0GBPwghkzgbBmQw3XB2rpwGCxviQ9Hy7DH7wv7aJwKkacE9EsnaC4qmoUzSC1F70twqfxYSbpqnxTnhF+OZTrWRuPtgWWB7o6OlQ31dMnSLNKOd0uKQSxV4uKlQ5JLfze3L4FIMiynQnJtbQrCSFhO+tVwRAlDMVSwNjkvlNrfpUO7JHtlkCYkbaDD0WVSFIrVkWIuJHaxYc3K+pbG6PBqqYMkCWdSHKbtPCYYFWKICljtkltaCJWiggjvqF9jH6tVIgE0LwlDol4gLMtSbEX0yAQ8d8bPOyp3X9QthfHN+qxSnj34UIX7mxJ/o7Ppk8XTt90+G/iqs3H3iuvPz/C19XtmPPtqTVPgKT2y4Lf1nz5+6zJ64qc9r7w7/+qVczu+fhvsY7ua37n6rTHw40Xj5jPPVc8e++fW/mPzzZvRne3bvvygakv/nFlTz350JocWmtcONEx7oGpkyfZB3n6wMG1w1djaufqblQN9O5ZfqV+483LDzhvnFzxW+cfIzNoL19YMND96fFjes/pQs6WsShx9YczYZ5558edTD3uk/sHRXzuTs9WxHxK7Bz8/Edv1TedbV3/f1Drw/cFZpr+0u/f6yPl+fsBobxr0ajd+OW9vf/LC1EeSW2OLF2zevHe6v8VX/V5x/dp4+9++0yfN7iqt6kHYd7H69F8R+WU4VJzx2hQbX6x++s9TR41wy16Bze3bUyquh2cu2lVZUfEvih+1Ig==

docs/cassettes/introduction_acbec099-e5d2-497f-929e-c548d7bcbf77.msgpack.zlib

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

docs/cassettes/introduction_c1955d79-a1e4-47d0-ba79-b45bd5752a23.msgpack.zlib

@@ -0,0 +1 @@
+eNqNVVtsFFUYbmm4mhBilGiCelwQ+tDZ7q3XmOiyLaUQoNICgpRydubszrSz5wxzziy7NE2kqBggmFEiPJgYod3ipgJFDQ/e0kgNiMEIVNImQiJGwFswpkQRrf/MbkuRJroPm7Pn/Nfv+/5/O3uSxOQao4W9GhXExLKAH9zu7DHJFotw8UImQYTKlK6GVY1NhyxTG3pCFcLg1aWl2NC8mArVZIYme2WWKE36SxOEcxwnvCvKlPRw0cV2TwKnWgRrI5R7qpHfFwiVIM+YFdw81+4xmU7g5LE4MT3wKjMohQrnqh5RQhTEWYIgkjKIKVDc0hRMZYJizERRS9MVjcaRUDWOwvUIolLhRRFm6QpKMwvl+0CYc42LcccEecrT0eyUwhSiO6lkHVsKkYKSirU2SwpApb6gr8IpSDCm52ulOOHWKnBS09MtnGBTVltMwi1d8JZWzqjjoBAum5rhYOkYh1HODhEa1yhBDF4S2jZozCkFkDNMogJAWpKUICzLlomFc6IKEqbFBRjmM3jRGk5ilu46bgUft0cXI8HAgW8lJnIbdmhEOMosgSCeCaggkoRvCFFPDbjlqotRlCA8Vh44mmmv04DmmLRwWSUJDB20ewxgGdDXXM7aPa6le/pXqxMjOSXpjLUhy3BRTBsudFyYwJinowPuHHY0kygOuPmgzRNMWbSVyMI1vQP96hyj4XFCJ0G8lstYBxBBFwQApo7KsfOYgymvJRfNnHS0mIskNgmyKI7qxDV0UyAFKpSFnkaAOdg5IR2ponzxHHHLMBhIM0rSjLqyMxHET2jcGS3u3Ug30ibmOOWSxSzqzlkJhNBxejziIo4W5fW6CDTv3udVL0PRwEFSU3I9mVpcvTML/4uzfGT3/J9cjBlPykZzR49KsAKY7u1SGRd23z274CjImBhCIlRmzoDa78S3aUYJUkjM4SULnFDigmBn2wgxJKyD+jM5L/sYNgxdk13GSp2h6s3vBMmp5d7nrIOe5M6+fSI8VkdpQxpWF0U+bzDkDRxLSSAXjeqweyQdQ0kZw33/YOKDgeU2iCPl16KdyTkfmWjDuN29AsurGu8K6eje7sZmojz07sR706Iw7cTuiTTcmy7/eCdd0OsPeEN9dwXmaSrb3TGsc9I3DvK4SxY2VVDylUs+/2EQowGCIzsy4C4s3tkF6JMvTvXkF+7BVcvHmNvTVQM82B8tMbUSFPChRmIgZ+chf1l1sKra50d1K5p6I3nYmyaFva/JhJUTA+hrx2jukVWLthElG5mU4GxeV5Km2B/CucXnX7uydiXfum5Dqm5L7TMN4TJ1eXRtMvx+SpJ1ZimSgP8kIrn0p4Q9BOtRqaoI+CsCAVxGAkG5SsEkJpdVEqVKDspy6FBSw3bW7/WjOGNxnRyNLJEiGIZCanQhsXtq1q8Mr6iP9D4rrWZRJrjUhON2F2WUZBqJCbDaWTc1CNUkGXBfHV5vv1cplwdIhRKrwLjKX1YRkhqXRY6NwTPefpejcve/b3smN1sDheix3TMK3E9RU8OZ1k99c24/2Bfvrnxl4duULkfbNy0uDnU/NDBc6Tn+XWpdaOD3y7vfmDt85exPTx6Y3Vs4tWxNbfmm16++eJlduvnl/isj1ok3r/78Q1/hzNuDm28t9jQ/vlTdsfz5hcdPDgeXHt4Rnj5rWc+h/q+EOHdzXt1reuBMZmjKgn39wW3TRi79VW3OOPLyvpKdj17fC0EvvDV04Me5I7/8Zny788/B8/c9Eu68aJ1L/Hq/XTl6unR60eWaaYPh9vnh/g2pmvnFF4pvDG8+c3DX1wu2V760dt5B67Nby26cfvXUxcXrrv0x+9bfkSlb1F1zy6aOfnL96YZZ9f2f111dcBI/PPhN6wPzzl6beUGv2j/HMzrw/fmPR6cVFIyOFhUUd4/sSRUWFPwDJ8hQ8Q==

docs/cassettes/introduction_dba1b168-f8e0-496d-9bd6-37198fb4776e.msgpack.zlib

@@ -0,0 +1 @@
+eNptVG1sFEUYLiVIS/wgJZiKoOOlxADd6320vWtjE8qVWlrKlV5FiTbn3O7c3fb2drYzs22P2hgqYgBDWGtA+GHEHnfkUqVVhFiqVZuqDYQYQ5TyA6EiIQSDRIl/EJzdXrEI9+MyO+/zfj3v805vugMRKmN1zoCsMkSgyPgHNXrTBLXriLJtqThiUSwlm/yBln6dyJPLo4xptLKkBGqyHaosSrAmi3YRx0s6nCVxRCmMIJoMYSlxLnd+ty0Ou4IMx5BKbZXA6XCVFgPbDIrfvNxtI1hB/GTTKSI2bhUxL0Vl5lWdDFgUEfQMaEwAFcYRkCl4UVYUu62n1QyEJaSYQFGBuoQEtxCFckwXXDyPw+3wmOEYxko2kxnBRDPYISuJIEWQiNEgQVRXGA22UayaDhKiIpE1kwkTXA2mcQCpEVlFAHNLXN6CJBDGBPC+NYKivD25AxUDKIo6gcw8qRJgRKeMA7MZ7OAFisK6Yjl2ch+QwDpQEUcwzB1oJyLAot0cAoAhrDPA4xHOBkAd/J+HWKdq/JZGsa5IIIQAnCmPO5KE3WxANiFBKkZRHPIOum0anxEiTLYY77ZZSOv0v1ZnRzJLUjCOAV2zWExoFnWUEVmN2Hp6+J2pEZkgySQ3G7R1FhSH2pDIOLS1Jx1FUOJK252MYsqMofu0c4QThzQmIFXEEk9gfBTZImvFQEJhhdOZ4ZpQkSVOIxNDSBOgwvlOTXsZg1DTFFmEpr3EHONAVkOCWcv95owpNYErUGXG8eqZOkqaElzqKnDY3aV212CXQBmUVYVrVVAgLymlWfYTsw0aFGM8jpBdIyM17fzxbAymxqFGKPoD94Q0mTYOQRIvL/109j3RVa4vZKR9Tfenyxr/S+e2O1320qF7AtOEKhqHwlChaOguyXddMnw33IKjXHA4D3Ndalxp6I0Ud2c67U1y9tGp79PZBf3Q3zAzubeTNXwOxhe1RC4GLgcIIA2YWwacZZVub2VpOXi+sWXAl6W95YG0D7UQLvIwp37tzJjTYlRXY0jK+B444Ez2GRJkyRjh56DDubGuq72ZeFDdRuKSwr665nbPhrX1n3UJooJ1SWD8DUOCNf4uZkwC6HWGoATL3KUVHuh0eaHT4xAr3C5P2CF6Q1Kov0OGRsZpd4IIxhEFHfHVCj7IV0cIWJQY6ZrNG6ob1/kGXhKacQgzKrTAiJFUsYpSAUQ4rUbGSs2FSlCKuzdXbzaOesVyF/J43d6QWF7uCbuEQL1vcIaeu+0nTZVbb+XW1PRmjc+penpXXo71m7t+j98/5nh4fHTnDbRPuXr7g2r1BFi5emr7wjWBvQfK2q6yHWNXUj2dZxYsfLbhetWdW5fcwwvKjsmjwmX/jZrY8MSfY/9MvP/U71M31b/3bDz417JHVtRPXMtf/O2F+V8nL71T+HjL2e07n2s7ev7SztRJOf5KX3pXaGjl3vEli899tab48C+nR2sOHoGdS5c07C96NZJftLqh6Ie3Bi6MJ16f91ty3tjgiovXV56tqz3c2/rYk3srt5+enHxvYMXudw+85mm6cCX50FjVUtfy9q2LtuWFmvtqR8uqzlzuC/9xbaIo158rVI9dzNO9a/J/clzL++a74NwG98jIqvUFw/Givtz+2qm2VRWu24U7Ht1/tqDt9PlVp35ddPOJZZ2bjxUsmdq25fMvNxV+cuvnTcf3nfRwnu7cmZtT+OObBf1zcnL+BdUbsRw=

docs/cassettes/introduction_effb95d9-b7d5-40c5-9253-253d193b23b2.msgpack.zlib

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

docs/cassettes/introduction_f5447778-53d7-47f3-801b-f47bcf2185a0.msgpack.zlib

@@ -0,0 +1 @@
+eNptlVtsFFUYgAs1SIiKRhNIg3JYgg1hZ7u3dpcaYkqhtZSW0hawIaQ5O/PvzrCzc8Y5Z7bdNg3h9uCtZPAJTLyx3YVtkTbYSBQeDHKJNFEf0EDiJb54edCImBgV8Z/ptpTLJt2cnv/+/f9/dl8xCxbXmDFvTDMEWFQW+A939hUteMkGLg4UMiBUpuQ7tnR1H7Mt7doqVQiT19fUUFMLUEOoFjM1OSCzTE02VJMBzmkKeD7BlNz1yicHfRna3ytYGgzuqyehYDjqJ74ZLbzZOeizmA548tkcLB9KZYapGMK9ekEjQgULVpC2HDFoBojGyQ5N1wO+IT+5Y0o517jAbO6xbxHVnBiaDEQwkgEQJMdsv+dhBWmpzhBqkIYWMmtOZAuoAIUkcqRhtjZP003D9aKCbrpeSJ8mVLTPEQ+Ui40wiwjK09yTZ2iOqDQLAdKhA+VAdAyPFaQN1kdU/GshMoZPAGHJ2QxkuKeyB0DphAxkEmCRzDST531Du1yoTAHdlcs6tRWQIpJKtbQthZF5MBKMuV4EY3qZumvpagua1fRcLwdqyWqvBdzWBe/dzZnhGijAZUsz3fJc5QYyrUfASGkGZo6SjDaAwJJYO86AaYGKrday4CdUlm0LaeLJUIiwbO6SLUcIkG0ckrbuGfahjcfMANRAyNTgfVjgHbI0wWzsjm1ZCIFAFr/RRYth4i1Xma0rLkg6kx4aWrmAW4DmqvRyWYUMxQoGfSb2FCyhedM36PM0vdM9pc715KakM5YmtulRzJkeOi4szUj5hrBhPndfNAsUF27Z6a45qiyxG2SBqruGiipQBbduOK8yLpyJ+/boFIIDU0hgyEzBAM7J1IBm+okCSR1xlnAUDPAW1SmlAUyJ6si7MG3ljFPT1DWZuvIat41j5dGR3FzuF5fcCZNwGw3hfDg78zUdOVx7gwQDkWggPN4v4XBqho57K+kUUyqYnvzjuQKTymn0I5WfFKcwbfz+XB3GnZE2Km/pusulS9oZoVamLnp67r1lGzhf4BQbO+4PVxbeCRcJhMKB6MRdjnnOkJ2RJNU5TMxCnjUp4W5EpGCdFAwdx7k0cdJgfwHNhc335ZE+TF0ulh+r97a0znTutfwG7INzrsnS/CQcJF1gEnfLSKi2PhKvj8ZIc1v3WGMZe/cDsU90WzjkSUS/cabNRVm1jTQopcYHNrhUfpIlTXHO4rk3GOpp7m5vGkjVsr6OtvYd2zqbG8T2rU2T/ZKsM1uRBL7nIHnt7xfONQJKMoYLFg/B2nhCjimRcDgehXAsWpusTUZicCyrUacUCoRIirGUDqcam6RGiqsjdXlInOKGnvaGtpbGsRelTpZggkvdNOXkDWZAoQssxOqUvNA4qBYU0Lyzocf5IC7XhSEWXxuNJ5S6WDIsdW1qHJ/BM1t+3p1y73djb2F6sz79a/mrCyu8T+XmQ6H0+eBTB26/MtC6ZCSeJRt3XnzkyKbV2uqmieXDVT2df771zonf99Q8Jon6M//8+v2zZ55ZsHJxZvLbR4uXbt66ORDPL04dyn69jn2+U71c++X6J04/vbBq7d8XxqeGLyzYe3Hp4I3gT2eldSePXr32UWvP1W3nThzd3fNz4vFF8/+ouyUtGpK+eXPpspcnr49uXvl69We/VLVu/2Q4v2x0yY+39l+/sm7N6OHqK6veOHy8ydfzxXNTv1X5Q5NH/JcqKhcNrVn18L8LNr99cH1z8N3+U1uNPVMPLel0tv9wcP55/ehkk//Gd6Ojuf/mVVTcvl1ZcXHrVwcCeP4fYwrmXA==

docs/cassettes/introduction_faa345c6-38a2-42e8-9035-9cf56f7bb5b1.msgpack.zlib

@@ -0,0 +1 @@
+eNptVHtsFEUcbqlIMRHrg4iJCePxMIbu9Z5taYmkHKVQBWqvGtpSm7ndX2+3t7ez7MxeezRHIhBDrDEuQlR8BOj1To4irVBJgCIJwYCYqEGJkCAJjwASEzRqkBBwdnvFItwfl9nfe77v+83abAIMqhCtcEDRGBhYZPyDWmuzBqwygbL1mTgwmUjphuXhpj7TUE7PkhnTaVVZGdYVN9aYbBBdEd0iiZclvGVxoBRHgaYjREqemSD0uOK4u52RGGjUVYW8Hl+gFLnGoriltcdlEBX4yWVSMFzcKxI+isZs05Ln40gFbGiKFkUvYy1aZ2BddqMQMVUJJYmJJIIoiQMygPI4UUZEQwpDHcRAcZjvSrXZ7YgEql1OVLEpgeAXZKzETMHHp/H4PRV2U0aImp9Hw3FnHoYTippsH63bzhuYKqPtnZRodoIEVDQU3cbLDq5B+f6gRRUNEOGeuLIaJGcUjo5ugMxBUBJQirAomgZm9kmTEDNMynhgvoMbvUqhw1SdxC6e49xTAx7BCE+gXWAghxybKoQjxGSI1zM4ZggS/J+XWKLp3EplB6cIIDw2Hk80km77Aood0k5FGeKY36DHpXMmwWCKw0uPy4l0Tv+76vhK9kgqITFk6g6KSd2BjjKDM+ZKpbjNVpJigGSDmy/aNi6URDpBZDy0LZWVAUtcj++kZUKZNXSfwnZz4EBnAmgikXgDa1d0taKXIgk6VA5njitHA0fCVi4GoAtY5XhnRrOsQazrqiJi219m0ziQV5pgz3K/O2cLUuA61Zi1r2ZsjrKGJF8IDXnc/oDbN9gtUIYVTeWKFlQuUCujO/4D4x06FmO8jpBfNiszmvz5+BhCrf6lWFwevqekjbTVj414eWDPeLthalxfYGVDDfe3yzv/a+d3e33uwNA9hWlSE63+DqxSGLoL8t2UHN8Nv+ApFzzez7guda40WJfh6cyka9Mcffj2WDa/xtuXvzTG3NvphZwHa2SRoZQinweFQUf2liFvsMpfWRUMoLqlTQOhPOxND4R9qMngIu/g0NeO0ZwVZVOLgZQLPZDgXP6xEhTJOsjP7R5vY7x+RcMymnhFk8XaRjm8IEKa6xYPdwuiSkxJYPylA8Ghv5tZp5EnGJQiXm9FZVDqkILlWJR8QSkYFIOecv9csXxuX0LBVs7r9qIoIVEVdocWCSHMV0cIO5BY2YXNy2qWLgkNrBAaSYQwKjThqJXWiAaZMBgcVivntOZCNSDD0xtrmq29lWK5DyoivggEyn1Br1cI14cGx+C5e/20rXLnRX0jM7pZRwsrp/cWFzi/oqaGE51HPCW3pprf1a86P9O9v3/b5E3PLtg6ssm1fmRN4IuLi3fu/frGud6VN6uE6mp/9YGiwMRiOTXrveTNW2zeqeyk1pX7hudUBOb/tmPSlB+7pjVfGcmVVFbunLH1IJn3QujwtuGJnSXvxqY+8nH/npbgZU/rzF7YOPsZ/diu5wIPnYcbiZm3NpzZUfzz9hk/TTt7brDoiZhlXqm/1pL5oO7SH1uaj0z5pqknu3/L5lNDv7zZOu2f3X3DLQ9PDy17/+iLx6RDzZcu/3X79u8p3KVsBvjyWm9Q9+Q+Yb+eufL6ml3WlNT3Fy99tG921Yfukg2F7sK2xyas8R2uPGRcl6qvNtT+/VXxycMXZm09/vj6yS20+OSTR6/DnOOf/tBdcvXsxnWP/vn0idcu3JhcUHDnTlFB7VtTn+orLCj4FyMpvOg=

docs/cassettes/langgraph_adaptive_rag_29acc541-d726-4b75-84d1-a215845fe88a.msgpack.zlib

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

docs/cassettes/langgraph_adaptive_rag_4dec9d98-f3dc-4b7f-abc0-9d01c754f2be.msgpack.zlib

@@ -0,0 +1 @@
+eNrtWn9wHFUdb+2ojIzaP0RHwWHdqcqP7GXvdu9yd52IMU3btE2TNqE/Keu73Xd32+ztbvbtXnKJQa2oM4Ajx2+tIpA0KbE/qC0UKFiYAUWBAQsKYYSqCP4YEXVAHQTx+97uJnvpQUNbRZSbaXP7vu993/d9f36++27LeBk7RLfMuTt008UOUl14IJdvGXdwn4eJe+FYCbtFSxtZ0tYz4jn65IKi69ok29iIbD1GSrpbjBnILKhFpJsx1So16mbeGs1ZWuWu8SJGGrC/cOJcgh2hpYBNt7qPzmbrBLvSKMbisXgiubtFVbHtCm2mamm6WajuLAzqdgOn4byBXDzmk6s3Ids2dBVRGRs3E8ucaLVMEzOZqxO9GNsCMvQy3u5gYsMx8JfGiItcj2wZBb74gfvGS5gQVMA3dC4Phbv4TsqcEAFYuY5lCG0DtkWwsNQnV68/a4cKFBBdcCs2PlKGO2asbzEMq1/oYFqjy+vTp9mPtxiu0F1Wq5OxotTMZ2VZ4hdyJdScSGYSoig2FCUhkalD2NUayLUCmwW3WB2Rk8mRNTqqToBOuYJlFQx8oO7mnY5e0M3qdZNcXXKrgzXgqyODVEddx8O3zJjWgQaoNasjKVHcqSK1iAXVJ1W3m5bARpgLfBH074A9n5j7wyE+8DQ+y4uxppgk8g08KBKDmRQ8YOsOU6ni6iXMZ03PMBr4HHLVogLrwREV2CGvF/jsEE9UZGDFs5U+og9iBXYoFLDDZ+NUW9NU0y06oGWiGDq4G5BTIVGz+k3FxCXbrUyvloFK2YWzGa+pASVXcTHhswkx0xRPJsThBl43wblMFSvgowVCBQMHhxBysYJ0BaLHqSjYRDkDa3yWqrGBt5yCooJQ7KSaTgJiHjQNVFK0+hXXNRRPDxe4EJFwQh07iuYFGtJQhe1mWGaBejswkJmwRctxg4G4DAISjBzQ3wwZ+i2nl9iULVEtGytUJt0s6+x4oSSSQlzLgUipXT08fERiGO3q7PYzw1lHywyOZ5JGZlPmHE98+IwhHmINlM1tHOJ12IPjE1oONaXSSSGZwmlBzotIyGhNoiAmNDWf0zLpZDLPN3A8qN5xA2eBVWJCFsSMkBB74smslM4mE7FMskmSxbNFMSuKdAU2tXA+8y4YGQD1wuMQD5IFJPAurZeyjKYptqHWq0x5MMcHiYtSDD3nIKcSLmLnhXhwMCXakL/yllOi1BJSO7uFuBxLCsgppWT6v5CSc+BuMHNaBt6ugGZNtryi6CXbwCWIR2Z9Sm7tmqIHi6KSSSBXTGaChdLUCi7FxFoqlXXmlETkZEfShoEI5kcacgMF4rJOpyi+FSH+1V7bgpLS3ByPga5EIZMWCmktKSdkMS9ouuNW+GHKBjuO5URsUoaTEt8jTOSrg9mayjNrcw9vorrBeexgGqB4AFEl+sIFG9kIaK4CCqwZdlkocxspAz/43phfapbrYg2CSqM5xRdVzDBBpXQy4Uu5YbbcLM+1PaaOQDwCaZiqOVQNFEjkGUw54dBqz2Qh203jFE5PaboZsBniWfAGxlxbtLh+3TA4t4i5z0C2IJzmoLzL5XWHuJxuMsLKxSv84XOY3anGaCX07Qz+Q0fD8JUTGKm5OBZwKhMX4Ckt5OSkKmjxfErN5JHUpKVmHb6Zpvrh+xrz05KUisyfCu4T4Kg14Xn8KYItemtnh3qxCyAPMAOUTI1pyVDhT5zGUegtAMmgiqhQWZhT0mkbp3diJ3IsqMqEfoUxdvJW+NvFhnugYlM4yNPg7O1HTsF3aebdShnB7uD3LHyn3XwTS1UM9QVp5QTJ1V0hLi51+KxfX0B/9YlQSsAJvr1hlbCMFk6HjddbHgc5kEMmB/ALOy6HXM6BjAN4i0OcB9bkQi1yrgVDZUylpMAAc5bD9eMc50OM2HkmB58eSBbRORQTwhEgqViqR32UcA6m22uMH20HSAPnH4kDDKubGFO02AAyaRzSqNPRExggmYvUXhLsA90ES0zRvSCKpqQlnMUyF51m2bpKYlwnPDr9OmAbejAquhCIzkfUotBYRNRQfF7wkSuL/TC1ztD58DDLfCfIn5Z6JWS+ddypNsKijjUUUoaPT7ebouQ6WWD4OOHCdHlhZgyXQ6E5+uJIrTkGrDFrNBGiEUitfVlIN3Y2zr/5yCR25FLQ5YbZ1v5pUDMUfA/KdDRJBz3324mqJlEhTdPpQmQo09HJ0EnwwkOJgp3hSF4grFr5nh7R7RtGgMclRJGmOAgYBh5mAWXrBP2/EcwGyTCCZjUp1aQilBIkLZcUZFmShVxaygnppJSU5ExaA6+eLZpNp+TE7JpRaMYt//2SAokDlfyjliwNG5R9wXYFCUCi6zk5SxADhMnIU7qsPweyLkYUa/pdPug5LB6gXfriwnPoajEmwtiUWiwbm0gXwjIFXmxH2iXLMoKIDefnPZO9kKOTp75nIwl2NYQuXkVfj7C0hInq6HZoRUaMRLVToSFILVeywIoQlriMTJej7kUsz1ExCwymKOxCHIYVkiYKHfuP05P9x9otl+hQRI5IJGrRslhcslSDOd2l36dTCU0sNZkm5tvVK7GEHSHQcVin+Ov8/B1GZVAH/ejp83QH+wU7InF0vpXbDHxZcQwObRhgdmoFRYXvJGJcf7Bo6cGpj8U+DOGAB7Bk5bc+0+anJP8NHX1NFrhSTbNlEAUsUdaDiuN7EusuiDIbh52aFuk33YBQz2f/K5q7/4v3P/+e7o+a17c4Q6fT/kILQSc8tbTPRKazcaN6ruLzVpCtK724Ul9iglUHuxFhO7vaVra0Ky1d7crytvU8A6glNKDALMfPNYkwq87EroH0x4lZI0XkPws7E/+VsJOqY8Nsi/SxvEuLWK4WeETB6jG+UiCQnkpMsilmM98qzHT2t0Fx3e59BsQ95qa8vkWiffnrGORYkPQMXDy8adNMTGoYJYqXw8vKr/ynb1J3hHeMPXXvPmdeQY6mxGTTa9y+Pjh3Z3j9uqfHsrgOZFa41f5lEgkPeNH/zG3sDW/GZWzNpetkE4W6EMPQNvAdMLtoVDjP1EHjHMvkBKIJrMGxC05IIyqGrTR+1nd8fg1lV3vleCMt3o3wHaoQC2P/jm/ebW939rNJYmDJE92nhyypGn24cJQeMmwHX7+vOKKLrAevTkzz8XaD+SY2mFNF52ujRdBMdVdtyO9GfqHB9QvNhFq3noyh16g/R0nrE1R3AvLrno/IGv0uiIvH5KaYeNOAQGikGzQ10sJYHfO7qANRgg0hDEyEoKGpjvmLd0XnWKS6rYN2ajUsqWar21jbtjc6HjRg1fGgKTtQhzi9nd+b7alhTCqmWt3GgumN/G7pqTkfGl0Eiq7eudjRG7iEyHVjm6MQmQsaBolb0tFzlAK+p8dBJoEmYhowjKtFz+zF2msggjuRX36CH/wI2C/QgVTVHeuEoKYL7Yv2Bu+OLKeATH2QbVu9cQpz7QvIEEyUJWwulEh1RBKTuwJKqLgJOJcoQP8uxm+jLq2Cn1DBbctxIYuqUJrcSnWyAZox6iTN8WQySYvyQsiMquFpuNvLLbJKtBIshGyPDQtptw8I9Lc6rPgJ/v9B2QMHoD8lEm89coZr9WKTVLcnRf/z/egUB9Md6DGmGI1m4HNH/UkhL5nOyYjS7bXTCI4INJIqkVuPpAcsbhDJjoFwsqBr1ckF8KBooqymcwlVFuNJOaWm02k5raoSlPl4PJHJS7tbFwut7Ndb3czbquOL1q9s6WhvnegG3q2W1avjy56YO09R1LySKzWvKq3rXTE4kFrVs8RxCn3d0mbcVmpf3tXVqsa1tXZpsK0tJ6ny6nMREeJNiVRaTjVJksBevcTiwjo7n9H1lhVL+wY7pY7C0qJibdhAVi5ZvTadyRnQURfT63s3LO5db6Ke7taU2YXWqpXEoNeyqH2NZtux8krL3LA8vWJtT6XY2rWoNVa21fwqsCdyi82NCzn2IzJMmoN4ECAeBBoNqawYRsNCwAFU/c2x2mS2kFsKuKbTNCoLIYzAnTD8hXzfrbu4GbbFk1eADryyrjWvybX2OV0ZrWfVOtLheh1dqwZbUm1WwSoXESkszxS6lyQV2ejWjEJECeCOghjoISXKaeY806Ifo1S3rBOi4S10+i/qquOmRUw9nx/rxg6EUHVCNSxPg7zs4DGw+eqW9dV9aTWVwE25eFrLJ1NNOfCBZa03hdymksEoTerjCDAxAUy8txYSQ/s9A3LeO/fg6RefNId95sG/V191Vx+2nhDnX/CQgp6UetrPfPiZnUOPn3FoNL7v0OYV1adPu3vr0xf/4f41F/398PgCuX3V1e++//bGw+8//GR8/jvcd+2Zc/PVOy46dMnzn7pP3PbgYzePP/Pc/eoLv7sg/vmBsRdfOvNz5929Pd/10smnHPzerg+csq3lZ9rGdZkrLrl5s3zw2iefeuDZy9vnfeCK62/UKz96+kc/dR+4crl+2uLHHpFI54brv7ru5ZMunP+rx7/lLd76S+ke/rQ717znhfOfPanvb5fP/8V9j55y6VO9Dx1KXDLYVcX7PGPjh6U519y3YNlHHjl1/+E++/lTP/619tTk8peeuQC97OxtOH3N5/8y/vXvHGy8wf7FY8tO//EnHt71vYneh+c8//s/f/kb8z+Lf2IfXHXvrRMPfzT2+Ge+4FbOve6ZbOa0/Ze2X3XtWeP2yX/+4D9z3xy4YuVz++0tTb/u/tNTr/zmOuF9/Vde/ezPd5NXHn3vXV3nZ5e90nYOGt/513/cc/0LDx64S7pyZ/9zj6Q//WK+3JU9a9nKay4Y2fnOka3rv/vuV8wXf/vyJfE98rxD7l/OWX3Zx5Y/+cD+jTemrrulsnt++cythS3nDPyAn9S3jpz97T9e9cn0O19lVpo3Z396820LwWT/AmuuSB0=

docs/cassettes/langgraph_adaptive_rag_9d75f1d7-a47a-4577-bb0d-84b504b0867e.msgpack.zlib

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

docs/cassettes/langgraph_adaptive_rag_ded99680-437a-4c9d-b860-619c88949d84.msgpack.zlib

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

docs/cassettes/langgraph_adaptive_rag_local_830ba5f7-9c8d-4c01-83b1-e4d51d40d48f.msgpack.zlib

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

docs/cassettes/langgraph_adaptive_rag_local_aeb8b373-0289-4dec-bd4b-8b2701200301.msgpack.zlib

@@ -0,0 +1 @@
+eNrtVV9vG0UQV8UXWa2QkJDPPttnmxzKQxRFFNGoIFok1Ean9d7c3TZ3u9fdvdhu5AdC33i6fgIgUVJFLfCAeAEk3uCBLxA+DbN3dv+EoFZ9BUvWnWd2fvOb2d+Mj84OQBuh5LUnQlrQjFv8YR4dnWm4X4GxD08LsJmKjz/YuXVcaXHxdmZtacJej5Wiawphs27OZMozJmSXq6InZKJOpipe/HaWAYsR/uH5bQPa20pB2vpHd7qJ88pFz+/2u/3B6PstzqG03o7kKhYyrZ+mD0TZITEkObNw2rrrH1hZ5oIzx7F3zyh5vq2khIZzfb4PUHosFwfwWIMpsQz48tRYZitzdIK48OcfZwUYw1L49uZHa3Jf/ezAjfEQymqVe1t5rmbeTS1SIeuvf7nSe72Nrb959/gzwepzLIKkSqU5XJArA7Y1xFi9YLmpT6yu4Grc3abXDvenS/5dNncNrI/Hvv+EoxHRPLso4Z9NOdvKrffpAa8vutlwk4ZBMKTvk4JtDkYbA9/3O9nQG2xc4fj1Us6deakMvFDsU854Bh5v/fVjqbzG8t32itANkKnN6uNgNGok8AX2X+N9/nXt90O6UhoNqd+ddIc+7VDkDXhNEcxLoZsKIisKoKGs8rxDp8zyLMJ4FGKEWROR0vCQGs5yiKoyum/EA4gwQ5qCpmHfFffcK22mkbqJcoFyQ/d47YzVTEYSitIunkcH6HVw69MN1jNDNF1YMDQc+BuT/mjgLztUSBSX5BChRlPjiKHAcYQsRExEOD16EYFk0xxiGro771Cl04gjqabSWJiVM0FZoNdkahZZm0eVWAdYnEisUICO4mrVoZgtmmy5kqlTOwIEDdlMabsy9AMkaIBp7N8lDjOl903pYA1XJUSOk5AHoilvzWQYGas0TsrL0cvlvy+GzVctBvyi1fR0XvQQ2iu1whvouQE39v+N8d/eGO8Fwcsb460bh7RVTJQxk+HWGPlBMGBJfziEcX80GcMkGA3HfDwajTkk0E8Y7wcTzmJ/OEiC4WQyHfs8GI5hzGM+HQPum4JJkaDa3PgI1PQd+kyi6G0FafANLRYf2/j4uDHewmXhdEX3cGlxnC8cTWwlssLSkHHFcVwwYn/GdLsLVrrB9zuvlet6heR226A3zdmCvqq41akOfdM0dh0R0s9VRZgGwiRhxgi3EC1JlCbNjkB9eUyaGbgbJZaZfdMlONnEZoCnnICdoxSAKiIqIRrw8gE3GGkEO7fEKtIiNDFr1C75MCELzB0r+Y4l+1LNGn97tEPuVcYSwxZoZPbSwTUDDUAMOBW65AWbi6IqECEmbi28AOe4cGGge1d+ssofksM1lSW5K7dbsmhd0XbGrSY4pO6PoqxsdMC0cKvUKYKuo939tyGu/evGRtjBAlUR0sRrx4Eu8bP32lBL3P4wZ4jWnNlb/g3WkrhQ

docs/cassettes/langgraph_adaptive_rag_local_b095c1db-8bd1-4a34-937c-1a9b74ae74ff.msgpack.zlib

@@ -0,0 +1 @@
+eNqtVc1uI0UQFtobT1GaS2Dlf08c2xcUBVhpyZKFGCEgK6s8U/E0meluunuSeKMcNou4+xXYKEbR8ichbogrB55gH4EX4Er12F7buwjJyJZHdldX1/dV1dc1V5NTMlYo+cZzIR0ZjBwv7PhqYuirnKz7+iYjl6j4+uHBYe9ZbsTviXO6W62mKsI0UdZ16/WwGVZRi2qUoLseqHj04s5fF0FG1uKQbNCFLy4Co1Lif0FuyQQlCCLFeNJ502cqBzQEKIHONRkH6MCo3Ak5BAR/AgoyTA2cYtMpRU4Zyw+BMnBGA7CEJkoqcCSPJMw+n1gCl9CK+7FaBLPAAff3HwAwT+lsCbRRmXZAcigkkWECJaYVA8a+TmgEpkzOYXRiV6F8DrECqRzwwdjTHBBY50NwaDgTLim4nNDoTJnYgpDF+mVihlJ005Ns98yVFtErMAe8Zc6EpZIvi0+8PE/8njjlEsJASDQjiBIlIoIt9uhPPbZ8pbaWSrEFA7QMqFaJrAJ+TC43UweE+4cHH04zQbCcWFqkA1sxOrQqNxHH9NWSigtJGQ7Soj3c1BQlvh78o6Wm+n5TFz5lCYGwBeBuqhPcU7HIM9DIwgAcsNc7Xj4im0vr0eUjXmcqptSLKRNcdEy9D7c6w0JhX1olvUXpou1sYnkKw+ot9mWepj7GzNInh/9idZgvrDLP+pE7XzUM9SseLjGE8aqNKxOLaAnWkCYOn6J1ffmaWZPE1I0WdkcZlwK5Lf4+1So1tnE/9ZLHse0/Xloq3T9ZXc6dL/3ZkeWQq/G9EheWEyLdx5T1tcQOz+YxJgnnyLfjm1u+b6a86/U+/lWPeGzI8myM2Gqj0uTvj7tRRNqV35MR91UOx98PHwtdgpiOPebNdHv87G717u2ekpKKeTS+9RTKBYXne9PBUe6NNI1/Qq1TERXaqvou/zDf3uc77JLxdb1Wa3xnyGruOz298Z3M7dU1w9Off0xmM+rbgw/mWTy9fpeJjH9734gSNGpwSJp/GiHUt7vNdjdsw70HvZ97BqU95mxfJjKJklyeULzK75dlfudlGXuOxYh8cjMdDi/u/H0xV+9CvEHEwuFp0Pf6DDx+udYpN2q9OYvKdrvTrO98zq6zHILufMgGaC0HQp6upcWcDS6OguCyFMRKss8xppYu3/xf0K1GK9xurwPNA2JD0K2w3VwHGe1mgHdqYbu1Vs7FPNwQeNjo1NfBPuJnM8g7nXptLZXBplTWroeNsLUO9PTdtiH07Waj01gHvXin/id4pVKBt5zJZeSx3/4H3KUz/g==

docs/cassettes/langgraph_agentic_rag_278d1d83-dda6-4de4-bf8b-be9965c227fa.msgpack.zlib

@@ -0,0 +1 @@
+eNrtVU9vG0UUV8UXGY2QkJDXXttrmyzKIYoiimhUEC0SaqPVePbt7jS7M9uZ2dhu5AOhN07bTwAkSqqoBQ6ICyBxgwNfIHwa3uzabQlBLT0iIkV23p/f+703v/dydHYA2gglrz0R0oJm3OIf5tHRmYb7FRj78LQAm6n4+L2dW8eVFhdvZtaWJuz1WCm6phA26+ZMpjxjQna5KnpCJupkquLFL2cZsBjhH57fNqC9rRSkrb930U2eVy56frff7Q9G325xDqX1diRXsZBp/TR9IMoOiSHJmYXT1l1/x8oyF5w5jr17RsnzbSUlNJzr832A0mO5OIDHGkyJbcDnp8YyW5mjE8SF3387K8AYlsLXNz9Yk/viJwdujIdQVqvc28pzNfOut976q7e/cQ5k7t0AmdqsPg5GowtyZdK2hhgjBctNfWJ1BT9eGXZTi1TI+ssnfIVsFyX8vbmfLyXvzEtl4AVmP1wK2GVzN+T6eOz7x58IVp/jcEmqVJrD1V3uNm/rsM62cut9fMDri2423KRhEAzpu6Rgm4PRxsD3/U429AYbVziecsYz8HiLWz+WymssjQQ+w/lrfM8/rv16SFdKoyH1u5Pu0Kcdiv0CPlME81LopvPIigJoKKs879ApszyLMB+FGGGFRKQ0PKSGsxyiqozuG/EAIqyQpqBp2Hc8n3ulzTTOykS5QLmhe7x2xmomIwlFaRfPswP0Orh1dIP1zBBNFxYMDQf+xqQ/GvjLDhUSxSU5RKjR1DhiKHBcIQsRExFuj15EINk0h5iGTg0dqnQacSTVdBoLs3ImKBj0mkzNImvzqBLrBIsbiR0K0FFcrSYUs0VTLVcydWpHgKAhmyltV4Z+gAQNMI3zu8RhpvS+KR2s4aqEyHES8kA07a2ZDCNjlcZN+Wv2cvnPh2HzZYcBf9FqejovegjtlVrhC/Tcghv7n74Y7wTB/xfjX16MN24c0lYxUcZMhldj5AfBgCX94RDG/dFkDJNgNBzz8Wg05pBAP2G8H0w4i/3hIAmGk8l07PNgOIYxj/l0DHhvCiZFgmpz6yNQ03foM4mitxWkwW9osfixjR8fNsZbeCycrugeHi2O+4WriU+ArLANZFxxXBfM2J8x3d6ClW7w+51XqnW9QnK7bdLr1mxBX9bcKqpDX7eMXWeE9FNVEaaBMEmYMcIdREsSpUlzI1CXHpNmBu5FiWVm33QJbjaxGWCUE5RzlAJQaUQlRAM+PuAFI43Q55ZYRVqEJmeN2iXvJ2SBtWMl37JkX6pZ429DO+ReZSwxbIFGZi8FrhloAGLArZMrXrC5KKoCEWLizsILcI4LFwa6d+VHq/ohOVxTWZK7crsli9YVbWfcapJD6v5RlJWNDpgW7pQ6RdB1tnv/NsWNfz3YCCdYoCpCmnjtOtAl/uy9MtQSrz/MGaI1MXvLPwGicLhQ

docs/cassettes/langgraph_code_assistant_c2eb35d1-4990-47dc-a5c4-208bae588a82.msgpack.zlib

@@ -0,0 +1 @@
+eNq1VF1vG0UUFeKNXzGsEIKQ8frbjputFCXphwD1IS7wFo1n7u6OOju7zMzadcVLQ18RWgmJF6QKbNkotFCEhIoqJB554A+EP0H/Ady1Yzd5aJoXJMu7Mzv3nHPPvXeO5kMwVqb6tUdSOzCMO1zY4mhu4NMcrHswS8DFqZhc3+9PciNP3oudy2zP97Mx7uuKYjriMZO6wtPEFym3Pk81h8xZfzpIxfiPeQxMIMuD49sWDN2JQLvi12U4PaWxfr3SwN9PO7wMpfuap0LqqHgc3ZPZJhEQKuZgtvxcTDb8jePdVGtY6C2O7wBklCk5hO8N2AxTgM9n1jGX26MpQsFff84TsJZF8N2t91eKvpigmGLSqm393DdM2xDlrZnnPM71HRA/fEI/AsNB0ZuiOHnbhmmt1xNbw3tdWuvU291mu1PrtOp1Cs1uWOs2mmHY6Py4DtplPEaOGzf7033HouLkrY99b1BtN1hnSwzC5oBtDRo11hatGmK1WL3Fu1XvESbn0CfaH2dQPHVw1/mxS9QVgl4bCy7IXUi70z00pfj9mpGbpF4lB5Dho94ktVav0e01OuT6h/1npWfW0hLRpIruKJWO6C0jI6mLbzceLwSuvhYnXpYPlOSbJGF3KdoVVPE1tw4rNUSDRVmFAzDYNsVsmeKTlda1ddOyaL8dOCM5ZlA6m6XG0QPg2EFuXDxZYbcb1U69Wq3+soLYk3jUykVRn0mtpIYrJJQKNEsg8Fad5S066z5W2CDf36//u/0mdp5Dr0jp0tU3tssHKXsz8EB7REgTeMoZj3DFrA28slHpyLAsA0MWC/yjGYpark7HgqJig8JIpnL0qzxkV+9SUGxLliv3AgD31hoJesVozCyNx8KgbyLwQqYseKU+7EB84HCxdUm92/1rtOuttpcp47TgWLq0lL40KfD2Up5blpvckmG90qw0yhgnnYIlp4kDz5kciXaXYnKmSJRLAeQz8vzh7Jt/nn75/OFXX5MP0KDdcni3/UX41SXzeZBTIUMJo7KMZ3SMpHBxIGAoOdDFYlNqLB5T1HKmIKh5FyG6kXR45/Q4M+IMqs2ThJnxoWImgkOZYE1eApOZFMvnxoGXRr3lwRcwF95TMon8ATam8F0MCdBFcCXT0aUE/69U55LKjbosz/mr98I8xLp/DlVaFuoMB07LK0ItMMPjXsmen/fh1bEr2tPxOhN7OmiXBKhUKuQd/KR5OVfv/gcSSIQ2

docs/cassettes/langgraph_code_assistant_ef7cf662-7a6f-4dee-965c-6309d4045feb.msgpack.zlib

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

docs/cassettes/langgraph_crag_30d0a69b-9087-4f85-af26-cab55b567872.msgpack.zlib

@@ -0,0 +1 @@
+eNqdVX1sG2cZd5ZNg0abUDetQ6LiZtAoU86+s8/nL1zhOvGSJo6TOGmTljV6fX5tX3Jfvfe1a6eEQltADHX0CtW0P4amJrG7NP0IDaMtyz4YRagdayuxj2yiICq0an9sQ5NgokzjOX+0idq/ONk+v/d8/57f89zeahGbRNa1lnlZo9hEEoUDsfZWTbyzgAndX1ExzeuZmf5kami6YMrLj+UpNUjI7UaG7NINrCHZJemqu8i7pTyibvhvKLjmZiatZ8rvtryy26liQlAOE2eI2b7bKekQS6NwcI7qBQYxtVBgwZiY3WXKkAhDwRcDipAfJQzSGFkzCvSWJtXBLo2prduooW4jE0Y3qKzKkzjDfEezP80rq5vMLpxmCEamlHcxvbo+wYAJzeOGe6RlGGqWbe8mRgR8orReqGsUtAw2lbKs5cCBijQqS4xcK4RxMypGGkhcznbGaeoKtmsjZUKx6pxqZ1aV3IVNbGdZjypTGSk3ywpBupAwQAVeVazqkAuc47qpFhREcQ0I1TD1IhTXNFoVtECw6Zx6Ap6oegYr9qOcQVmvy8fSgpnWWY73+GwDDUQ83AmFSlU4ZJFCMDyAnA1gAmjbDjkXN1XNYwS1kwMzeZ1Q68Tqzp9EkoQhBNYkPQMYWMdzk7LRzmRw1k55DkrXcI1X1twExgaLFLmIK3Ur6xQyDEWWkC13jwPi8w2oWFo28O3iObtAtgaQtZiEJKLd7v4yUFRjeJfgd3GnSiyhSNYUoByrIMinYtTkv10pMJA0AU7YBnWsSt34xEodnVizCSQlU6tc2tSxZpGpisLplc/NAjBCxVY11n97uIbwVjivi/e4hIVVjklZk6zZWhuOmpgYMEF4XwUUaIHsnQFw8et/rDYm6Uiyp9mVq451Mx0AtLUUN+V2xsMxKWzAzSMwvC/kDYR8PubxxNB8rIHr0B1xXRgykUaygG1ns49VKV/QJnBmLnbHDi7ZHYS87X4B+1hcMnSC2UZW1vwIO1jfIWx3x+k6XVjdzMGcTNbCWs/b3YGdIWuLDTEQ23YJwVmVWNMewXOiIWkCNwd1cSzPAY3PAnNlCXhiJ27oJmUJlmBD0bK13K6ikk2SCO/z+Twcx4Vh1CSlkMGpQrpDVyEmCTOGiRUdZc6VWKA7VmBnULb+29h+QAAejLkzt2tQfQLDojzq4+rXSytVTGxHsMu46WgmCNeLd1Zq+hJsnSDPnVutRvCKhKZFlZy5Xd5wcYQj86WmMitnrOWvw2FMCIpegQsGeE7wef1S2s/5g7xH9ONg0CMEvcLJWJyNISmP2VSNbVa1Y7QvmuiOzaXAdwzWpIwPvdvSOjYmZcfSaqRPSWgJOiBuFsZdSl9guJglCSQM+0c2eeLjKpE6onFTnNiUyE0GWN7vEQOC6Pf6WN7FuXgXz24Zy3u27RzKqnRTsbOHL5XzPYOc2unPJ7WYmC6RQU9pNDHoicW2DZRHqdznT3T2juZSXi0qSbu6u3qz0bxPG8Y9A9vMLQGN75DT/bFcDvqJaD7iDjPARBlgiTTmgYV5YO1pEENccxrCTKbGgohr9TILM13wektqSjkMYwR0wnBHKk7BSynSp2t4+ReAQaEoZyKdO7u2iF3xSV9ypEx8fVtLiVR0y3C2t1juzHfHRRT1dI+Ol4uqkJdWgCD6eJZr4CByQqBGnlup/59ZvTDCrhxvNmnU3+NVTSeanM1WUtiEEbLmJEUvZGAvm7gCPR+MjlqLAUn0YH8a+1FAFAWPyKY2x041vd1cBjP2Uq8iBaasKFmn896IMyQIXmeYUVEkIAocV3vb/6BiT6WWO9+iffWnX3DUrlb4fv45Pdij/4770v6P/vvk4Ut3/3PDpZ4f/v4nPbsn5OFHrimH1PX6uHv8m39/eev9By/H3Btff//Lf3pjofW5DcNt/ZXL6QsXHr149sPqa9/99Ozyt06K2kuuty6++drbl661rZPePHD/1aVp69ix3Jn59jULYenaQNsf/vwqDTzzl0Rleud9m/uuxLfv6PZ8cOCB5Rvrv/HZqx+vVdY8ui/K/u3XrQ5j/q/vXJn99PhDlz/acXht7HJwrvOTL367/MLAQOjuNUeePaq13ReObn37e48tOu45eNcjk9/3bljI7HGYzy31x3+0eI+5963Bp95grn/l2f033uv92fLG66Wfv7d995Vkovti+R/lda4Xr3jNB588/vj6d85vip4Z9EUKjqsf8P/a82Hq8Pu/OnT843vPPRx45pfXhsJ72u7d1/bgQ+r2qdCNS4uJAWHZ8B4N/ftrT/+m5bNKZmp2zY+ZEc1rBv9zIbWkL51//pM2G9RWx8bra4/tuMvh+B/1rMGR