Updates

.github/workflows/ci.yml

@@ -20,31 +20,7 @@ env:
   POETRY_VERSION: "1.7.1"
 
 jobs:
-  changes:
-    runs-on: ubuntu-latest
-    outputs:
-      python: ${{ steps.filter.outputs.python }}
-      sdk-js: ${{ steps.filter.outputs.sdk-js }}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dorny/paths-filter@v3
-        id: filter
-        with:
-          filters: |
-            python:
-              - 'libs/langgraph/**'
-              - 'libs/sdk-py/**'
-              - 'libs/cli/**'
-              - 'libs/checkpoint/**'
-              - 'libs/checkpoint-sqlite/**'
-              - 'libs/checkpoint-postgres/**'
-              - 'libs/scheduler-kafka/**'
-              - 'libs/prebuilt/**'
-            sdk-js:
-              - 'libs/sdk-js/**'
-
   lint:
-    needs: changes
     name: cd ${{ matrix.working-directory }}
     strategy:
       matrix:
@@ -57,16 +33,13 @@ jobs:
             "libs/checkpoint-sqlite",
             "libs/checkpoint-postgres",
             "libs/scheduler-kafka",
-            "libs/prebuilt",
           ]
-    if: needs.changes.outputs.python == 'true'
     uses: ./.github/workflows/_lint.yml
     with:
       working-directory: ${{ matrix.working-directory }}
     secrets: inherit
 
   test:
-    needs: changes
     name: cd ${{ matrix.working-directory }}
     strategy:
       matrix:
@@ -76,9 +49,7 @@ jobs:
             "libs/checkpoint",
             "libs/checkpoint-sqlite",
             "libs/checkpoint-postgres",
-            "libs/prebuilt",
           ]
-    if: needs.changes.outputs.python == 'true'
     uses: ./.github/workflows/_test.yml
     with:
       working-directory: ${{ matrix.working-directory }}
@@ -86,23 +57,17 @@ jobs:
 
   # NOTE: we're testing langgraph separately because it requires a different matrix
   test-langgraph:
-    needs: changes
-    if: needs.changes.outputs.python == 'true'
     name: "cd libs/langgraph"
     uses: ./.github/workflows/_test_langgraph.yml
     secrets: inherit
 
   # NOTE: we're testing scheduler-kafka separately because it requires a different matrix
   test-scheduler-kafka:
-    needs: changes
-    if: needs.changes.outputs.python == 'true'
     name: "cd libs/scheduler-kafka"
     uses: ./.github/workflows/_test_scheduler_kafka.yml
     secrets: inherit
 
   check-sdk-methods:
-    needs: changes
-    if: needs.changes.outputs.python == 'true'
     name: "Check SDK methods matching"
     runs-on: ubuntu-latest
     steps:
@@ -115,15 +80,11 @@ jobs:
         run: python .github/scripts/check_sdk_methods.py
 
   integration-test:
-    needs: changes
-    if: needs.changes.outputs.python == 'true'
     name: CLI integration test
     uses: ./.github/workflows/_integration_test.yml
     secrets: inherit
 
   lint-js:
-    needs: changes
-    if: needs.changes.outputs.sdk-js == 'true'
     runs-on: ubuntu-latest
     strategy:
       matrix:
@@ -148,8 +109,6 @@ jobs:
         run: yarn build
 
   test-js:
-    needs: changes
-    if: needs.changes.outputs.sdk-js == 'true'
     runs-on: ubuntu-latest
     strategy:
       matrix:

.github/workflows/codespell.yml

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

@@ -21,10 +21,6 @@ concurrency:
   group: "pages"
   cancel-in-progress: false
 
-defaults:
-  run:
-    working-directory: docs
-
 jobs:
   get-changed-files:
     runs-on: ubuntu-latest
@@ -48,7 +44,6 @@ jobs:
   deploy:
     # needs: run-changed-notebooks
     runs-on: ubuntu-latest
-    timeout-minutes: 10 # Job will be cancelled if it runs for more than 10 minutes
     env:
       GITHUB_TOKEN: ${{ secrets.MKDOCS_GITHUB_TOKEN }}
     steps:
@@ -63,50 +58,26 @@ jobs:
           poetry-version: ${{ env.POETRY_VERSION }}
           cache-key: docs
 
-      - name: Use Node.js
-        uses: actions/setup-node@v3
-        with:
-          node-version: "22"
-          cache: "yarn"
-          cache-dependency-path: docs/yarn.lock
-
       - name: Install dependencies
         run: |
-          yarn
-          poetry install --with test --with docs --no-root
+          poetry install --with test --no-root
           poetry run pip install -U \
             pytest \
             pytest-check-links \
+            langsmith \
+            langchain \
             GitPython \
-            "git+https://github.com/benjamincburns/markdown-exec.git@cc0d39d737e5ffd4b83d23cd8729d7ea16e363c8"
+            "git+https://${GITHUB_TOKEN}@github.com/langchain-ai/mkdocs-material-insiders.git"
 
-          # we run this installation only for internal PRs
-          # as GITHUB_TOKEN is not available for PRs from outside contributors
-          if [ -n "${GITHUB_TOKEN}" ]; then
-            poetry run pip install "git+https://${GITHUB_TOKEN}@github.com/langchain-ai/mkdocs-material-insiders.git"
-          fi
-
-          poetry run jupyter kernelspec list
-          poetry run python3 -m ipykernel install --user --name=python3
-          npm install -g tslab
-          poetry run tslab install --python=python3
-          poetry run jupyter kernelspec list
-
-      - name: Run unit tests
-        # Run unit tests on the docs build pipeline
-        run: make tests
       - name: Lint Docs
         # This step lints the docs using the existing linting set up.
         # It should be very fast and should not require any external services.
         run: make lint-docs
-      - name: Build llms-text
-        run: make llms-text
       - name: Build site
         run: make build-docs
         env:
           MKDOCS_GIT_COMMITTERS_APIKEY: ${{ secrets.MKDOCS_GIT_COMMITTERS_APIKEY }}
-          OPENAI_API_KEY: sf-proj-1234567890 # fake placeholder, shouldn't actually be used
-          ANTHROPIC_API_KEY: sk-ant-api03-1234567890 # fake placeholder, shouldn't actually be used
+
       - name: Check links in notebooks
         env:
           LANGCHAIN_API_KEY: test
@@ -117,7 +88,6 @@ jobs:
               --check-links-ignore "https://(api|web|docs)\.smith\.langchain\.com/.*" \
               --check-links-ignore "https://academy\.langchain\.com/.*" \
               --check-links-ignore "https://x.com/.*" \
-              --check-links-ignore "https://twitter.com/.*" \
               --check-links-ignore "https://github\.com/.*" \
               --check-links-ignore "http://localhost:8123/.*" \
               --check-links-ignore "http://localhost:2024.*" \
@@ -125,15 +95,14 @@ jobs:
               --check-links-ignore "/.*\.(ipynb|html)$" \
               --check-links-ignore "https://python\.langchain\.com/.*" \
               --check-links-ignore "https://openai\.com/.*" \
-              --check-links-ignore "https://www\.uber\.com/.*" \
               --check-links-ignore "https://pepy\.tech/.*" \
-              --check-links $(find site -name "index.html" | grep -v 'storm/index.html')
+              --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/|site/|; s/\.ipynb$/\/index.html/' || true)
+            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..."
@@ -144,7 +113,6 @@ jobs:
                 --check-links-ignore "http://localhost:2024.*" \
                 --check-links-ignore "http://127.0.0.1:.*" \
                 --check-links-ignore "https://x.com/.*" \
-                --check-links-ignore "https://twitter.com/.*" \
                 --check-links-ignore "https://github\.com/.*" \
                 --check-links-ignore "/.*\.(ipynb|html)$" \
                 --check-links ${CHANGED_FILES} \
@@ -159,7 +127,7 @@ jobs:
         uses: actions/configure-pages@v4
 
       - name: Upload Pages Artifact
-        # if: github.ref == 'refs/heads/main'
+        if: github.ref == 'refs/heads/main'
         uses: actions/upload-pages-artifact@v3
         with:
           path: ./docs/site/

.github/workflows/extract_ignored_words_list.py

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

.github/workflows/release.yml

@@ -195,11 +195,7 @@ jobs:
               "$PKG_NAME==$VERSION" \
           )
 
-          if [[ "$PKG_NAME" == *prebuilt* ]]; then
-            poetry run pip install langgraph
-          fi
-
-          if [[ "$PKG_NAME" == *checkpoint* || "$PKG_NAME" == *prebuilt* ]]; then
+          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)"

.github/workflows/run_notebooks.yml

@@ -11,10 +11,6 @@ on:
   schedule:
     - cron: '0 13 * * *'
 
-defaults:
-  run:
-    working-directory: docs
-
 jobs:
   build:
     runs-on: ubuntu-latest
@@ -43,14 +39,14 @@ jobs:
 
       - name: Pre-download tiktoken files
         run: |
-          poetry run python _scripts/download_tiktoken.py
+          poetry run python docs/_scripts/download_tiktoken.py
 
       - name: Prepare notebooks
         run: |
           if [ "${{ matrix.lib-version }}" = "development" ]; then
-            poetry run python _scripts/prepare_notebooks_for_ci.py --comment-install-cells
+            poetry run python docs/_scripts/prepare_notebooks_for_ci.py --comment-install-cells
           else
-            poetry run python _scripts/prepare_notebooks_for_ci.py
+            poetry run python docs/_scripts/prepare_notebooks_for_ci.py
           fi
 
       - name: Run notebooks
@@ -67,12 +63,12 @@ jobs:
         run: |
           if [ "${{ github.event_name }}" = "workflow_dispatch" ] || [ "${{ github.event_name }}" = "schedule" ]; then
             echo "Running all notebooks"
-            ./_scripts/execute_notebooks.sh
+            ./docs/_scripts/execute_notebooks.sh
           else
-            CHANGED_FILES=$(echo '${{ inputs.changed-files }}' | tr ' ' '\n' | sed 's|^docs/docs/|docs/|' | grep '\.ipynb$' || true)
+            CHANGED_FILES=$(echo '${{ inputs.changed-files }}' | tr ' ' '\n' | grep '\.ipynb$' || true)
             if [ -n "$CHANGED_FILES" ]; then
               echo "Running changed notebooks: $CHANGED_FILES"
-              ./_scripts/execute_notebooks.sh $CHANGED_FILES
+              ./docs/_scripts/execute_notebooks.sh $CHANGED_FILES
             else
               echo "No notebook files changed, skipping execution"
             fi

.gitignore

@@ -178,5 +178,4 @@ Untitled*.ipynb
 
 Chinook.db
 
-.vercel
-.turbo
+libs/langgraph/out

CLAUDE.md

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

Makefile

@@ -0,0 +1,39 @@
+.PHONY: lint-docs format-docs build-docs serve-docs serve-clean-docs clean-docs codespell build-typedoc
+
+build-typedoc:
+	cd libs/sdk-js && yarn install --include-dev && yarn typedoc
+	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 -m mkdocs serve -c -f docs/mkdocs.yml --strict -w ./libs/langgraph
+
+serve-docs: build-typedoc
+	poetry run python -m mkdocs serve -f docs/mkdocs.yml -w ./libs/langgraph  -w ./libs/checkpoint -w ./libs/sdk-py --dirty
+
+clean-docs:
+	find ./docs/docs -name "*.ipynb" -type f -delete
+	rm -rf docs/site
+
+## Run format against the project documentation.
+format-docs:
+	poetry run ruff format docs/docs
+	poetry run ruff check --fix docs/docs
+
+# Check the docs for linting violations
+lint-docs:
+	poetry run ruff format --check docs/docs
+	poetry run ruff check docs/docs
+
+codespell:
+	./docs/codespell_notebooks.sh .
+
+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

@@ -21,7 +21,10 @@ LangGraph is inspired by [Pregel](https://research.google/pubs/pub37252/) and [A
 
 ### Why use LangGraph?
 
-LangGraph powers [production-grade agents](https://www.langchain.com/built-with-langgraph), trusted by Linkedin, Uber, Klarna, GitLab, and many more. LangGraph provides fine-grained control over both the flow and state of your agent applications. It implements a central [persistence layer](https://langchain-ai.github.io/langgraph/concepts/persistence/), enabling features that are common to most agent architectures:
+LangGraph provides fine-grained control over both the flow and state of your
+agent applications. It implements a central
+[persistence layer](https://langchain-ai.github.io/langgraph/concepts/persistence/),
+enabling features that are common to most agent architectures:
 
 - **Memory**: LangGraph persists arbitrary aspects of your application's state,
 supporting memory of conversations and other updates within and across user
@@ -330,10 +333,6 @@ Then we define one normal and one conditional edge. Conditional edge means that
 * [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.
 * [LangGraph Platform](https://langchain-ai.github.io/langgraph/concepts/#langgraph-platform): LangGraph Platform is a commercial solution for deploying agentic applications in production, built on the open-source LangGraph framework.
 
-## Resources
-
-* [Built with LangGraph](https://www.langchain.com/built-with-langgraph): Hear how industry leaders use LangGraph to ship powerful, production-ready AI applications.
-
 ## Contributing
 
 For more information on how to contribute, see [here](https://github.com/langchain-ai/langgraph/blob/main/CONTRIBUTING.md).

docs/.gitignore

@@ -0,0 +1,2 @@
+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/_patch.py

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

docs/_scripts/download_tiktoken.py

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

docs/_scripts/execute_notebooks.sh

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

docs/_scripts/generate_api_reference_links.py

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

docs/_scripts/notebook_convert.py

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

docs/_scripts/notebook_convert_templates/mdoutput/conf.json

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

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

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

docs/_scripts/notebook_hooks.py

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

docs/_scripts/prepare_notebooks_for_ci.py

@@ -0,0 +1,236 @@
+"""Preprocess notebooks for CI. Currently adds VCR cassettes and optionally removes pip install cells."""
+
+import logging
+import os
+import json
+import click
+import nbformat
+
+logger = logging.getLogger(__name__)
+NOTEBOOK_DIRS = ("docs/docs/how-tos","docs/docs/tutorials")
+DOCS_PATH = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+CASSETTES_PATH = os.path.join(DOCS_PATH, "cassettes")
+
+BLOCKLIST_COMMANDS = (
+    # skip if has WebBaseLoader to avoid caching web pages
+    "WebBaseLoader",
+    # skip if has draw_mermaid_png to avoid generating mermaid images via API
+    "draw_mermaid_png",
+)
+
+NOTEBOOKS_NO_CASSETTES = (
+    "docs/docs/how-tos/visualization.ipynb",
+    "docs/docs/how-tos/many-tools.ipynb"
+)
+
+NOTEBOOKS_NO_EXECUTION = [
+    # this uses a user provided project name for langsmith
+    "docs/docs/tutorials/tnt-llm/tnt-llm.ipynb",
+    # this uses langsmith datasets
+    "docs/docs/tutorials/chatbot-simulation-evaluation/langsmith-agent-simulation-evaluation.ipynb",
+    # this uses browser APIs
+    "docs/docs/tutorials/web-navigation/web_voyager.ipynb",
+    # these RAG guides use an ollama model
+    "docs/docs/tutorials/rag/langgraph_adaptive_rag_local.ipynb",
+    "docs/docs/tutorials/rag/langgraph_crag_local.ipynb",
+    "docs/docs/tutorials/rag/langgraph_self_rag_local.ipynb",
+    # this loads a massive dataset from gcp
+    "docs/docs/tutorials/usaco/usaco.ipynb",
+    # TODO: figure out why autogen notebook is not runnable (they are just hanging. possible due to code execution?)
+    "docs/docs/how-tos/autogen-integration.ipynb",
+    # TODO: need to update these notebooks to make sure they are runnable in CI
+    "docs/docs/tutorials/storm/storm.ipynb",  # issues only when running with VCR
+    "docs/docs/tutorials/lats/lats.ipynb",  # issues only when running with VCR
+    "docs/docs/tutorials/rag/langgraph_crag.ipynb",  # flakiness from tavily
+    "docs/docs/tutorials/rag/langgraph_adaptive_rag.ipynb",  # flakiness only when running in GHA 
+    "docs/docs/tutorials/rag/langgraph_self_rag.ipynb",  # flakiness only when running in GHA
+    "docs/docs/tutorials/rag/langgraph_agentic_rag.ipynb",  # flakiness only when running in GHA
+    "docs/docs/how-tos/map-reduce.ipynb",  # flakiness from structured output, only when running with VCR
+    "docs/docs/tutorials/tot/tot.ipynb",
+    "docs/docs/how-tos/visualization.ipynb",
+    "docs/docs/tutorials/llm-compiler/LLMCompiler.ipynb"
+]
+
+
+def comment_install_cells(notebook: nbformat.NotebookNode) -> nbformat.NotebookNode:
+    for cell in notebook.cells:
+        if cell.cell_type != "code":
+            continue
+
+        if "pip install" in cell.source:
+            # Comment out the lines in cells containing "pip install"
+            cell.source = "\n".join(
+                f"# {line}" if line.strip() else line
+                for line in cell.source.splitlines()
+            )
+
+    return notebook
+
+
+def is_magic_command(code: str) -> bool:
+    return code.strip().startswith("%") or code.strip().startswith("!")
+
+
+def is_comment(code: str) -> bool:
+    return code.strip().startswith("#")
+
+
+def has_blocklisted_command(code: str, metadata: dict) -> bool:
+    if 'hide_from_vcr' in metadata:
+        return True
+    
+    code = code.strip()
+    for blocklisted_pattern in BLOCKLIST_COMMANDS:
+        if blocklisted_pattern in code:
+            return True
+    return False
+
+
+def add_vcr_to_notebook(
+    notebook: nbformat.NotebookNode, cassette_prefix: str
+) -> nbformat.NotebookNode:
+    """Inject `with vcr.cassette` into each code cell of the notebook."""
+
+    uses_langsmith = False
+    # Inject VCR context manager into each code cell
+    for idx, cell in enumerate(notebook.cells):
+        if cell.cell_type != "code":
+            continue
+
+        lines = cell.source.splitlines()
+        # skip if empty cell
+        if not lines:
+            continue
+
+        are_magic_lines = [is_magic_command(line) for line in lines]
+
+        # skip if all magic
+        if all(are_magic_lines):
+            continue
+
+        if any(are_magic_lines):
+            raise ValueError(
+                "Cannot process code cells with mixed magic and non-magic code."
+            )
+
+        # skip if just comments
+        if all(is_comment(line) or not line.strip() for line in lines):
+            continue
+
+        if has_blocklisted_command(cell.source, cell.metadata):
+            continue
+
+        cell_id = cell.get("id", idx)
+        cassette_name = f"{cassette_prefix}_{cell_id}.msgpack.zlib"
+        cell.source = f"with custom_vcr.use_cassette('{cassette_name}', filter_headers=['x-api-key', 'authorization'], record_mode='once', serializer='advanced_compressed'):\n" + "\n".join(
+            f"    {line}" for line in lines
+        )
+
+        if any("hub.pull" in line or "from langsmith import" in line for line in lines):
+            uses_langsmith = True
+
+    # Add import statement
+    vcr_import_lines = []
+    if uses_langsmith:
+        vcr_import_lines.extend([
+            # patch urllib3 to handle vcr errors, see more here:
+            # https://github.com/langchain-ai/langsmith-sdk/blob/main/python/langsmith/_internal/_patch.py
+            "import sys",
+            f"sys.path.insert(0, '{os.path.join(DOCS_PATH, '_scripts')}')",
+            "import _patch as patch_urllib3",
+            "patch_urllib3.patch_urllib3()",
+        ])
+
+    vcr_import_lines.extend([
+        "import nest_asyncio",
+        "nest_asyncio.apply()",
+        "import vcr",
+        "import msgpack",
+        "import base64",
+        "import zlib",
+        "import os",
+        "os.environ.pop(\"LANGCHAIN_TRACING_V2\", None)",
+        "custom_vcr = vcr.VCR()",
+        "",
+        "def compress_data(data, compression_level=9):",
+        "    packed = msgpack.packb(data, use_bin_type=True)",
+        "    compressed = zlib.compress(packed, level=compression_level)",
+        "    return base64.b64encode(compressed).decode('utf-8')",
+        "",
+        "def decompress_data(compressed_string):",
+        "    decoded = base64.b64decode(compressed_string)",
+        "    decompressed = zlib.decompress(decoded)",
+        "    return msgpack.unpackb(decompressed, raw=False)",
+        "",
+        "class AdvancedCompressedSerializer:",
+        "    def serialize(self, cassette_dict):",
+        "        return compress_data(cassette_dict)",
+        "",
+        "    def deserialize(self, cassette_string):",
+        "        return decompress_data(cassette_string)",
+        "",
+        "custom_vcr.register_serializer('advanced_compressed', AdvancedCompressedSerializer())",
+        "custom_vcr.serializer = 'advanced_compressed'",
+    ])
+
+    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/add-summary-conversation-history_048805a4-3d97-4e76-ac45-8d80d4364c46.msgpack.zlib

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+eNqdVWtsHNUZdWQe+QFIbUiViiaebiI1JJ7xzL5m15ZBZv2og9ev3RDHeazuztzdHXtm7mTujL1rd2vlUShgQoa4DQalNLG9dhbjxBAguE4KqYBEKqWqGmiSKjQtlekjIqVVKUHUvbOPxFbyq/NjZ++9536vc75vdo33QB1LSF0yKakG1IFgkAW2do3rcIcJsbEno0AjgcTR1pZQeMTUpfPrEoah4cqKCqBJDNKgCiRGQEpFD1chJIBRQf5rMsyZGY0iMXVhyWC/Q4EYgzjEjkpqS79DQMSXapCFo5dcoSRMGQlI9UJAXjolqVSovpwK1DzoKKccOpKhjTQx1B3pbWRHQSKU7a24ZtBuZINUsuTIGxs6BApZxICMIdkwoKKRtAxTt42wDGvvISQXIjFSWs54zFRzmdu2rv+vpPodKlBygDg0IoX4bIwIsaBLWgHm2IghycBOA1EEuSCTGNIVYMOomI4UClBxqQeqlIyE3C5jG9OATryQ6uOcS00nVdUNCeaXRWhuUYyX5CmpcUc6bReIMCXpULQzuoG2C1VEo2gXFAyCTm9LjycgEImrp0cTCBvW1GIWjwJBgKSqUBWQSDxYL8X7JK2cEmFMBgbMEuZUmKuOle2GUKOBTPLJ5G9Zx4CmyVI+gIoujNTJAtO0HcnNx1mbU5roQjWs4y0kiJrGitYUkZtKcYzbx7DHkjQ2gKTKRD60DEg8GS13/rOFBxoQuokRuiBlK5O/PLUQg7A1FgRCS2iRSaALCWsM6IrX/crCfd1UDUmB1nig9WZ3hcMb7lwMxzH+6UWGcUoVrLGcCl9fdBkaeooWELFhHWKnivWRoRo3EtaIy++d0CHWSPPA3RlyzTDxrlHCBfzlmfFCEx1uebhI4qWSb4zWEl6sk+GEWU45vVQIapSTdbopzlXp8lV6fFRDMDwZKLgJ35KG6bAOVBwjVNQVaR8XEqbaDcVs4JaEn7QJJ9nY4ZP+pGFSQxjShaisyQ66PT8+6MbaV/LqopEeB6rUl3NrHbHJJONCUo8XjonqbZPEOa1gUgjeOVU4KdY5S/JiaY6lWe4NW/8CkZUduIZ0g8ZQIMPJSFnnyxWQtDVV7eI8Li/LslWkDQXZFGHIjNYihfjEVZSmQxkBcSZJk+EAZUmRCAm538LgI3rhyGX2xM0IA3VDMiMnXGz+ObUQokPbg53GdUOjfvLM3hpUtOW0MX7ePbMYhuGCgEa8Cj5x83nBxGEWTyaLYFoSrfNryCLi83l4AP1OvwdEPYDlfS7WH3MLAu8WfU7B5T0aqKcDQEhAOpRTmzVeu7m5JtgYyIaI7QBC3RJ85sKS0khEiEWiSjVjtoRTfqjWtvFeLRQW2D5/Z7hTciET+ppk54ZAJ/tIsJvfqOFGmuOdvMvD+10+mmNYhmM4GviZRG1TfbihMbr5IcHr9/HywwL3ULxdx2p4Q6+Ekm1MhO2sCzZ0SRJujjTFJGAwel0kFgu2sS7GC7S2eKhB0XdAsc7Dx6Nm0MPWED7JwK2uqKKIEsksxNWFfqBJP9B2N7gr2WI3VFFiTgXVzOLZV0V9l3zZWlQ5VUXaiMgJkjcZzCHJgNXNSIXnh0gNzB5JrDZMvwp7Ed/e4I929LQ7JdFkNE8Q4kCCc3cnmyM9nh1RqabVnQwuKALv42i2UAcv6/blxHMj9P8zqtc66IXtTbdo+U/4uIqwKsVimRDUSQtZWUFGpkjGuA4zhPP2ms3WcZ/gdwGf289HfT5eAD66blP7saK168Ng1P4G5L7lOzP5D8/bS35e9uTSktxTarRvQ8+z96bnNnV87g9/e4919cfmcxdmwxt5qWx435+2vvnS9HD67HP1X3y6bF/JU94HOz6ofmBuVdlHI++uOLNyzV21bzUO/eizTWV/vvjpuV8MHuj9cuyrU/PXzr734dt//Dds1m/f/yh47f21n5ye+Vpm8t5n3DO7f1DX/LuJO/5Rfs9I8ptM50/dVeG76aNnXrhvwHvwva+kj++8PNyx4v5f15z+ft8g1yN//s7hS5fXr5Er3whvMPbOLW0ceJw7Vu9Z/odfNTZsXdZ0R+uK4MR9H8480nXbPm7d8q1HDu14fe/IP/ct27QuPVjG9X85ffzO9LxycuA/n/31iU9SK5++Zv7msaxn6Fznv74YvHrqJ1s9wl3uii3q3qH/1jTffmF9pfCmsv3AxJHpe969e+3q5OoTO8XSlhe+8/eeV3cumx05ODtwcOCpr08/e27vizg8d+3I+9uHZ1+O/W3q8J6mrr888VtH75X975ztO6AqZRMfpVeFPxhaPiZub+Vfbvv946fZztIV3/PtFn/44qFVj82vHqtaw1ycv9KQxfebDyxt6t9/ZctbK78FhmPtc4n16y9e3jm5YffaS48+yZ5xXG2+FCFMzc+XliDt2sd1pSUl/wM+DOUE

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

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

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

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

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

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

docs/cassettes/create-react-agent-structured-output_d1386f99-ffd1-4b36-86ec-cabb3357d929.msgpack.zlib

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

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

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

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

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

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

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

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

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

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

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

docs/cassettes/disable-streaming_4.msgpack.zlib

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

docs/cassettes/disable-streaming_8.msgpack.zlib

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

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

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

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

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

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

@@ -0,0 +1 @@
+eNqFVMtOHEcUjaWs/BVXvcFY3fMKzMBsEmwT4mDACkSJZUejmu473eWpripXVQ+0EYuQx35+IRCIkPNYeedNVlnkC/w1udVDwyjGsjSL6fu+55y6x+cTNJYreesVlw4Nix192OnxucEXBVr341mOLlPJ6eOd3b2TwvA3mXPa9ptNpnnDsQkXZSNWedMiM3F2OlRJ+fbW7cOA3IMxlkEfAjcRZeT2Hiz31na/Gq/jveLFzpOVg2R5c9Phwe5Sa2u83QtCCKijqTK+yZhbsMBgQaoEF4BLeMRkumGYzj71kTk7GBi0hXCW4jtkmfUfJKhd5kuwZMJkjImP5jIWRYKDROWMS5/x9Dsy48GN5jqaSbuPhqwjJizOOQzbH8SK4JLuBi/PWYq2dhydZ8gSwvjni68tmmgtpazpa10SqDK6BNk2O41P6PfnWhzT/NG6jFXCZTr9PX3JdQgJjgRzeDZzT0/uNu9e3FdSYsXW9GKMqCMm+AT/uD+bK3qEMnXZ9KTT7b6qbXulxulfTGvBY+Yzm8+tkr8Rjpo4xx/OrGOusMen1B3//ec8R2tpl192NuslfnpP2w+0ONtFQzqb/ipTLg9OH9Au0zefGx5CuwdfMgmdVmcZ2t1+u9Nf7sLG1t7/9zhttzpLlbi+pykNYfP2448Oa8F8SC/BSAmh9geFHlR4e4kHfVkIEQY1y7OvmjwSQnClr6eHgeNOIDW6qgobQhE6poQINrj7ohjC4yo1DAojKLJ+JoIy4oz0FTHeSLnLimGDq8qc+kJNUpJn1Tb9hAInKJpU5EpfwTZtZP9+DQ/ndgrB70kLGwRXasJaiBJmooJRIWevGO7YUsagDDD/ZxH2M/QJGcKIG+tAK8t9JBNUKS1yagjcVgFeCqRqJhO4o/QsSJSL4cyJNF7yvnQGz/z4I54+o8fnF6HtiTGo68DMWxg2FAiaGUY3htRF8xZxRsNSCZcZktyAJ4sN2OU5F8yAU7CNbl+Z8bchlKoAliR+HouXcFAAgwpVKKzv6IeloIF3w+yQ9QlcGytDbLYaq51eq9XqdYns+TfttXAUXrP+UDqjkqJC1Te54qEPa3APSdQSDelvo+DUJ4ItTHiRvyOFvDJX1/KzWAuVNvlc4cip6EoVEYuGl3VtlPqyUXtptDrEVqfXXmq/K5A+bF8rgrYeFlz4EwJDoeKxBTXyiJnr0RuwzgjsChmDmsRO1TzytXwq3RBVuS5c9ZRJE6gb8ISAp4PE5RzqGs1ImRysxpiPeAyO2bENoeZTGxXTMfHzcEn1QsjZmL7muVhZXV5Z7a7eRMXsMVZHauB4TuHtRrd79B/qa3Sq

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

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

docs/cassettes/introduction_6a385b06-8d34-4a2d-aded-1cf4bb0ca590.msgpack.zlib

@@ -0,0 +1 @@
+eNqNVHlQE1cYB4MW6hGL0/HoOOykIo64SZYckFSpKZfcVDJYoIwum0eyZLMbdzeEQ0djFa3isR7Voq1UQ2IjhyhTtdoOg7XUY1orU5EKtlOpjow4o/UYj5a+QBAsqN2/3r7v+n2/3/e9Ve4iwHIkQ/vXkDQPWJzg4Q8nrHKzYKkNcPxqlwXwJsbgzEjP1O+3sWR7qInnrZxWJsOtpBSneRPLWElCSjAWWREmswCOw42Ac+YzhpL2DWUSC168mGfMgOYkWgSTRyjnIJIBJ3iTWyZhGQrAk8TGAVYCrQQDkdC892qRCecRA4OUMDbETDN2BM9nbDySgtPGBBa3mt6VLM/z5mMMgPL6ExRuMwBUgapQjqFpwKMRsKJcHSGXLHebAG6AzW52mhiOFxqGwa/HCQJYeRTQBGMgaaNQaywlrXMQAyigcB54CG/GPn4EjxkAK4pTZBFw9UcJh3CrlSIJ3GuXFcLqNb4+UL7ECoabPd52UcgCzQtHdQM4ZBklkG0akUsVSmnEoWKU43GSpiBfKAWbFlzWPvuJoQYrTphhHtSnpODqD64b6sNwQnUqTqRnPpcSZwmTUI2zFrXyyNB71kbzpAUI7piM4eV8xsFyCimGSSMbnkvMldCEUF2AUxxoeEbysxAPVEWBytWoHKsbYIkCtJE3CfsxheYACzgrnELwkQum5G3cKidUBJz/we0bnH3pyQNqXvWb7IyF6gjfxLPkHASLRJJwGoH5VQim1mIRWpUSSUjV18T4yuhHFKNBz+I0VwAFiRsQ302YbLQZGDwxI8reLhlsi4X1KdJC8qhvaaBY3l/BqZTL5e0zX+rJAgtkzVvRqdBoNK/IC5kBvNDo7Q+Sh2KRel+XWM7IdUjaaoMj2LeAPlQuLyqIa/Yr/QexDcTM/B8xL0CozGkPGykaLvQwiNVRfdXCX+0/CNEXE/Z/Yl4MERkp/D/09Rea8RLPocT1eyMv9X4hHo9PeZQ0CCfhebEci7NH0QsKyOR43SKOL15qz4hlGA7sLyJxwYNJMcTIMEYK1MfEozE4YQJoZt8KCe7Y7DRdamJMzQfoQiafgbOkx+HM0QwNXJmAhaspeAiKsRngY8cCFwxfqMsWGjVyRSSOYWolUAElQWjQ9+AbMrBMz5bF6X0p+558B1xZFl6dHiUP2RDo1/eJDFtTmSvyceW9r3+RLEvb0pjreHSp51D1ZTxkbe2U8pWCafe6lNLgHc5Zj397TYOup8N0kkfdJYnRURPqbMTtowfv71jWe/xJaVkXY2+531m2IulmS89G857OdP2RWcZbZ1RSska8S2GMwdqOvS+Ka9OGNATkfIhelR5evwWVLtrJZLXtDG+Lqs+fcf3XxeKf9sW7c6JDap9UXFyREjW+aerEbzuuVI0S7EGt8wLOdowdLV/j+CPgRDM2X63sTlrdEHtt9IMZY6JShXnTDhpmfVq9dt3FybeCCi6dXL0xryv71PzRKWEXJsxuXuuf7RfatP1ekyNiV+H5C+SovYG13dNVPScOtMw1Hp4Seu+G2G5IkDia8hK+vNtBLRlzLiOU36PvtgTJPhFaHosrjoUtETWf396dXCWK++z61wvc10/fDd+trvI/p7vm+Mf2juLH8ZUSnbqyYKuiNTj6pjBh+7SmSk1rtHiyeqJeOm7M3IkBEV0L/LVp7eWeJPfHwduKSwuVuaJsnHtj5XfmxDdPibseqgpFjqLpZd8H6pZPTaSKMhzBj0qWnbmcoLWfzKqoHH+2UZ4XoKzsqXoY+svYZDc51/x72gb/3PJNF5L2HbFtnnQ76jD2Z3XZ085jlNYyCc9aWvt2UG54Ykcm0rp3IXo8K6liY/hf3UfFm8Dsr1Sd2wxtdfVv3fhZ3Divfs3ZB7bmbs3ngad6MfRBEv337Tt3ZHA0entFfoXGp64dIj+/fwEX/nZF

docs/cassettes/introduction_7df33d9e-cc76-4a0f-8307-01e619483b3e.msgpack.zlib

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

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

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

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

@@ -0,0 +1 @@
+eNqNVWtsU1UcH8NXiAnxgy5+UA+NY4nudn1s6zbFZJbXgDFYS9yArZ7de9ZeenvP9dxzB2UOZQxDxKE3YlCCBlnXYi2wBWQQID7QiAkmk0DiCALxEUgMxn0AAjGZ/3vXssHGo0mbe8/5/f6P3//RzlQbYbpM1SkZWeWEYZHDi252phh5wyA670rGCI9QKbGkLhDsMZg8VBjhXNOrSkqwJjuxyiOMarLoFGmspM1dEiO6jsNET7RQKX42f1q7I4bXhDiNElV3VCG3y1NajBw5FJysaHcwqhB4chg6YQ64FSmEonLraL6MeIQwMgPVxpGKYwTJOnpNVhSno6PJMkQlolhAUcGGRASvUCboVFUJFzzgylXucVkWOaVK1pllxCJw3CYr8ZBOMBMjIUZ0Q+F6aBWQLYJEdJHJmiWGBa5GozhE1LCsEkThJiavJRJqpQxB6hojEchQbiPFCIuiwTC3nlQJcWboHIBZD060TCethmITVwMHxamBVAIIToGgryYM2cpbdUC4hRocgT0GgiDSBr9gokbV4FSPUEORUAtBOBceEFncaSUgW5CQLkZIDEMG7Q4NykQYl23R2x020n66I9XxlqyQFEqjyNBsFeOaLZ3OmayGHR0dcGa1icyIZImbNdo0DkpbVhGRA7SpIxUhWIJmez8RoTo3+ye0zz4QjmhcIKpIJXBg7gmvlbViJJFWBeRMi1Zd7f4001FCNAEroHdylGX2YU1TZBFb9yVWGTPZNhKsWCZep61uE6AJVW4OVOfiKFkSh25XkcvpLXV6+tYIOseyqkC7CgqGkJKafX9k/IWGxSjYEbKTZCZHyXvHY6hu9tZisS5wm0lLabMXs1h56f7x58xQob+ImfIvmegueznmzut0u52+/tsM63FVNHtbsaKT/lsi36KkYTa8gqtccLn35lRSoLV5xOwp83h2Q69q0H1kQxJMckPvTEBFyMkTqezc7qpbmKvm+byCxGyojnlsLpOLkduHFmAVgf0y5C6vcnurXBVoXm0w48+6CU5ajP4gg9ZvhYLMyRU/JUYMNUqktH/Ssg85xtKyhk2BeeRCdmlBsaxXM1HqcrmGZt4TyWBAZNXymPBWVlbexy4oQ7h5wMoPxBPcvmA2S9/yyf3YcyiM7r9sVEkrKojrhfvix2LLcWY+AOcuEVYsHyqajA0LZkKIvRW2txfvjx8LMcspehDO3UNEk9HvkG/U0fP3QI4XbhSN7om+azzpbOUFWTKPwnPI5a5c2lK2tDocqG2pX1NqyKuXRcvilaynTcZm2u10ozClYYXs888V/BjWrxCwR8hMzW5cXF1b4880CPW0hUIvBTH0nEpVkgwQBqNppkWFGhIsO0aSQK+vbjQPVLq8Puz2iWUVEi4VRVF4FXZIbphuDUvC2pT2X+765Oh2/mFK6XObH8uzP1PhOzIifVAbza9+/J2RBds3b/sq8/ePuKT56uCzXfWfbyUf1/z2rXtI9ezeNHIss2fwVOBi/PzR9Stdj2SGdx5J7lCmf1hQFVNWPOMvuhIYaHx5oOvhs4d7ZsxJq763m0/l7VgV1JWGi9X5hZlfirZN7U79caNh4yfKyo/OZFYGC5+6vLH71751R84t7F58/Gbs9KFdWx9qFhdM7zto5s+rez3/UceG/X/Oa/jpiaNiw/HrN9Z31miXCjNPZno/+2Z46OyJlwa3vPnfpnXzu/MTh74+c6VxC5rVtfuVL53DN5t3bue1dYs39s/9fbDhn6ff6joVnnmtq+zS1mknB0KnC947R6KLrn3/7tXMjoLLn9IvhmdVbv7u5wuz49dnHf73Qs3BC9Lypn0hW5qpeX8t2vNBckpe3v9NnJOl

docs/cassettes/introduction_df6d81bb-e674-44ef-a46e-17b1a8d2381a.msgpack.zlib

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

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

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