InMemorySaver

.github/scripts/run_langgraph_cli_test.py

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

.github/workflows/_integration_test.yml

@@ -39,36 +39,22 @@ jobs:
       - name: Install cli globally
         if: steps.changed-files.outputs.all
         run: pip install -e .
-      - name: Build and test service A
+      - name: Start service A
         if: steps.changed-files.outputs.all
-        working-directory: libs/cli/examples
         run: |
-          # The build-arg isn't used; just testing that we accept other args
-          langgraph build -t langgraph-test-a  --base-image "langchain/langgraph-trial"
-          cp .env.example .envg
-          timeout 60 python ../../../.github/scripts/run_langgraph_cli_test.py -c langgraph.json -t langgraph-test-a
-      - name: Build and test service B
+          timeout 60 langgraph test -c examples/langgraph.json --verbose || (exit "$(($? == 124 ? 0 : $?))")
+      - name: Start service B
         if: steps.changed-files.outputs.all
         working-directory: libs/cli/examples/graphs
         run: |
-          langgraph build -t langgraph-test-b  --base-image "langchain/langgraph-trial"
-          timeout 60 python ../../../../.github/scripts/run_langgraph_cli_test.py -t langgraph-test-b
-      - name: Build and test service C
+          timeout 60 langgraph test --verbose || (exit "$(($? == 124 ? 0 : $?))")
+      - name: Start service C
         if: steps.changed-files.outputs.all
         working-directory: libs/cli/examples/graphs_reqs_a
         run: |
-          langgraph build -t langgraph-test-c  --base-image "langchain/langgraph-trial"
-          timeout 60 python ../../../../.github/scripts/run_langgraph_cli_test.py -t langgraph-test-c
-      - name: Build and test service D
+          timeout 60 langgraph test --verbose || (exit "$(($? == 124 ? 0 : $?))")
+      - name: Start service D
         if: steps.changed-files.outputs.all
         working-directory: libs/cli/examples/graphs_reqs_b
         run: |
-          langgraph build -t langgraph-test-d  --base-image "langchain/langgraph-trial"
-          timeout 60 python ../../../../.github/scripts/run_langgraph_cli_test.py -t langgraph-test-d
-
-      - name: Build JS service
-        if: steps.changed-files.outputs.all
-        working-directory: libs/cli/js-examples
-        run: |
-          langgraph build -t langgraph-test-e
-  
+          timeout 60 langgraph test --verbose || (exit "$(($? == 124 ? 0 : $?))")

.github/workflows/_test.yml

@@ -21,7 +21,6 @@ jobs:
           - "3.10"
           - "3.11"
           - "3.12"
-          - "3.13"
 
     name: "test #${{ matrix.python-version }}"
     steps:
@@ -33,12 +32,6 @@ jobs:
           poetry-version: ${{ env.POETRY_VERSION }}
           working-directory: ${{ inputs.working-directory }}
           cache-key: test-${{ inputs.working-directory }}
-      - name: Login to Docker Hub
-        uses: docker/login-action@v3
-        if: ${{ !github.event.pull_request.head.repo.fork }}
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_RO_TOKEN }}
 
       - name: Install dependencies
         shell: bash

.github/workflows/_test_langgraph.yml

@@ -16,22 +16,14 @@ jobs:
           - "3.10"
           - "3.11"
           - "3.12"
-          - "3.13"
         core-version:
+          - ">=0.2.39,<0.3.0"
           - "latest"
-        ff-send-v2:
-          - "false"
-        include:
-          - python-version: "3.11"
-            core-version: ">=0.2.42,<0.3.0"
-          - python-version: "3.11"
-            core-version: "latest"
-            ff-send-v2: "true"
 
     defaults:
       run:
         working-directory: libs/langgraph
-    name: "test #${{ matrix.python-version }} (langchain-core: ${{ matrix.core-version }}, ff-send-v2: ${{ matrix.ff-send-v2 }})"
+    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 }}
@@ -40,12 +32,6 @@ jobs:
           python-version: ${{ matrix.python-version }}
           poetry-version: ${{ env.POETRY_VERSION }}
           cache-key: test-langgraph
-      - name: Login to Docker Hub
-        uses: docker/login-action@v3
-        if: ${{ !github.event.pull_request.head.repo.fork }}
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_RO_TOKEN }}
 
       - name: Install dependencies
         shell: bash
@@ -57,8 +43,6 @@ jobs:
 
       - name: Run tests
         shell: bash
-        env:
-          LANGGRAPH_FF_SEND_V2: ${{ matrix.ff-send-v2 }}
         run: |
           make test
 

.github/workflows/_test_release.yml

@@ -93,5 +93,3 @@ jobs:
           # This is *only for CI use* and is *extremely dangerous* otherwise!
           # https://github.com/pypa/gh-action-pypi-publish#tolerating-release-package-file-duplicates
           skip-existing: true
-          # Temp workaround since attestations are on by default as of gh-action-pypi-publish v1.11.0
-          attestations: false

.github/workflows/_test_scheduler_kafka.yml

@@ -27,12 +27,6 @@ jobs:
           python-version: ${{ matrix.python-version }}
           poetry-version: ${{ env.POETRY_VERSION }}
           cache-key: test-scheduler-kafka
-      - name: Login to Docker Hub
-        uses: docker/login-action@v3
-        if: ${{ !github.event.pull_request.head.repo.fork }}
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_RO_TOKEN }}
 
       - name: Install dependencies
         shell: bash

.github/workflows/ci.yml

@@ -31,7 +31,6 @@ jobs:
             "libs/cli",
             "libs/checkpoint",
             "libs/checkpoint-sqlite",
-            "libs/checkpoint-duckdb",
             "libs/checkpoint-postgres",
             "libs/scheduler-kafka",
           ]
@@ -48,7 +47,6 @@ jobs:
             "libs/cli",
             "libs/checkpoint",
             "libs/checkpoint-sqlite",
-            "libs/checkpoint-duckdb",
             "libs/checkpoint-postgres"
           ]
     uses: ./.github/workflows/_test.yml

.github/workflows/deploy_docs.yml

@@ -44,8 +44,6 @@ jobs:
   deploy:
     # needs: run-changed-notebooks
     runs-on: ubuntu-latest
-    env:
-      GITHUB_TOKEN: ${{ secrets.MKDOCS_GITHUB_TOKEN }}
     steps:
       - uses: actions/checkout@v4
         with:
@@ -60,14 +58,8 @@ jobs:
 
       - name: Install dependencies
         run: |
-          poetry install --with test --no-root
-          poetry run pip install -U \
-            pytest \
-            pytest-check-links \
-            langsmith \
-            langchain \
-            GitPython \
-            "git+https://${GITHUB_TOKEN}@github.com/langchain-ai/mkdocs-material-insiders.git"
+          poetry install --with docs
+          poetry run pip install -U pytest pytest-check-links langsmith langchain GitPython
 
       - name: Lint Docs
         # This step lints the docs using the existing linting set up.
@@ -89,11 +81,7 @@ jobs:
               --check-links-ignore "https://x.com/.*" \
               --check-links-ignore "https://github\.com/.*" \
               --check-links-ignore "/.*\.(ipynb|html)$" \
-              --check-links-ignore "https://python\.langchain\.com/.*" \
-              --check-links-ignore "https://openai\.com/.*" \
-              --check-links-ignore "https://pepy\.tech/.*" \
-              --check-links $(find docs/site -name "index.html" | grep -v 'storm/index.html') 
-              
+              --check-links $(find docs/site -name "index.html" | grep -v 'storm/index.html')
           else
             echo "Fetching changes from origin/main..."
             git fetch origin main

.github/workflows/release.yml

@@ -270,8 +270,6 @@ jobs:
           packages-dir: ${{ inputs.working-directory }}/dist/
           verbose: true
           print-hash: true
-          # Temp workaround since attestations are on by default as of gh-action-pypi-publish v1.11.0
-          attestations: false
 
   mark-release:
     needs:

README.md

@@ -16,8 +16,6 @@
 
 LangGraph is inspired by [Pregel](https://research.google/pubs/pub37252/) and [Apache Beam](https://beam.apache.org/). The public interface draws inspiration from [NetworkX](https://networkx.org/documentation/latest/). LangGraph is built by LangChain Inc, the creators of LangChain, but can be used without LangChain.
 
-[LangGraph Platform](https://langchain-ai.github.io/langgraph/concepts/langgraph_platform) is infrastructure for deploying LangGraph agents. It is a commercial solution for deploying agentic applications to production, built on the open-source LangGraph framework. The LangGraph Platform consists of several components that work together to support the development, deployment, debugging, and monitoring of LangGraph applications: [LangGraph Server](https://langchain-ai.github.io/langgraph/concepts/langgraph_server) (APIs), [LangGraph SDKs](https://langchain-ai.github.io/langgraph/concepts/sdk) (clients for the APIs), [LangGraph CLI](https://langchain-ai.github.io/langgraph/concepts/langgraph_cli) (command line tool for building the server), [LangGraph Studio](https://langchain-ai.github.io/langgraph/concepts/langgraph_studio) (UI/debugger),
-
 To learn more about LangGraph, check out our first LangChain Academy course, *Introduction to LangGraph*, available for free [here](https://academy.langchain.com/courses/intro-to-langgraph).
 
 ### Key Features
@@ -28,16 +26,6 @@ To learn more about LangGraph, check out our first LangChain Academy course, *In
 - **Streaming Support**: Stream outputs as they are produced by each node (including token streaming).
 - **Integration with LangChain**: LangGraph integrates seamlessly with [LangChain](https://github.com/langchain-ai/langchain/) and [LangSmith](https://docs.smith.langchain.com/) (but does not require them).
 
-### LangGraph Platform
-
-LangGraph Platform is a commercial solution for deploying agentic applications to production, built on the open-source LangGraph framework.
-Here are some common issues that arise in complex deployments, which LangGraph Platform addresses:
-
-- **Streaming support**: LangGraph Server provides [multiple streaming modes](https://langchain-ai.github.io/langgraph/concepts/streaming) optimized for various application needs
-- **Background runs**: Runs agents asynchronously in the background
-- **Support for long running agents**: Infrastructure that can handle long running processes
-- **[Double texting](https://langchain-ai.github.io/langgraph/concepts/double_texting)**: Handle the case where you get two messages from the user before the agent can respond
-- **Handle burstiness**: Task queue for ensuring requests are handled consistently without loss, even under heavy loads
 
 ## Installation
 
@@ -72,7 +60,7 @@ from typing import Annotated, Literal, TypedDict
 from langchain_core.messages import HumanMessage
 from langchain_anthropic import ChatAnthropic
 from langchain_core.tools import tool
-from langgraph.checkpoint.memory import MemorySaver
+from langgraph.checkpoint.memory import InMemorySaver
 from langgraph.graph import END, START, StateGraph, MessagesState
 from langgraph.prebuilt import ToolNode
 
@@ -137,7 +125,7 @@ workflow.add_conditional_edges(
 workflow.add_edge("tools", 'agent')
 
 # Initialize memory to persist state between graph runs
-checkpointer = MemorySaver()
+checkpointer = InMemorySaver()
 
 # Finally, we compile it!
 # This compiles it into a LangChain Runnable,
@@ -213,7 +201,7 @@ final_state["messages"][-1].content
     <summary>Compile the graph.</summary>
 
     - When we compile the graph, we turn it into a LangChain [Runnable](https://python.langchain.com/v0.2/docs/concepts/#runnable-interface), which automatically enables calling `.invoke()`, `.stream()` and `.batch()` with your inputs
-    - We can also optionally pass checkpointer object for persisting state between graph runs, and enabling memory, human-in-the-loop workflows, time travel and more. In our case we use `MemorySaver` - a simple in-memory checkpointer
+    - We can also optionally pass checkpointer object for persisting state between graph runs, and enabling memory, human-in-the-loop workflows, time travel and more. In our case we use `InMemorySaver` - a simple in-memory checkpointer
     </details>
 
 6. <details>

docs/_scripts/execute_notebooks.sh

@@ -24,7 +24,7 @@ export -f execute_notebook
 
 # Check if custom notebook paths are provided
 if [ $# -gt 0 ]; then
-    notebooks=$(echo "$@" | tr ' ' '\n' | grep -vFf <(echo "$SKIP_NOTEBOOKS"))
+    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"))

docs/_scripts/generate_api_reference_links.py

@@ -1,246 +0,0 @@
-import importlib
-import inspect
-import logging
-import os
-import re
-from typing import List, Literal, Optional
-from typing_extensions import TypedDict
-
-import nbformat
-from nbconvert.preprocessors import Preprocessor
-
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-# Base URL for all class documentation
-_LANGCHAIN_API_REFERENCE = "https://python.langchain.com/api_reference/"
-_LANGGRAPH_API_REFERENCE = "https://langchain-ai.github.io/langgraph/reference/"
-
-
-# (alias/re-exported modules, source module, class, docs namespace)
-MANUAL_API_REFERENCES_LANGGRAPH = [
-    (
-        ["langgraph.prebuilt"],
-        "langgraph.prebuilt.chat_agent_executor",
-        "create_react_agent",
-        "prebuilt",
-    ),
-    (["langgraph.prebuilt"], "langgraph.prebuilt.tool_node", "ToolNode", "prebuilt"),
-    (
-        ["langgraph.prebuilt"],
-        "langgraph.prebuilt.tool_node",
-        "tools_condition",
-        "prebuilt",
-    ),
-    (
-        ["langgraph.prebuilt"],
-        "langgraph.prebuilt.tool_node",
-        "InjectedState",
-        "prebuilt",
-    ),
-    # Graph
-    (["langgraph.graph"], "langgraph.graph.message", "add_messages", "graphs"),
-    (["langgraph.graph"], "langgraph.graph.state", "StateGraph", "graphs"),
-    (["langgraph.graph"], "langgraph.graph.state", "CompiledStateGraph", "graphs"),
-    ([], "langgraph.types", "StreamMode", "types"),
-    (["langgraph.graph"], "langgraph.constants", "START", "constants"),
-    (["langgraph.graph"], "langgraph.constants", "END", "constants"),
-    (["langgraph.constants"], "langgraph.types", "Send", "types"),
-    (["langgraph.constants"], "langgraph.types", "Interrupt", "types"),
-    ([], "langgraph.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")
-
-
-def _get_full_module_name(module_path, class_name) -> Optional[str]:
-    """Get full module name using inspect"""
-    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"Could not find module for {class_name}, {e}")
-        return None
-    except ImportError as e:
-        logger.warning(f"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  # imported class name
-    source: str  # module path
-    docs: str  # URL to the documentation
-    title: str  # Title of the document
-
-
-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
-
-
-class ImportPreprocessor(Preprocessor):
-    """A preprocessor to replace imports in each Python code cell with links to their
-    documentation and append the import info in a comment."""
-
-    def preprocess(self, nb, resources):
-        self.all_imports = []
-        file_name = os.path.basename(resources.get("metadata", {}).get("name", ""))
-        _DOC_TITLE = _get_doc_title(nb.cells[0].source, file_name)
-
-        cells = []
-        for cell in nb.cells:
-            if cell.cell_type == "code":
-                cells.append(cell)
-                imports = _get_imports(
-                    cell.source, _DOC_TITLE, "langchain"
-                ) + _get_imports(cell.source, _DOC_TITLE, "langgraph")
-                if not imports:
-                    continue
-
-                cells.append(
-                    nbformat.v4.new_markdown_cell(
-                        source=f"""
-<div>
-<b>API Reference:</b>
-{' | '.join(f'<a href="{imp["docs"]}">{imp["imported"]}</a>' for imp in imports)}
-</div>
-                    """
-                    )
-                )
-            else:
-                cells.append(cell)
-        nb.cells = cells
-        return nb, resources

docs/_scripts/notebook_convert.py

@@ -1,126 +0,0 @@
-import os
-import re
-from pathlib import Path
-
-import nbformat
-from nbconvert.exporters import MarkdownExporter
-from nbconvert.preprocessors import Preprocessor
-
-from generate_api_reference_links import ImportPreprocessor
-
-
-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,
-        ImportPreprocessor,
-    ],
-    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

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

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

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

@@ -1,40 +0,0 @@
-import logging
-from typing import Any, Dict
-
-from mkdocs.structure.pages import Page
-from mkdocs.structure.files import Files, File
-from notebook_convert import convert_notebook
-
-logger = logging.getLogger(__name__)
-logging.basicConfig()
-logger.setLevel(logging.INFO)
-
-
-class NotebookFile(File):
-    def is_documentation_page(self):
-        return True
-
-
-def on_files(files: Files, **kwargs: Dict[str, Any]):
-    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 on_page_markdown(markdown: str, page: Page, **kwargs: Dict[str, Any]):
-    if page.file.src_path.endswith(".ipynb"):
-        logger.info("Processing Jupyter notebook: %s", page.file.src_path)
-        body = convert_notebook(page.file.abs_src_path)
-        return body
-
-    return markdown

docs/_scripts/prepare_notebooks_for_ci.py

@@ -40,6 +40,7 @@ NOTEBOOKS_NO_EXECUTION = [
     "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/multi_agent/hierarchical_agent_teams.ipynb",  # taking a very long time to run
+    "docs/docs/tutorials/customer-support/customer-support.ipynb",  # user input - update
     "docs/docs/tutorials/rag/langgraph_crag.ipynb",  # flakiness from tavily
     "docs/docs/tutorials/rag/langgraph_adaptive_rag.ipynb",  # Cannot create a consistent method resolution error from VCR
     "docs/docs/how-tos/map-reduce.ipynb"  # flakiness from structured output, only when running with VCR
@@ -69,13 +70,10 @@ 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
-    
+def has_blocklisted_command(code: str) -> bool:
     code = code.strip()
-    for blocklisted_pattern in BLOCKLIST_COMMANDS:
-        if blocklisted_pattern in code:
+    for blocklisted_command in BLOCKLIST_COMMANDS:
+        if blocklisted_command in code:
             return True
     return False
 
@@ -110,7 +108,7 @@ def add_vcr_to_notebook(
         if all(is_comment(line) or not line.strip() for line in lines):
             continue
 
-        if has_blocklisted_command(cell.source, cell.metadata):
+        if has_blocklisted_command(cell.source):
             continue
 
         cell_id = cell.get("id", idx)
@@ -127,8 +125,6 @@ def add_vcr_to_notebook(
         "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):",

docs/docs/cloud/concepts/api.md

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

docs/docs/cloud/concepts/cloud.md

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

docs/docs/cloud/deployment/cloud.md

@@ -11,7 +11,7 @@ LangGraph Cloud is available within <a href="https://www.langchain.com/langsmith
 
 Starting from the <a href="https://smith.langchain.com/" target="_blank">LangSmith UI</a>...
 
-1. In the left-hand navigation panel, select `LangGraph Cloud`. The `LangGraph Cloud` view contains a list of existing LangGraph Cloud deployments.
+1. In the left-hand navigation panel, select `Deployments`. The `Deployments` view contains a list of existing LangGraph Cloud deployments.
 1. In the top-right corner, select `+ New Deployment` to create a new deployment.
 1. In the `Create New Deployment` panel, fill out the required fields.
     1. `Deployment details`
@@ -38,7 +38,7 @@ When [creating a new deployment](#create-new-deployment), a new revision is crea
 
 Starting from the <a href="https://smith.langchain.com/" target="_blank">LangSmith UI</a>...
 
-1. In the left-hand navigation panel, select `LangGraph Cloud`. The `LangGraph Cloud` view contains a list of existing LangGraph Cloud deployments.
+1. In the left-hand navigation panel, select `Deployments`. The `Deployments` view contains a list of existing LangGraph Cloud deployments.
 1. Select an existing deployment to create a new revision for.
 1. In the `Deployment` view, in the top-right corner, select `+ New Revision`.
 1. In the `New Revision` modal, fill out the required fields.
@@ -56,7 +56,7 @@ Starting from the <a href="https://smith.langchain.com/" target="_blank">LangSmi
 
 Build and deployment logs are available for each revision.
 
-Starting from the `LangGraph Cloud` view...
+Starting from the `Deployment` view...
 
 1. Select the desired revision from the `Revisions` table. A panel slides open from the right-hand side and the `Build` tab is selected by default, which displays build logs for the revision.
 1. In the panel, select the `Deploy` tab to view deployment logs for the revision.
@@ -69,7 +69,7 @@ Interrupting a revision will stop deployment of the revision.
 !!! warning "Undefined Behavior"
     Interrupted revisions have undefined behavior. This is only useful if you need to deploy a new revision and you already have a revision "stuck" in progress. In the future, this feature may be removed.
 
-Starting from the `LangGraph Cloud` view...
+Starting from the `Deployment` view...
 
 1. Select the menu icon (three dots) on the right-hand side of the row for the desired revision from the `Revisions` table.
 1. Select `Interrupt` from the menu.
@@ -79,13 +79,13 @@ Starting from the `LangGraph Cloud` view...
 
 Starting from the <a href="https://smith.langchain.com/" target="_blank">LangSmith UI</a>...
 
-1. In the left-hand navigation panel, select `LangGraph Cloud`. The `LangGraph Cloud` view contains a list of existing LangGraph Cloud deployments.
+1. In the left-hand navigation panel, select `Deployments`. The `Deployments` view contains a list of existing LangGraph Cloud deployments.
 1. Select the menu icon (three dots) on the right-hand side of the row for the desired deployment and select `Delete`.
 1. A `Confirmation` modal will appear. Select `Delete`.
 
 ## Deployment Settings
 
-Starting from the `LangGraph Cloud` view...
+Starting from the `Deployment` view...
 
 1. In the top-right corner, select the gear icon (`Deployment Settings`).
 1. Update the `Git Branch` to the desired branch.

docs/docs/cloud/deployment/test_locally.md

@@ -8,17 +8,11 @@ Testing locally ensures that there are no errors or conflicts with Python depend
 
 Install the proper packages:
 
+```shell
+pip install langgraph-cli
+```
 
-=== "pip" 
-    ```bash
-    pip install -U langgraph-cli
-    ```
-=== "Homebrew (macOS only)"
-    ```bash
-    brew install langgraph-cli
-    ```
-
-Ensure you have an API key, which you can create from the [LangSmith UI](https://smith.langchain.com) (Settings > API Keys). This is required to authenticate that you have LangGraph Cloud access. After you have saved the key to a safe place, place the following line in your `.env` file:
+Ensure you have an API key, which you can create from the LangSmith UI (Settings > API Keys). This is required to authenticate that you have LangGraph Cloud access. After you have saved the key to a safe place, place the following line in your `.env` file:
 
 ```python
 LANGCHAIN_API_KEY = *********
@@ -26,7 +20,7 @@ LANGCHAIN_API_KEY = *********
 
 ## Start the API server
 
-Once you have installed the CLI, you can run the following command to start the API server for local testing:
+Once you have downloaded the CLI, you can run the following command to start the API server for local testing:
 
 ```shell
 langgraph up
@@ -189,4 +183,4 @@ Now we can invoke our graph to ensure it is working. Make sure to change the inp
      ' 
     ```
 
-If your graph works correctly, you should see your graph output displayed in the console. Of course, there are many more ways you might need to test your graph, for a full list of commands you can send with the SDK, see the [Python](https://langchain-ai.github.io/langgraph/cloud/reference/sdk/python_sdk_ref/) and [JS/TS](https://langchain-ai.github.io/langgraph/cloud/reference/sdk/js_ts_sdk_ref/) references.
+If your graph works correctly, you should see your graph output displayed in the console. Of course, there are many more ways you might need to test your graph, for a full list of commands you can send with the SDK, see the [Python](https://langchain-ai.github.io/langgraph/cloud/reference/sdk/python_sdk_ref/) and [JS/TS](https://langchain-ai.github.io/langgraph/cloud/reference/sdk/js_ts_sdk_ref/) references.

docs/docs/cloud/faq/studio.md

@@ -1,76 +1,39 @@
-# LangGraph Studio
+# Studio FAQs
 
-!!! info "Prerequisites"
-
-    - [LangGraph Platform](./langgraph_platform.md)
-    - [LangGraph Server](./langgraph_server.md)
-
-LangGraph Studio offers a new way to develop LLM applications by providing a specialized agent IDE that enables visualization, interaction, and debugging of complex agentic applications.
-
-With visual graphs and the ability to edit state, you can better understand agent workflows and iterate faster. LangGraph Studio integrates with LangSmith allowing you to  collaborate with teammates to debug failure modes.
-
-![](img/lg_studio.png)
-
-## Features
-
-The key features of LangGraph Studio are:
-
-- Visualizes your graph
-- Test your graph by running it from the UI
-- Debug your agent by [modifying its state and rerunning](human_in_the_loop.md)
-- Create and manage [assistants](assistants.md)
-- View and manage [threads](persistence.md#threads)
-- View and manage [long term memory](memory.md)
-- Add node input/outputs to [LangSmith](https://smith.langchain.com/) datasets for testing
-
-## Types
-
-### Desktop app
-
-LangGraph Studio is available as a [desktop app](https://studio.langchain.com/) for MacOS users.
-
-While in Beta, LangGraph Studio is available for free to all [LangSmith](https://smith.langchain.com/) users on any plan tier.
-
-### Cloud studio
-
-If you have deployed your LangGraph application on LangGraph Platform (Cloud), you can access the studio as part of that
-
-## Studio FAQs
-
-### Why is my project failing to start?
+## Why is my project failing to start?
 
 There are a few reasons that your project might fail to start, here are some of the most common ones.
 
-#### Docker issues (desktop only)
+### Docker issues
 
-LangGraph Studio (desktop) requires Docker Desktop version 4.24 or higher. Please make sure you have a version of Docker installed that satisfies that requirement and also make sure you have the Docker Desktop app up and running before trying to use LangGraph Studio. In addition, make sure you have docker-compose updated to version 2.22.0 or higher.
+LangGraph Studio requires Docker Desktop version 4.24 or higher. Please make sure you have a version of Docker installed that satisfies that requirement and also make sure you have the Docker Desktop app up and running before trying to use LangGraph Studio. In addition, make sure you have docker-compose updated to version 2.22.0 or higher.
 
-#### Configuration or environment issues
+### Configuration or environment issues
 
 Another reason your project might fail to start is because your configuration file is defined incorrectly, or you are missing required environment variables. 
 
-### How does interrupt work?
+## How does interrupt work?
 
 When you select the `Interrupts` dropdown and select a node to interrupt the graph will pause execution before and after (unless the node goes straight to `END`) that node has run. This means that you will be able to both edit the state before the node is ran and the state after the node has ran. This is intended to allow developers more fine-grained control over the behavior of a node and make it easier to observe how the node is behaving. You will not be able to edit the state after the node has ran if the node is the final node in the graph.
 
-### How do I reload the app?  (desktop only)
+## How do I reload the app?
 
 If you would like to reload the app, don't use Command+R as you might normally do. Instead, close and reopen the app for a full refresh.
 
-### How does automatic rebuilding work?  (desktop only)
+## How does automatic rebuilding work?
 
 One of the key features of LangGraph Studio is that it automatically rebuilds your image when you change the source code. This allows for a super fast development and testing cycle which makes it easy to iterate on your graph. There are two different ways that LangGraph rebuilds your image: either by editing the image or completely rebuilding it.
 
-#### Rebuilds from source code changes
+### Rebuilds from source code changes
 
 If you modified the source code only (no configuration or dependency changes!) then the image does not require a full rebuild, and LangGraph Studio will only update the relevant parts. The UI status in the bottom left will switch from `Online` to `Stopping` temporarily while the image gets edited. The logs will be shown as this process is happening, and after the image has been edited the status will change back to `Online` and you will be able to run your graph with the modified code!
 
 
-#### Rebuilds from configuration or dependency changes
+### Rebuilds from configuration or dependency changes
 
 If you edit your graph configuration file (`langgraph.json`) or the dependencies (either `pyproject.toml` or `requirements.txt`) then the entire image will be rebuilt. This will cause the UI to switch away from the graph view and start showing the logs of the new image building process. This can take a minute or two, and once it is done your updated image will be ready to use!
 
-### Why is my graph taking so long to startup?  (desktop only)
+## Why is my graph taking so long to startup?
 
 The LangGraph Studio interacts with a local LangGraph API server. To stay aligned with ongoing updates, the LangGraph API requires regular rebuilding. As a result, you may occasionally experience slight delays when starting up your project.
 
@@ -108,9 +71,3 @@ def routing_function(state: GraphState) -> Literal["node_b","node_c"]:
         return "node_c"
 ```
 
-
-## Related
-
-For more information please see the following:
-
-*  [LangGraph Studio how-to guides](../how-tos/index.md#langgraph-studio)

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

@@ -1,6 +1,6 @@
 # How to version assistants
 
-In this how-to guide we will walk through how you can create and manage different assistant versions. If you haven't already, you can read [this](../../concepts/assistants.md#versioning-assistants) conceptual guide to gain a better understanding of what assistant versioning is. This how-to assumes you have a graph that is configurable, which means you have defined a config schema and passed it to your graph as follows:
+In this how-to guide we will walk through how you can create and manage different assistant versions. If you haven't already, you can read [this](../concepts/api.md/#versioning-assistants) conceptual guide to gain a better understanding of what assistant versioning is. This how-to assumes you have a graph that is configurable, which means you have defined a config schema and passed it to your graph as follows:
 
 === "Python"
 
@@ -86,19 +86,19 @@ To create an assistant using the studio do the following steps:
 
 1. Click on the "Create New Assistant" button:
 
-    ![click create](./img/click_create_assistant.png)
+![click create](./img/click_create_assistant.png)
 
-1. Use the create assistant pane to enter info for the assistant you wish to create, and then click create:
+2. Use the create assistant pane to enter info for the assistant you wish to create, and then click create:
 
-    ![create](./img/create_assistant.png)
+![create](./img/create_assistant.png)
 
-1. See that your assistant was created and is displayed in the Studio
+3. See that your assistant was created and is displayed in the Studio
 
-    ![view create](./img/create_assistant_view.png)
+![view create](./img/create_assistant_view.png)
 
-1. Click on the edit button next to the selected assistant to manage your created assistant:
+4. Click on the edit button next to the selected assistant to manage your created assistant:
 
-    ![create edit](./img/edit_created_assistant.png)
+![create edit](./img/edit_created_assistant.png)
 
 ## Create a new version for your assistant
 
@@ -131,15 +131,15 @@ Let's now say we wanted to add a system prompt to our assistant. We can do this
 
 1. First, click on the edit button next to the `openai_assistant`. Then, add a system prompt and click "Save New Version":
 
-    ![create new version](./img/create_new_version.png)
+![create new version](./img/create_new_version.png)
 
-1. Then you can see it is selected in the assistant dropdown:
+2. Then you can see it is selected in the assistant dropdown:
 
-    ![see version dropdown](./img/see_new_version.png)
+![see version dropdown](./img/see_new_version.png)
 
-1. And you can see all the version history in the edit pane for the assistant:
+3. And you can see all the version history in the edit pane for the assistant:
 
-    ![see versions](./img/see_version_history.png)
+![see versions](./img/see_version_history.png)
 
 ## Point your assistant to a different version
 

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

@@ -4,7 +4,7 @@ You may wish to copy (i.e. "fork") an existing thread in order to keep the exist
 
 ## Setup
 
-This code assumes you already have a thread to copy. You can read about what a thread is [here](../../concepts/langgraph_server.md#threads) and learn how to stream a run on a thread in [these how-to guides](../../how-tos/index.md#streaming_1).
+This code assumes you already have a thread to copy. You can read about what a thread is [here](https://langchain-ai.github.io/langgraph/cloud/concepts/api/#threads) and learn how to stream a run on a thread in [these how-to guides](https://langchain-ai.github.io/langgraph/cloud/how-tos/#streaming).
 
 ### SDK initialization
 

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

@@ -1,6 +1,6 @@
 # Enqueue
 
-This guide assumes knowledge of what double-texting is, which you can learn about in the [double-texting conceptual guide](../../concepts/double_texting.md).
+This guide assumes knowledge of what double-texting is, which you can learn about in the [double-texting conceptual guide](../concepts/api.md#double-texting).
 
 The guide covers the `enqueue` option for double texting, which adds the interruptions to a queue and executes them in the order they are received by the client. Below is a quick example of using the `enqueue` option.
 

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

@@ -6,7 +6,7 @@ This can be in several ways, but the primary supported way is to add an "interru
 
 ## Setup
 
-We are not going to show the full code for the graph we are hosting, but you can see it [here](../../how-tos/human_in_the_loop/edit-graph-state.ipynb#agent) if you want to. Once this graph is hosted, we are ready to invoke it and wait for user input.
+We are not going to show the full code for the graph we are hosting, but you can see it [here](../../how-tos/human_in_the_loop/edit-graph-state.ipynb#build-the-agent) if you want to. Once this graph is hosted, we are ready to invoke it and wait for user input. 
 
 ### SDK initialization
 

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

@@ -14,7 +14,7 @@ Luckily, LangGraph makes it possible to do similar things in a production way. T
 
 ## Setup
 
-We are not going to show the full code for the graph we are hosting, but you can see it [here](../../how-tos/human_in_the_loop/wait-user-input.ipynb#agent) if you want to. Once this graph is hosted, we are ready to invoke it and wait for user input.
+We are not going to show the full code for the graph we are hosting, but you can see it [here](../../how-tos/human_in_the_loop/wait-user-input.ipynb#build-the-agent) if you want to. Once this graph is hosted, we are ready to invoke it and wait for user input. 
 
 ### SDK initialization
 

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

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

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

@@ -1,6 +1,6 @@
 # Interrupt
 
-This guide assumes knowledge of what double-texting is, which you can learn about in the [double-texting conceptual guide](../../concepts/double_texting.md).
+This guide assumes knowledge of what double-texting is, which you can learn about in the [double-texting conceptual guide](../concepts/api.md#double-texting).
 
 The guide covers the `interrupt` option for double texting, which interrupts the prior run of the graph and starts a new one with the double-text. This option does not delete the first run, but rather keeps it in the database but sets its status to `interrupted`. Below is a quick example of using the `interrupt` option.
 
@@ -94,7 +94,6 @@ Now we can start our two runs and join the second on euntil it has completed:
         assistant_id,
         input={"messages": [{"role": "user", "content": "what's the weather in sf?"}]},
     )
-    # sleep a bit to get partial outputs from the first run
     await asyncio.sleep(2)
     run = await client.runs.create(
         thread["thread_id"],
@@ -115,7 +114,6 @@ Now we can start our two runs and join the second on euntil it has completed:
       assistantId,
       { input: { messages: [{ role: "human", content: "what's the weather in sf?" }] } }
     );
-    // sleep a bit to get partial outputs from the first run
     await new Promise(resolve => setTimeout(resolve, 2000)); 
 
     let run = await client.runs.create(

docs/docs/cloud/how-tos/langgraph_to_langgraph_cloud.ipynb

@@ -392,7 +392,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from langgraph.checkpoint.memory import MemorySaver"
+        "from langgraph.checkpoint.memory import InMemorySaver"
       ]
     },
     {
@@ -402,7 +402,7 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "checkpointer = MemorySaver()\n",
+        "checkpointer = InMemorySaver()\n",
         "graph_with_memory = create_react_agent(model, tools, checkpointer=checkpointer)"
       ]
     },

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

@@ -1,6 +1,6 @@
 # Reject
 
-This guide assumes knowledge of what double-texting is, which you can learn about in the [double-texting conceptual guide](../../concepts/double_texting.md).
+This guide assumes knowledge of what double-texting is, which you can learn about in the [double-texting conceptual guide][double-texting].
 
 The guide covers the `reject` option for double texting, which rejects the new run of the graph by throwing an error and continues with the original run until completion. Below is a quick example of using the `reject` option.
 

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

@@ -1,6 +1,6 @@
 # Rollback
 
-This guide assumes knowledge of what double-texting is, which you can learn about in the [double-texting conceptual guide](../../concepts/double_texting.md).
+This guide assumes knowledge of what double-texting is, which you can learn about in the [double-texting conceptual guide][double-texting].
 
 The guide covers the `rollback` option for double texting, which interrupts the prior run of the graph and starts a new one with the double-text. This option is very similar to the `interrupt` option, but in this case the first run is completely deleted from the database and cannot be restarted. Below is a quick example of using the `rollback` option.
 
@@ -95,6 +95,7 @@ Now let's run a thread with the multitask parameter set to "rollback":
         assistant_id,
         input={"messages": [{"role": "user", "content": "what's the weather in sf?"}]},
     )
+    await asyncio.sleep(2)
     run = await client.runs.create(
         thread["thread_id"],
         assistant_id,
@@ -114,6 +115,7 @@ Now let's run a thread with the multitask parameter set to "rollback":
       assistantId,
       { input: { messages: [{ role: "human", content: "what's the weather in sf?" }] } }
     );
+    await new Promise(resolve => setTimeout(resolve, 2000)); 
 
     let run = await client.runs.create(
       thread["thread_id"],
@@ -137,7 +139,7 @@ Now let's run a thread with the multitask parameter set to "rollback":
     --data "{
       \"assistant_id\": \"agent\",
       \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"what\'s the weather in sf?\"}]},
-    }" && curl --request POST \
+    }" && sleep 2 && curl --request POST \
     --url <DEPLOY<ENT_URL>>/threads/<THREAD_ID>/runs \
     --header 'Content-Type: application/json' \
     --data "{

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

@@ -1,8 +1,5 @@
 # How to stream debug events
 
-!!! info "Prerequisites"
-    * [Streaming](../../concepts/streaming.md)
-
 This guide covers how to stream debug events from your graph (`stream_mode="debug"`). Streaming debug events produces responses containing `type` and `timestamp` keys. Debug events correspond to different steps in the graph's execution, and there are three different types of steps that will get streamed back to you:
 
 - `checkpoint`: These events will get streamed anytime the graph saves its state, which occurs after every super-step. Read more about checkpoints [here](https://langchain-ai.github.io/langgraph/concepts/low_level/#checkpointer)

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

@@ -1,9 +1,6 @@
 # How to stream events
 
-!!! info "Prerequisites"
-    * [Streaming](../../concepts/streaming.md#streaming-llm-tokens-and-events-astream_events)
-
-This guide covers how to stream events from your graph (`stream_mode="events"`). Depending on the use case and user experience of your LangGraph application, your application may process event types differently.
+This guide covers how to stream events from your graph (`stream_mode="events"`). Depending on the use case and user experience of your LangGraph application, your application may process event types differently. Read more about events in this [conceptual guide](https://langchain-ai.github.io/langgraph/concepts/low_level/#astream_events-for-streaming-tokens-of-llm-calls).
 
 ## Setup
 
@@ -292,4 +289,131 @@ Output:
     
     
     Receiving new event of type: end...
-    None
+    None
+
+
+## Token-by-Token Streaming
+
+Token-by-token streaming can be implemented with the `events` streaming mode. The `on_chat_model_stream` event type should be processed to stream LLM responses token-by-token.
+
+=== "Python"
+
+    ```python
+    llm_response = ""
+
+    # stream token-by-token
+    async for chunk in client.runs.stream(
+        thread_id=thread["thread_id"],
+        assistant_id=assistant_id,
+        input=input,
+        stream_mode="events",
+    ):
+        if (
+            chunk.event == "events" and
+            chunk.data["event"] == "on_chat_model_stream" and
+            len(chunk.data["data"]["chunk"]["content"]) > 0 and
+            'text' in chunk.data["data"]["chunk"]["content"][0]
+        ):
+            llm_response += chunk.data["data"]["chunk"]["content"][0]['text']
+            print(llm_response)
+    ```
+
+=== "Javascript"
+
+    ```js
+    const llmResponse = "";
+    // stream events
+    const streamResponse = client.runs.stream(
+      thread["thread_id"],
+      assistantID,
+      {
+        input,
+        streamMode: "events"
+      }
+    );
+    for await (const chunk of streamResponse) {
+      if (chunk.event === "events" && chunk.data.event === "on_chat_model_stream" && chunk.data.chunk.content.length > 0 && 'text' in chunk.data.chunk.content[0]) {
+        llmResponse += chunk.data.data.chunk.content[0].text;
+        console.log(llmResponse);
+      }
+    }
+    ```
+
+=== "CURL"
+
+    ```bash
+    curl --request POST \
+     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
+     --header 'Content-Type: application/json' \
+     --data "{
+       \"assistant_id\": \"agent\",
+       \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"What's the weather in sf\"}]},
+       \"stream_mode\": [
+         \"events\"
+       ]
+     }" | sed 's/\r$//' | awk '
+    /^event:/ { event = $2 }
+    /^data:/ {
+        json_data = substr($0, index($0, $2))
+
+        if (event == "events") {
+        print json_data
+        }
+    }' | jq -r '
+        select(.event == "on_chat_model_stream") |
+        .data.chunk.content[] | .text // empty
+    ' | awk '
+    BEGIN { llm_response="" }
+    $0 != "" && $0 != "null" {
+        llm_response = llm_response $0
+        print llm_response
+    }'
+    ```
+
+Output:
+
+    The
+    The search
+    The search results provide
+    The search results provide the current weather conditions
+    The search results provide the current weather conditions in San Francisco.
+    The search results provide the current weather conditions in San Francisco. According
+    The search results provide the current weather conditions in San Francisco. According to the data,
+    The search results provide the current weather conditions in San Francisco. According to the data, as
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12,
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024,
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C).
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The win
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is bl
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 k
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph).
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70%
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70% and visibility
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70% and visibility is 6
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70% and visibility is 6 miles
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70% and visibility is 6 miles (10 km
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70% and visibility is 6 miles (10 km).
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70% and visibility is 6 miles (10 km). Overall
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70% and visibility is 6 miles (10 km). Overall, it appears
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70% and visibility is 6 miles (10 km). Overall, it appears to be a nice
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70% and visibility is 6 miles (10 km). Overall, it appears to be a nice sunny day in San
+    The search results provide the current weather conditions in San Francisco. According to the data, as of 3:19 PM on August 12, 2024, the weather in San Francisco is sunny with a temperature of 60.8°F (16°C). The wind is blowing from the west-southwest at 13.4 mph (21.6 kph). The humidity is 70% and visibility is 6 miles (10 km). Overall, it appears to be a nice sunny day in San Francisco.
+
+

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

@@ -1,9 +1,43 @@
 # How to stream messages from your graph
 
-!!! info "Prerequisites"
-    * [Streaming](../../concepts/streaming.md)
+This guide covers how to stream messages from your graph. In order to use this mode, the state of the graph you are interacting with MUST have a `messages` key that is a list of messages.
 
-This guide covers how to stream messages from your graph. With `stream_mode="messages-tuple"`, messages (i.e. individual LLM tokens) from any chat model invocations inside your graph nodes will be streamed back.
+E.g., the state should look something like:
+
+=== "Python"
+
+    ```python
+    from typing import Annotated
+    from typing_extensions import TypedDict
+    from langgraph.graph import add_messages
+    from langchain_core.messages import AnyMessage
+
+    class State(TypedDict):
+        messages: Annotated[list[AnyMessage], add_messages]
+    ```
+
+=== "Javascript"
+
+    ```js
+    import { type BaseMessage } from "@langchain/core/messages";
+    import { Annotation, messagesStateReducer } from "@langchain/langgraph";
+
+    export const StateAnnotation = Annotation.Root({
+      messages: Annotation<BaseMessage[]>({
+        reducer: messagesStateReducer,
+        default: () => [],
+      }),
+    });
+    ```
+
+Alternatively, you can use an instance or subclass of `from langgraph.graph import MessagesState` (`MessagesState` is equivalent to the implementation above). Or in Javascript: `import { MessagesAnnotation } from "@langchain/langgraph";`.
+
+With `stream_mode="messages"` two things will be streamed back:
+
+- It outputs messages produced by any chat model called inside (unless tagged in a special way)
+- It outputs messages returned from nodes (to allow for nodes to return `ToolMessages` and the like)
+
+Read more about how the `messages` streaming mode works [here](https://langchain-ai.github.io/langgraph/cloud/concepts/api/#modemessages)
 
 ## Setup
 
@@ -56,9 +90,101 @@ Output:
         'values': None
     }
 
+Let's also define a helper function for better formatting of the tool calls in messages (for CURL we will define a helper script called `process_stream.sh`)
+
+=== "Python"
+
+    ```python
+    def format_tool_calls(tool_calls):
+        if tool_calls:
+            formatted_calls = []
+            for call in tool_calls:
+                formatted_calls.append(
+                    f"Tool Call ID: {call['id']}, Function: {call['name']}, Arguments: {call['args']}"
+                )
+            return "\n".join(formatted_calls)
+        return "No tool calls"
+    ```
+
+=== "Javascript"
+
+    ```js
+    function formatToolCalls(toolCalls) {
+      if (toolCalls && toolCalls.length > 0) {
+        const formattedCalls = toolCalls.map(call => {
+          return `Tool Call ID: ${call.id}, Function: ${call.name}, Arguments: ${call.args}`;
+        });
+        return formattedCalls.join("\n");
+      }
+      return "No tool calls";
+    }
+    ```
+
+=== "CURL"
+
+    ```bash
+    # process_stream.sh
+
+    format_tool_calls() {
+        echo "$1" | jq -r 'map("Tool Call ID: \(.id), Function: \(.name), Arguments: \(.args)") | join("\n")'
+    }
+
+    process_data_item() {
+        local data_item="$1"
+
+        if echo "$data_item" | jq -e '.role == "user"' > /dev/null; then
+            echo "Human: $(echo "$data_item" | jq -r '.content')"
+        else
+            local tool_calls=$(echo "$data_item" | jq -r '.tool_calls // []')
+            local invalid_tool_calls=$(echo "$data_item" | jq -r '.invalid_tool_calls // []')
+            local content=$(echo "$data_item" | jq -r '.content // ""')
+            local response_metadata=$(echo "$data_item" | jq -r '.response_metadata // {}')
+
+            if [ -n "$content" ] && [ "$content" != "null" ]; then
+                echo "AI: $content"
+            fi
+
+            if [ "$tool_calls" != "[]" ]; then
+                echo "Tool Calls:"
+                format_tool_calls "$tool_calls"
+            fi
+
+            if [ "$invalid_tool_calls" != "[]" ]; then
+                echo "Invalid Tool Calls:"
+                format_tool_calls "$invalid_tool_calls"
+            fi
+
+            if [ "$response_metadata" != "{}" ]; then
+                local finish_reason=$(echo "$response_metadata" | jq -r '.finish_reason // "N/A"')
+                echo "Response Metadata: Finish Reason - $finish_reason"
+            fi
+        fi
+    }
+
+    while IFS=': ' read -r key value; do
+        case "$key" in
+            event)
+                event="$value"
+                ;;
+            data)
+                if [ "$event" = "metadata" ]; then
+                    run_id=$(echo "$value" | jq -r '.run_id')
+                    echo "Metadata: Run ID - $run_id"
+                    echo "------------------------------------------------"
+                elif [ "$event" = "messages/partial" ]; then
+                    echo "$value" | jq -c '.[]' | while read -r data_item; do
+                        process_data_item "$data_item"
+                    done
+                    echo "------------------------------------------------"
+                fi
+                ;;
+        esac
+    done
+    ```
+
 ## Stream graph in messages mode
 
-Now we can stream LLM tokens for any messages generated inside a node in the form of tuples `(message, metadata)`. Metadata contains additional information that can be useful for filtering the streamed outputs to a specific node or LLM.
+Now we can stream by messages, which will return complete messages (at the end of node execution) as well as tokens for any messages generated inside a node:
 
 === "Python"
 
@@ -66,16 +192,41 @@ Now we can stream LLM tokens for any messages generated inside a node in the for
     input = {"messages": [{"role": "user", "content": "what's the weather in sf"}]}
     config = {"configurable": {"model_name": "openai"}}
 
-    async for chunk in client.runs.stream(
+    async for event in client.runs.stream(
         thread["thread_id"],
         assistant_id=assistant_id,
         input=input,
         config=config,
-        stream_mode="messages-tuple",
+        stream_mode="messages",
     ):
-        print(f"Receiving new event of type: {chunk.event}...")
-        print(chunk.data)
-        print("\n\n")
+        if event.event == "metadata":
+            print(f"Metadata: Run ID - {event.data['run_id']}")
+            print("-" * 50)
+        elif event.event == "messages/partial":
+            for data_item in event.data:
+                if "role" in data_item and data_item["role"] == "user":
+                    print(f"Human: {data_item['content']}")
+                else:
+                    tool_calls = data_item.get("tool_calls", [])
+                    invalid_tool_calls = data_item.get("invalid_tool_calls", [])
+                    content = data_item.get("content", "")
+                    response_metadata = data_item.get("response_metadata", {})
+
+                    if content:
+                        print(f"AI: {content}")
+
+                    if tool_calls:
+                        print("Tool Calls:")
+                        print(format_tool_calls(tool_calls))
+
+                    if invalid_tool_calls:
+                        print("Invalid Tool Calls:")
+                        print(format_tool_calls(invalid_tool_calls))
+
+                    if response_metadata:
+                        finish_reason = response_metadata.get("finish_reason", "N/A")
+                        print(f"Response Metadata: Finish Reason - {finish_reason}")
+            print("-" * 50)
     ```
 
 === "Javascript"
@@ -97,13 +248,46 @@ Now we can stream LLM tokens for any messages generated inside a node in the for
       {
         input,
         config,
-        streamMode: "messages-tuple"
+        streamMode: "messages"
       }
     );
-    for await (const chunk of streamResponse) {
-      console.log(`Receiving new event of type: ${chunk.event}...`);
-      console.log(chunk.data);
-      console.log("\n\n");
+
+    for await (const event of streamResponse) {
+      if (event.event === "metadata") {
+        console.log(`Metadata: Run ID - ${event.data.run_id}`);
+        console.log("-".repeat(50));
+      } else if (event.event === "messages/partial") {
+        event.data.forEach(dataItem => {
+          if (dataItem.role && dataItem.role === "user") {
+            console.log(`Human: ${dataItem.content}`);
+          } else {
+            const toolCalls = dataItem.tool_calls || [];
+            const invalidToolCalls = dataItem.invalid_tool_calls || [];
+            const content = dataItem.content || "";
+            const responseMetadata = dataItem.response_metadata || {};
+
+            if (content) {
+              console.log(`AI: ${content}`);
+            }
+
+            if (toolCalls.length > 0) {
+              console.log("Tool Calls:");
+              console.log(formatToolCalls(toolCalls));
+            }
+
+            if (invalidToolCalls.length > 0) {
+              console.log("Invalid Tool Calls:");
+              console.log(formatToolCalls(invalidToolCalls));
+            }
+
+            if (responseMetadata) {
+              const finishReason = responseMetadata.finish_reason || "N/A";
+              console.log(`Response Metadata: Finish Reason - ${finishReason}`);
+            }
+          }
+        });
+        console.log("-".repeat(50));
+      }
     }
     ```
 
@@ -111,221 +295,203 @@ Now we can stream LLM tokens for any messages generated inside a node in the for
 
     ```bash
     curl --request POST \
-     --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-     --header 'Content-Type: application/json' \
-     --data "{
-       \"assistant_id\": \"agent\",
-       \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"what's the weather in la\"}]},
-       \"stream_mode\": [
-         \"messages-tuple\"
-       ]
-     }" | \
-     sed 's/\r$//' | \
-     awk '
-     /^event:/ {
-         if (data_content != "") {
-             print data_content "\n"
-         }
-         sub(/^event: /, "Receiving event of type: ", $0)
-         printf "%s...\n", $0
-         data_content = ""
-     }
-     /^data:/ {
-         sub(/^data: /, "", $0)
-         data_content = $0
-     }
-     END {
-         if (data_content != "") {
-             print data_content "\n"
-         }
-     }
-     '
+    --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
+    --header 'Content-Type: application/json' \
+    --data "{
+    \"assistant_id\": \"agent\",
+    \"config\":{\"configurable\":{\"model_name\":\"openai\"}},
+    \"input\": {\"messages\": [{\"role\": \"human\", \"content\": \"What's the weather in sf\"}]},
+    \"stream_mode\": [
+    \"messages\"
+    ]
+    }" | sed 's/\r$//' | ./process_stream.sh
     ```
 
 
 Output:
 
-    Receiving new event of type: metadata...
-    {"run_id": "1ef971e0-9a84-6154-9047-247b4ce89c4d", "attempt": 1}
+    Metadata: Run ID - 1ef2fe5c-6a1d-6575-bc09-d7832711c17e
+    --------------------------------------------------
+    Invalid Tool Calls:
+    Tool Call ID: call_cg14F20jMBqWYrNgEkdWHwB3, Function: tavily_search_results_json, Arguments: 
+    --------------------------------------------------
+    Tool Calls:
+    Tool Call ID: call_cg14F20jMBqWYrNgEkdWHwB3, Function: tavily_search_results_json, Arguments: {}
+    --------------------------------------------------
+    Tool Calls:
+    Tool Call ID: call_cg14F20jMBqWYrNgEkdWHwB3, Function: tavily_search_results_json, Arguments: {}
+    --------------------------------------------------
+    Tool Calls:
+    Tool Call ID: call_cg14F20jMBqWYrNgEkdWHwB3, Function: tavily_search_results_json, Arguments: {'query': ''}
+    --------------------------------------------------
+    Tool Calls:
+    Tool Call ID: call_cg14F20jMBqWYrNgEkdWHwB3, Function: tavily_search_results_json, Arguments: {'query': 'current'}
+    --------------------------------------------------
+    Tool Calls:
+    Tool Call ID: call_cg14F20jMBqWYrNgEkdWHwB3, Function: tavily_search_results_json, Arguments: {'query': 'current weather'}
+    --------------------------------------------------
+    Tool Calls:
+    Tool Call ID: call_cg14F20jMBqWYrNgEkdWHwB3, Function: tavily_search_results_json, Arguments: {'query': 'current weather in'}
+    --------------------------------------------------
+    Tool Calls:
+    Tool Call ID: call_cg14F20jMBqWYrNgEkdWHwB3, Function: tavily_search_results_json, Arguments: {'query': 'current weather in San'}
+    --------------------------------------------------
+    Tool Calls:
+    Tool Call ID: call_cg14F20jMBqWYrNgEkdWHwB3, Function: tavily_search_results_json, Arguments: {'query': 'current weather in San Francisco'}
+    --------------------------------------------------
+    Tool Calls:
+    Tool Call ID: call_cg14F20jMBqWYrNgEkdWHwB3, Function: tavily_search_results_json, Arguments: {'query': 'current weather in San Francisco'}
+    --------------------------------------------------
+    Tool Calls:
+    Tool Call ID: call_cg14F20jMBqWYrNgEkdWHwB3, Function: tavily_search_results_json, Arguments: {'query': 'current weather in San Francisco'}
+    Response Metadata: Finish Reason - tool_calls
+    --------------------------------------------------
+    --------------------------------------------------
+    AI: The
+    --------------------------------------------------
+    AI: The current
+    --------------------------------------------------
+    AI: The current weather
+    --------------------------------------------------
+    AI: The current weather in
+    --------------------------------------------------
+    AI: The current weather in San
+    --------------------------------------------------
+    AI: The current weather in San Francisco
+    --------------------------------------------------
+    AI: The current weather in San Francisco is
+    --------------------------------------------------
+    AI: The current weather in San Francisco is over
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F).
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-s
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-south
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 k
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph).
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%,
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is 
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is 16
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is 16 km
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is 16 km (
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is 16 km (9
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is 16 km (9 miles
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is 16 km (9 miles).
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is 16 km (9 miles). The
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is 16 km (9 miles). The UV
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is 16 km (9 miles). The UV index
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is 16 km (9 miles). The UV index is
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is 16 km (9 miles). The UV index is 
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is 16 km (9 miles). The UV index is 3
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is 16 km (9 miles). The UV index is 3.
+    --------------------------------------------------
+    AI: The current weather in San Francisco is overcast with a temperature of 13.9°C (57.0°F). The wind is blowing from the south-southwest at 6.9 mph (11.2 kph). The humidity is at 81%, and the visibility is 16 km (9 miles). The UV index is 3.
+    Response Metadata: Finish Reason - stop
+    --------------------------------------------------
 
-    ...
-
-    Receiving new event of type: messages...
-    [
-      {
-        "type": "AIMessageChunk",
-        "tool_calls": [
-          {
-            "name": "tavily_search_results_json",
-            "args": {
-              "query": "weat"
-            },
-            "id": "toolu_0114XKXdNtHQEa3ozmY1uDdM",
-            "type": "tool_call"
-          }
-        ],
-        ...
-      },
-      {
-        "graph_id": "agent",
-        "langgraph_node": "agent",
-        ...
-      }
-    ]
-
-
-
-    Receiving new event of type: messages...
-    [
-      {
-        "type": "AIMessageChunk",
-        "tool_calls": [
-          {
-            "name": "tavily_search_results_json",
-            "args": {
-              "query": "her in san "
-            },
-            "id": "toolu_0114XKXdNtHQEa3ozmY1uDdM",
-            "type": "tool_call"
-          }
-        ],
-        ...
-      },
-      {
-        "graph_id": "agent",
-        "langgraph_node": "agent",
-        ...
-      }
-    ]
-
-    ...
-
-    Receiving new event of type: messages...
-    [
-      {
-        "type": "AIMessageChunk",
-        "tool_calls": [
-          {
-            "name": "tavily_search_results_json",
-            "args": {
-              "query": "francisco"
-            },
-            "id": "toolu_0114XKXdNtHQEa3ozmY1uDdM",
-            "type": "tool_call"
-          }
-        ],
-        ...
-      },
-      {
-        "graph_id": "agent",
-        "langgraph_node": "agent",
-        ...
-      }
-    ]
-
-    ...
-
-    Receiving new event of type: messages...
-    [
-      {
-        "content": "[{\"url\": \"https://www.weatherapi.com/\", \"content\": \"{'location': {'name': 'San Francisco', 'region': 'California', 'country': 'United States of America', 'lat': 37.775, 'lon': -122.4183, 'tz_id': 'America/Los_Angeles', 'localtime_epoch': 1730475777, 'localtime': '2024-11-01 08:42'}, 'current': {'last_updated_epoch': 1730475000, 'last_updated': '2024-11-01 08:30', 'temp_c': 11.1, 'temp_f': 52.0, 'is_day': 1, 'condition': {'text': 'Partly cloudy', 'icon': '//cdn.weatherapi.com/weather/64x64/day/116.png', 'code': 1003}, 'wind_mph': 2.2, 'wind_kph': 3.6, 'wind_degree': 192, 'wind_dir': 'SSW', 'pressure_mb': 1018.0, 'pressure_in': 30.07, 'precip_mm': 0.0, 'precip_in': 0.0, 'humidity': 89, 'cloud': 75, 'feelslike_c': 11.5, 'feelslike_f': 52.6, 'windchill_c': 10.0, 'windchill_f': 50.1, 'heatindex_c': 10.4, 'heatindex_f': 50.7, 'dewpoint_c': 9.1, 'dewpoint_f': 48.5, 'vis_km': 16.0, 'vis_miles': 9.0, 'uv': 3.0, 'gust_mph': 6.7, 'gust_kph': 10.8}}\"}]",
-        "type": "tool",
-        "tool_call_id": "toolu_0114XKXdNtHQEa3ozmY1uDdM",
-        ...
-      },
-      {
-        "graph_id": "agent",
-        "langgraph_node": "action",
-        ...
-      }
-    ]
-
-    ...
-
-    Receiving new event of type: messages...
-    [
-      {
-        "content": [
-          {
-            "text": "\n\nThe search",
-            "type": "text",
-            "index": 0
-          }
-        ],
-        "type": "AIMessageChunk",
-        ...
-      },
-      {
-        "graph_id": "agent",
-        "langgraph_node": "agent",
-        ...
-      }
-    ]
-
-
-
-    Receiving new event of type: messages...
-    [
-      {
-        "content": [
-          {
-            "text": " results provide",
-            "type": "text",
-            "index": 0
-          }
-        ],
-        "type": "AIMessageChunk",
-        ...
-      },
-      {
-        "graph_id": "agent",
-        "langgraph_node": "agent",
-        ...
-      }
-    ]
-
-
-
-    Receiving new event of type: messages...
-    [
-      {
-        "content": [
-          {
-            "text": " the current weather conditions",
-            "type": "text",
-            "index": 0
-          }
-        ],
-        "type": "AIMessageChunk",
-        ...
-      },
-      {
-        "graph_id": "agent",
-        "langgraph_node": "agent",
-        ...
-      }
-    ]
-
-
-
-    Receiving new event of type: messages...
-    [
-      {
-        "content": [
-          {
-            "text": " in San Francisco.",
-            "type": "text",
-            "index": 0
-          }
-        ],
-        "type": "AIMessageChunk",
-        ...
-      },
-      {
-        "graph_id": "agent",
-        "langgraph_node": "agent",
-        ...
-      }
-    ]
-
-    ...

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

@@ -1,8 +1,5 @@
 # How to configure multiple streaming modes at the same time
 
-!!! info "Prerequisites"
-    * [Streaming](../../concepts/streaming.md)
-
 This guide covers how to configure multiple streaming modes at the same time.
 
 ## Setup
@@ -178,6 +175,11 @@ Output:
     
     
     
+    Receiving new event of type: messages/complete...
+    [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}]
+    
+    
+    
     Receiving new event of type: debug...
     {'type': 'checkpoint', 'timestamp': '2024-06-24T21:34:06.117924+00:00', 'step': 0, 'payload': {'config': {'tags': [], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'callbacks': [None], 'recursion_limit': 25, 'configurable': {'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'thread_ts': '1ef32717-bc81-68c8-8000-4e18ae7d67a5', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25'}, 'values': {'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}]}, 'metadata': {'source': 'loop', 'step': 0, 'writes': None}}}
     
@@ -303,6 +305,11 @@ Output:
     
     
     
+    Receiving new event of type: messages/complete...
+    [{'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]
+    
+    
+    
     Receiving new event of type: debug...
     {'type': 'checkpoint', 'timestamp': '2024-06-24T21:34:06.124510+00:00', 'step': 1, 'payload': {'config': {'tags': [], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'callbacks': [None], 'recursion_limit': 25, 'configurable': {'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'thread_ts': '1ef32717-bc91-6a34-8001-26353c117c25', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25'}, 'values': {'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}, 'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}, 'metadata': {'source': 'loop', 'step': 1, 'writes': {'agent': {'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}, 'messages': [{'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}}}}}
     
@@ -462,7 +469,12 @@ Output:
     {'event': 'on_chain_stream', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'name': 'LangGraph', 'tags': [], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'data': {'chunk': ['values', {'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}, 'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '639ca779-403d-4915-a066-327e1f634c8b', 'tool_call_id': 'tool_call_id'}, {'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-0f2ef0a1-0fc7-445c-9df4-55e8bb284575', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}]}, 'parent_ids': []}
     
     
-
+    
+    Receiving new event of type: messages/complete...
+    [{'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-0f2ef0a1-0fc7-445c-9df4-55e8bb284575', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]
+    
+    
+    
     Receiving new event of type: debug...
     {'type': 'checkpoint', 'timestamp': '2024-06-24T21:34:06.134190+00:00', 'step': 3, 'payload': {'config': {'tags': [], 'metadata': {'created_by': 'system', 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'callbacks': [None], 'recursion_limit': 25, 'configurable': {'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25', 'user_id': '', 'graph_id': 'agent', 'thread_id': 'bfc68029-1f7b-400f-beab-6f9032a52da4', 'thread_ts': '1ef32717-bca9-6418-8003-8d0d0b06845c', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'run_id': '1ef32717-bc30-6cf2-8a26-33f63567bc25'}, 'values': {'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}, 'messages': [{'content': "What's the weather in SF?", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': '7da1bafa-f53c-4df8-ba63-8dd517140b9f', 'example': False}, {'content': 'begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-2424dd6d-5cf5-4244-8d98-357640ce6e12', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}, {'content': 'tool_call__begin', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': None, 'id': '639ca779-403d-4915-a066-327e1f634c8b', 'tool_call_id': 'tool_call_id'}, {'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-0f2ef0a1-0fc7-445c-9df4-55e8bb284575', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}, 'metadata': {'source': 'loop', 'step': 3, 'writes': {'agent': {'some_bytes': 'c29tZV9ieXRlcw==', 'some_byte_array': 'c29tZV9ieXRlX2FycmF5', 'dict_with_bytes': {'more_bytes': 'bW9yZV9ieXRlcw=='}, 'messages': [{'content': 'end', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-0f2ef0a1-0fc7-445c-9df4-55e8bb284575', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}}}}}
     

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

@@ -1,9 +1,6 @@
 # How to stream state updates of your graph
 
-!!! info "Prerequisites"
-    * [Streaming](../../concepts/streaming.md)
-
-This guide covers how to use `stream_mode="updates"` for your graph, which will stream the updates to the graph state that are made after each node is executed. This differs from using `stream_mode="values"`: instead of streaming the entire value of the state at each superstep, it only streams the updates from each of the nodes that made an update to the state at that superstep.
+This guide covers how to use `stream_mode="updates"` for your graph, which will stream the updates to the graph state that are made after each node is executed. This differs from using `stream_mode="values"`: instead of streaming the entire value of the state at each superstep, it only streams the updates from each of the nodes that made an update to the state at that superstep. Read [this conceptual guide](https://langchain-ai.github.io/langgraph/concepts/low_level/#stream-and-astream) to learn more.
 
 ## Setup
 
@@ -149,69 +146,24 @@ Now we can stream by updates, which outputs updates made to the state by each no
 Output:
 
     Receiving new event of type: metadata...
-    {"run_id": "cfc96c16-ed9a-44bd-b5bb-c30e3c0725f0"}
-
-
-
-    Receiving new event of type: updates...
-    {
-      "agent": {
-        "messages": [
-          {
-            "type": "ai",
-            "tool_calls": [
-              {
-                "name": "tavily_search_results_json",
-                "args": {
-                  "query": "weather in los angeles"
-                },
-                "id": "toolu_0148tMmDK51iLQfG1yaNwRHM"
-              }
-            ],
-            ...
-          }
-        ]
-      }
-    }
-
-
-
-    Receiving new event of type: updates...
-    {
-      "action": {
-        "messages": [
-          {
-            "content": [
-              {
-                "url": "https://www.weatherapi.com/",
-                "content": "{\"location\": {\"name\": \"Los Angeles\", \"region\": \"California\", \"country\": \"United States of America\", \"lat\": 34.05, \"lon\": -118.24, \"tz_id\": \"America/Los_Angeles\", \"localtime_epoch\": 1716062239, \"localtime\": \"2024-05-18 12:57\"}, \"current\": {\"last_updated_epoch\": 1716061500, \"last_updated\": \"2024-05-18 12:45\", \"temp_c\": 18.9, \"temp_f\": 66.0, \"is_day\": 1, \"condition\": {\"text\": \"Overcast\", \"icon\": \"//cdn.weatherapi.com/weather/64x64/day/122.png\", \"code\": 1009}, \"wind_mph\": 2.2, \"wind_kph\": 3.6, \"wind_degree\": 10, \"wind_dir\": \"N\", \"pressure_mb\": 1017.0, \"pressure_in\": 30.02, \"precip_mm\": 0.0, \"precip_in\": 0.0, \"humidity\": 65, \"cloud\": 100, \"feelslike_c\": 18.9, \"feelslike_f\": 66.0, \"vis_km\": 16.0, \"vis_miles\": 9.0, \"uv\": 6.0, \"gust_mph\": 7.5, \"gust_kph\": 12.0}}"
-              }
-            ],
-            "type": "tool",
-            "name": "tavily_search_results_json",
-            "tool_call_id": "toolu_0148tMmDK51iLQfG1yaNwRHM",
-            ...
-          }
-        ]
-      }
-    }
-
-
-
-    Receiving new event of type: updates...
-    {
-      "agent": {
-        "messages": [
-          {
-            "content": "The weather in Los Angeles is currently overcast with a temperature of around 66°F (18.9°C). There are light winds from the north at around 2-3 mph. The humidity is 65% and visibility is good at 9 miles. Overall, mild spring weather conditions in LA.",
-            "type": "ai",
-            ...
-          }
-        ]
-      }
-    }
-
-
-
+    {'run_id': 'cfc96c16-ed9a-44bd-b5bb-c30e3c0725f0'}
+    
+    
+    
+    Receiving new event of type: data...
+    {'agent': {'messages': [{'content': [{'id': 'toolu_0148tMmDK51iLQfG1yaNwRHM', 'input': {'query': 'weather in los angeles'}, 'name': 'tavily_search_results_json', 'type': 'tool_use'}], 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-1a9d32b0-7007-4a36-abde-8df812a0ed94', 'example': False, 'tool_calls': [{'name': 'tavily_search_results_json', 'args': {'query': 'weather in los angeles'}, 'id': 'toolu_0148tMmDK51iLQfG1yaNwRHM'}], 'invalid_tool_calls': []}]}}
+    
+    
+    
+    Receiving new event of type: data...
+    {'action': {'messages': [{'content': '[{"url": "https://www.weatherapi.com/", "content": "{\'location\': {\'name\': \'Los Angeles\', \'region\': \'California\', \'country\': \'United States of America\', \'lat\': 34.05, \'lon\': -118.24, \'tz_id\': \'America/Los_Angeles\', \'localtime_epoch\': 1716062239, \'localtime\': \'2024-05-18 12:57\'}, \'current\': {\'last_updated_epoch\': 1716061500, \'last_updated\': \'2024-05-18 12:45\', \'temp_c\': 18.9, \'temp_f\': 66.0, \'is_day\': 1, \'condition\': {\'text\': \'Overcast\', \'icon\': \'//cdn.weatherapi.com/weather/64x64/day/122.png\', \'code\': 1009}, \'wind_mph\': 2.2, \'wind_kph\': 3.6, \'wind_degree\': 10, \'wind_dir\': \'N\', \'pressure_mb\': 1017.0, \'pressure_in\': 30.02, \'precip_mm\': 0.0, \'precip_in\': 0.0, \'humidity\': 65, \'cloud\': 100, \'feelslike_c\': 18.9, \'feelslike_f\': 66.0, \'vis_km\': 16.0, \'vis_miles\': 9.0, \'uv\': 6.0, \'gust_mph\': 7.5, \'gust_kph\': 12.0}}"}]', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': 'tavily_search_results_json', 'id': 'a36e8cd1-0e96-4417-9c15-f10a945d2b42', 'tool_call_id': 'toolu_0148tMmDK51iLQfG1yaNwRHM'}]}}
+    
+    
+    
+    Receiving new event of type: data...
+    {'agent': {'messages': [{'content': 'The weather in Los Angeles is currently overcast with a temperature of around 66°F (18.9°C). There are light winds from the north at around 2-3 mph. The humidity is 65% and visibility is good at 9 miles. Overall, mild spring weather conditions in LA.', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-d5c1c2f0-b12d-41ce-990b-f36570e7483d', 'example': False, 'tool_calls': [], 'invalid_tool_calls': []}]}}
+    
+    
+    
     Receiving new event of type: end...
     None

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

@@ -1,9 +1,6 @@
 # How to stream full state of your graph
 
-!!! info "Prerequisites"
-    * [Streaming](../../concepts/streaming.md)
-
-This guide covers how to use `stream_mode="values"`, which streams the value of the state at each superstep. This differs from using `stream_mode="updates"`: instead of streaming just the updates to the state from each node, it streams the entire graph state at that superstep.
+This guide covers how to use `stream_mode="values"`, which streams the value of the state at each superstep. This differs from using `stream_mode="updates"`: instead of streaming just the updates to the state from each node, it streams the entire graph state at that superstep. Read [this conceptual guide](https://langchain-ai.github.io/langgraph/concepts/low_level/#stream-and-astream) to learn more.
 
 ## Setup
 
@@ -136,93 +133,30 @@ Now we can stream by values, which streams the full state of the graph after eac
 Output:
 
     Receiving new event of type: metadata...
-    {"run_id": "f08791ce-0a3d-44e0-836c-ff62cd2e2786"}
-
-
-
+    {'run_id': 'f08791ce-0a3d-44e0-836c-ff62cd2e2786'}
+    
+    
+    
     Receiving new event of type: values...
-    {
-      "messages": [
-        {
-          "role": "human",
-          "content": "what's the weather in la"
-        }
-      ]
-    }
-
-
-
+    {'messages': [{'role': 'human', 'content': 'what's the weather in la'}]}
+    
+    
+    
     Receiving new event of type: values...
-    {
-      "messages": [
-        {
-          "content": "what's the weather in la",
-          "type": "human",
-          ...
-        },
-        {
-          "content": "",
-          "type": "ai",
-          "tool_calls": [
-            {
-              "name": "tavily_search_results_json",
-              "args": {
-                "query": "weather in los angeles"
-              },
-              "id": "toolu_01E5mSaZWm5rWJnCqmt63v4g"
-            }
-          ],
-          ...
-        }
-      ]
-    }
-
-    ...
-
+    {'messages': [{'content': 'what's the weather in la', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'faa15565-8823-4aa1-87af-e21b40526fae', 'example': False}, {'content': [{'id': 'toolu_01E5mSaZWm5rWJnCqmt63v4g', 'input': {'query': 'weather in los angeles'}, 'name': 'tavily_search_results_json', 'type': 'tool_use'}], 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-3fe1db7a-6b8d-4d83-ba07-8657190ad811', 'example': False, 'tool_calls': [{'name': 'tavily_search_results_json', 'args': {'query': 'weather in los angeles'}, 'id': 'toolu_01E5mSaZWm5rWJnCqmt63v4g'}], 'invalid_tool_calls': []}]}
+    
+    
+    
     Receiving new event of type: values...
-    {
-      "messages": [
-        {
-          "content": "what's the weather in la",
-          "type": "human",
-          ...
-        },
-        {
-          "content": "",
-          "type": "ai",
-          "tool_calls": [
-            {
-              "name": "tavily_search_results_json",
-              "args": {
-                "query": "weather in los angeles"
-              },
-              "id": "toolu_01E5mSaZWm5rWJnCqmt63v4g"
-            }
-          ],
-          ...
-        }
-        {
-          "content": [
-            {
-              "url": "https://www.weatherapi.com/",
-              "content": "{\"location\": {\"name\": \"Los Angeles\", \"region\": \"California\", \"country\": \"United States of America\", \"lat\": 34.05, \"lon\": -118.24, \"tz_id\": \"America/Los_Angeles\", \"localtime_epoch\": 1716310320, \"localtime\": \"2024-05-21 9:52\"}, \"current\": {\"last_updated_epoch\": 1716309900, \"last_updated\": \"2024-05-21 09:45\", \"temp_c\": 16.7, \"temp_f\": 62.1, \"is_day\": 1, \"condition\": {\"text\": \"Overcast\", \"icon\": \"//cdn.weatherapi.com/weather/64x64/day/122.png\", \"code\": 1009}, \"wind_mph\": 8.1, \"wind_kph\": 13.0, \"wind_degree\": 250, \"wind_dir\": \"WSW\", \"pressure_mb\": 1015.0, \"pressure_in\": 29.97, \"precip_mm\": 0.0, \"precip_in\": 0.0, \"humidity\": 65, \"cloud\": 100, \"feelslike_c\": 16.7, \"feelslike_f\": 62.1, \"vis_km\": 16.0, \"vis_miles\": 9.0, \"uv\": 5.0, \"gust_mph\": 12.5, \"gust_kph\": 20.2}}"
-            }
-          ],
-          "type": "tool",
-          "name": "tavily_search_results_json",
-          "tool_call_id": "toolu_01E5mSaZWm5rWJnCqmt63v4g"
-          ...
-        },
-        {
-          "content": "Based on the weather API results, the current weather in Los Angeles is overcast with a temperature of around 62°F (17°C). There are light winds from the west-southwest around 8-13 mph. The humidity is 65% and visibility is good at 9 miles. Overall, mild spring weather conditions in LA.",
-          "type": "ai",
-          ...
-        }
-      ]
-    }
-
-
-
+    {'messages': [{'content': 'what's the weather in la', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'faa15565-8823-4aa1-87af-e21b40526fae', 'example': False}, {'content': [{'id': 'toolu_01E5mSaZWm5rWJnCqmt63v4g', 'input': {'query': 'weather in los angeles'}, 'name': 'tavily_search_results_json', 'type': 'tool_use'}], 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-3fe1db7a-6b8d-4d83-ba07-8657190ad811', 'example': False, 'tool_calls': [{'name': 'tavily_search_results_json', 'args': {'query': 'weather in los angeles'}, 'id': 'toolu_01E5mSaZWm5rWJnCqmt63v4g'}], 'invalid_tool_calls': []}, {'content': '[{"url": "https://www.weatherapi.com/", "content": "{\'location\': {\'name\': \'Los Angeles\', \'region\': \'California\', \'country\': \'United States of America\', \'lat\': 34.05, \'lon\': -118.24, \'tz_id\': \'America/Los_Angeles\', \'localtime_epoch\': 1716310320, \'localtime\': \'2024-05-21 9:52\'}, \'current\': {\'last_updated_epoch\': 1716309900, \'last_updated\': \'2024-05-21 09:45\', \'temp_c\': 16.7, \'temp_f\': 62.1, \'is_day\': 1, \'condition\': {\'text\': \'Overcast\', \'icon\': \'//cdn.weatherapi.com/weather/64x64/day/122.png\', \'code\': 1009}, \'wind_mph\': 8.1, \'wind_kph\': 13.0, \'wind_degree\': 250, \'wind_dir\': \'WSW\', \'pressure_mb\': 1015.0, \'pressure_in\': 29.97, \'precip_mm\': 0.0, \'precip_in\': 0.0, \'humidity\': 65, \'cloud\': 100, \'feelslike_c\': 16.7, \'feelslike_f\': 62.1, \'vis_km\': 16.0, \'vis_miles\': 9.0, \'uv\': 5.0, \'gust_mph\': 12.5, \'gust_kph\': 20.2}}"}]', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': 'tavily_search_results_json', 'id': '0d5dab31-5ff8-4ae2-a560-bc4bcba7c9d7', 'tool_call_id': 'toolu_01E5mSaZWm5rWJnCqmt63v4g'}]}
+    
+    
+    
+    Receiving new event of type: values...
+    {'messages': [{'content': 'what's the weather in la', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'faa15565-8823-4aa1-87af-e21b40526fae', 'example': False}, {'content': [{'id': 'toolu_01E5mSaZWm5rWJnCqmt63v4g', 'input': {'query': 'weather in los angeles'}, 'name': 'tavily_search_results_json', 'type': 'tool_use'}], 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-3fe1db7a-6b8d-4d83-ba07-8657190ad811', 'example': False, 'tool_calls': [{'name': 'tavily_search_results_json', 'args': {'query': 'weather in los angeles'}, 'id': 'toolu_01E5mSaZWm5rWJnCqmt63v4g'}], 'invalid_tool_calls': []}, {'content': '[{"url": "https://www.weatherapi.com/", "content": "{\'location\': {\'name\': \'Los Angeles\', \'region\': \'California\', \'country\': \'United States of America\', \'lat\': 34.05, \'lon\': -118.24, \'tz_id\': \'America/Los_Angeles\', \'localtime_epoch\': 1716310320, \'localtime\': \'2024-05-21 9:52\'}, \'current\': {\'last_updated_epoch\': 1716309900, \'last_updated\': \'2024-05-21 09:45\', \'temp_c\': 16.7, \'temp_f\': 62.1, \'is_day\': 1, \'condition\': {\'text\': \'Overcast\', \'icon\': \'//cdn.weatherapi.com/weather/64x64/day/122.png\', \'code\': 1009}, \'wind_mph\': 8.1, \'wind_kph\': 13.0, \'wind_degree\': 250, \'wind_dir\': \'WSW\', \'pressure_mb\': 1015.0, \'pressure_in\': 29.97, \'precip_mm\': 0.0, \'precip_in\': 0.0, \'humidity\': 65, \'cloud\': 100, \'feelslike_c\': 16.7, \'feelslike_f\': 62.1, \'vis_km\': 16.0, \'vis_miles\': 9.0, \'uv\': 5.0, \'gust_mph\': 12.5, \'gust_kph\': 20.2}}"}]', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'tool', 'name': 'tavily_search_results_json', 'id': '0d5dab31-5ff8-4ae2-a560-bc4bcba7c9d7', 'tool_call_id': 'toolu_01E5mSaZWm5rWJnCqmt63v4g'}, {'content': 'Based on the weather API results, the current weather in Los Angeles is overcast with a temperature of around 62°F (17°C). There are light winds from the west-southwest around 8-13 mph. The humidity is 65% and visibility is good at 9 miles. Overall, mild spring weather conditions in LA.', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-4d6d4c23-5aad-4042-b0d9-19407a9e08e3', 'example': False, 'tool_calls': [], 'invalid_tool_calls': []}]}
+    
+    
+    
     Receiving new event of type: end...
     None
     
@@ -294,42 +228,40 @@ If we want to just get the final result, we can use this endpoint and just keep
 
 Output:
 
-    {
-      "messages": [
-        {
-          "content": "what's the weather in la",
-          "type": "human",
-          ...
-        },
-        {
-          "type": "ai",
-          "tool_calls": [
-            {
-              "name": "tavily_search_results_json",
-              "args": {
-                "query": "weather in los angeles"
-              },
-              "id": "toolu_01E5mSaZWm5rWJnCqmt63v4g"
-            }
-          ],
-          ...
-        }
-        {
-          "content": [
-            {
-              "url": "https://www.weatherapi.com/",
-              "content": "{\"location\": {\"name\": \"Los Angeles\", \"region\": \"California\", \"country\": \"United States of America\", \"lat\": 34.05, \"lon\": -118.24, \"tz_id\": \"America/Los_Angeles\", \"localtime_epoch\": 1716310320, \"localtime\": \"2024-05-21 9:52\"}, \"current\": {\"last_updated_epoch\": 1716309900, \"last_updated\": \"2024-05-21 09:45\", \"temp_c\": 16.7, \"temp_f\": 62.1, \"is_day\": 1, \"condition\": {\"text\": \"Overcast\", \"icon\": \"//cdn.weatherapi.com/weather/64x64/day/122.png\", \"code\": 1009}, \"wind_mph\": 8.1, \"wind_kph\": 13.0, \"wind_degree\": 250, \"wind_dir\": \"WSW\", \"pressure_mb\": 1015.0, \"pressure_in\": 29.97, \"precip_mm\": 0.0, \"precip_in\": 0.0, \"humidity\": 65, \"cloud\": 100, \"feelslike_c\": 16.7, \"feelslike_f\": 62.1, \"vis_km\": 16.0, \"vis_miles\": 9.0, \"uv\": 5.0, \"gust_mph\": 12.5, \"gust_kph\": 20.2}}"
-            }
-          ],
-          "type": "tool",
-          "name": "tavily_search_results_json",
-          "tool_call_id": "toolu_01E5mSaZWm5rWJnCqmt63v4g"
-          ...
-        },
-        {
-          "content": "Based on the weather API results, the current weather in Los Angeles is overcast with a temperature of around 62°F (17°C). There are light winds from the west-southwest around 8-13 mph. The humidity is 65% and visibility is good at 9 miles. Overall, mild spring weather conditions in LA.",
-          "type": "ai",
-          ...
-        }
-      ]
-    }
+    {'messages': [{'content': 'what's the weather in la',
+       'additional_kwargs': {},
+       'response_metadata': {},
+       'type': 'human',
+       'name': None,
+       'id': 'e78c2f94-d810-42fc-a399-11f6bb1b1092',
+       'example': False},
+      {'content': [{'id': 'toolu_01SBMoAGr4U9x3ibztm2UUom',
+         'input': {'query': 'weather in los angeles'},
+         'name': 'tavily_search_results_json',
+         'type': 'tool_use'}],
+       'additional_kwargs': {},
+       'response_metadata': {},
+       'type': 'ai',
+       'name': None,
+       'id': 'run-80767ab8-09fc-40ec-9e45-657ddef5e0b1',
+       'example': False,
+       'tool_calls': [{'name': 'tavily_search_results_json',
+         'args': {'query': 'weather in los angeles'},
+         'id': 'toolu_01SBMoAGr4U9x3ibztm2UUom'}],
+       'invalid_tool_calls': []},
+      {'content': '[{"url": "https://www.weatherapi.com/", "content": "{\'location\': {\'name\': \'Los Angeles\', \'region\': \'California\', \'country\': \'United States of America\', \'lat\': 34.05, \'lon\': -118.24, \'tz_id\': \'America/Los_Angeles\', \'localtime_epoch\': 1716310320, \'localtime\': \'2024-05-21 9:52\'}, \'current\': {\'last_updated_epoch\': 1716309900, \'last_updated\': \'2024-05-21 09:45\', \'temp_c\': 16.7, \'temp_f\': 62.1, \'is_day\': 1, \'condition\': {\'text\': \'Overcast\', \'icon\': \'//cdn.weatherapi.com/weather/64x64/day/122.png\', \'code\': 1009}, \'wind_mph\': 8.1, \'wind_kph\': 13.0, \'wind_degree\': 250, \'wind_dir\': \'WSW\', \'pressure_mb\': 1015.0, \'pressure_in\': 29.97, \'precip_mm\': 0.0, \'precip_in\': 0.0, \'humidity\': 65, \'cloud\': 100, \'feelslike_c\': 16.7, \'feelslike_f\': 62.1, \'vis_km\': 16.0, \'vis_miles\': 9.0, \'uv\': 5.0, \'gust_mph\': 12.5, \'gust_kph\': 20.2}}"}]',
+       'additional_kwargs': {},
+       'response_metadata': {},
+       'type': 'tool',
+       'name': 'tavily_search_results_json',
+       'id': 'af25e94a-c119-48c3-bbd3-096e42f472ac',
+       'tool_call_id': 'toolu_01SBMoAGr4U9x3ibztm2UUom'},
+      {'content': 'Based on the weather API results, the current weather in Los Angeles is overcast with a temperature of around 62°F (17°C). There are light winds from the west-southwest around 8-13 mph. The humidity is 65% and visibility is good at 9 miles. Overall, mild spring weather conditions in LA.',
+       'additional_kwargs': {},
+       'response_metadata': {},
+       'type': 'ai',
+       'name': None,
+       'id': 'run-b90f0037-e56a-4f3b-ad92-00d10d079a9e',
+       'example': False,
+       'tool_calls': [],
+       'invalid_tool_calls': []}]}

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

@@ -4,7 +4,7 @@ The LangGraph Studio UI connects directly to LangGraph Cloud deployments.
 
 Starting from the <a href="https://smith.langchain.com/" target="_blank">LangSmith UI</a>...
 
-1. In the left-hand navigation panel, select `LangGraph Cloud`. The `LangGraph Cloud` view contains a list of existing LangGraph Cloud deployments.
+1. In the left-hand navigation panel, select `Deployments`. The `Deployments` view contains a list of existing LangGraph Cloud deployments.
 1. Select an existing deployment to test with LangGraph Studio.
 1. In the top-right corner, select `Open LangGraph Studio`.
 1. [Invoke an assistant](./invoke_studio.md) or [view an existing thread](./threads_studio.md).

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

@@ -76,9 +76,7 @@ Output:
 
 ## Use graph with a webhook
 
-To invoke a run with a webhook, we specify the `webhook` parameter with the desired endpoint when creating a run. Webhook requests are triggered by the end of a run.
-
-For example, if we can receive requests at `https://my-server.app/my-webhook-endpoint`, we can pass this to `stream`:
+Now we can invoke a run with a webhook:
 
 === "Python"
 
@@ -91,7 +89,7 @@ For example, if we can receive requests at `https://my-server.app/my-webhook-end
         assistant_id=assistant_id,
         input=input,
         stream_mode="events",
-        webhook="https://my-server.app/my-webhook-endpoint"
+        webhook="your-webhook"
     ):
         # Do something with the stream output
         pass
@@ -109,7 +107,7 @@ For example, if we can receive requests at `https://my-server.app/my-webhook-end
       assistantID,
       {
         input: input,
-        webhook: "https://my-server.app/my-webhook-endpoint"
+        webhook: "your-webhook"
       }
     );
     for await (const chunk of streamResponse) {
@@ -126,17 +124,8 @@ For example, if we can receive requests at `https://my-server.app/my-webhook-end
         --data '{
             "assistant_id": <ASSISTANT_ID>,
             "input" : {"messages":[{"role": "user", "content": "Hello!"}]},
-            "webhook": "https://my-server.app/my-webhook-endpoint"
+            "webhook": <YOUR_WEBHOOK_URL>
         }'
     ```
 
-The schema for the payload sent to `my-webhook-endpoint` is that of a [run](../../concepts/langgraph_server.md/#runs). See [API Reference](https://langchain-ai.github.io/langgraph/cloud/reference/api/api_ref.html#model/run) for more detail. Note that the run input, configuration, etc. are included in the `kwargs` field.
-
-### Signing webhook requests
-
-To sign the webhook requests, we can specify a token parameter in the webhook URL, e.g.,
-```
-https://my-server.app/my-webhook-endpoint?token=...
-```
-
-The server should then extract the token from the request's parameters and validate it before processing the payload.
+And that's it! Now you can trigger your custom webhooks whenever you want in your LangGraph applications!

docs/docs/cloud/index.md

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

docs/docs/cloud/quick_start.md

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

docs/docs/cloud/reference/cli.md

@@ -1,38 +1,23 @@
 # LangGraph CLI
-
-The LangGraph command line interface includes commands to build and run a LangGraph Cloud API server locally in [Docker](https://www.docker.com/). For development and testing, you can use the CLI to deploy a local API server as an alternative to the [Studio desktop app](../../concepts/langgraph_studio.md).
+The LangGraph CLI includes commands to build and run a LangGraph Cloud API server locally in [Docker](https://www.docker.com/). For development and testing, use the CLI to deploy a local API server.
 
 ## Installation
-
 1. Ensure that Docker is installed (e.g. `docker --version`).
-2. Install the `langgraph-cli` package:
- 
-    === "pip"
-        ```bash    
-        pip install langgraph-cli
-        ```
-
-    === "Homebrew (MacOS only)"
-        ```bash
-        brew install langgraph-cli
-        ```
- 
+2. Install the `langgraph-cli` Python package (e.g. `pip install langgraph-cli`).
 3. Run the command `langgraph --help` to confirm that the CLI is installed.
 
 [](){#langgraph.json}
-
 ## Configuration File
-
 The LangGraph CLI requires a JSON configuration file with the following keys:
 
-| Key                | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-|--------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `dependencies`     | **Required**. Array of dependencies for LangGraph Cloud API server. Dependencies can be one of the following: (1) `"."`, which will look for local Python packages, (2) `pyproject.toml`, `setup.py` or `requirements.txt` in the app directory `"./local_package"`, or (3) a package name.                                                                                                                                                                                                                                                  |
-| `graphs`           | **Required**. Mapping from graph ID to path where the compiled graph or a function that makes a graph is defined. Example: <ul><li>`./your_package/your_file.py:variable`, where `variable` is an instance of `langgraph.graph.state.CompiledStateGraph`</li><li>`./your_package/your_file.py:make_graph`, where `make_graph` is a function that takes a config dictionary (`langchain_core.runnables.RunnableConfig`) and creates an instance of `langgraph.graph.state.StateGraph` / `langgraph.graph.state.CompiledStateGraph`.</li></ul> |
-| `env`              | Path to `.env` file or a mapping from environment variable to its value.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| `python_version`   | `3.11` or `3.12`. Defaults to `3.11`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| `pip_config_file`  | Path to `pip` config file.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| `dockerfile_lines` | Array of additional lines to add to Dockerfile following the import from parent image.                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| Key | Description |
+| --- | ----------- |
+| `dependencies` | **Required**. Array of dependencies for LangGraph Cloud API server. Dependencies can be one of the following: (1) `"."`, which will look for local Python packages, (2) `pyproject.toml`, `setup.py` or `requirements.txt` in the app directory `"./local_package"`, or (3) a package name. |
+| `graphs` | **Required**. Mapping from graph ID to path where the compiled graph or a function that makes a graph is defined. Example: <ul><li>`./your_package/your_file.py:variable`, where `variable` is an instance of `langgraph.graph.state.CompiledStateGraph`</li><li>`./your_package/your_file.py:make_graph`, where `make_graph` is a function that takes a config dictionary (`langchain_core.runnables.RunnableConfig`) and creates an instance of `langgraph.graph.state.StateGraph` / `langgraph.graph.state.CompiledStateGraph`.</li></ul> |
+| `env` | Path to `.env` file or a mapping from environment variable to its value. |
+| `python_version` | `3.11` or `3.12`. Defaults to `3.11`. |
+| `pip_config_file`| Path to `pip` config file. |
+| `dockerfile_lines` | Array of additional lines to add to Dockerfile following the import from parent image. |
 
 <div class="admonition tip">
     <p class="admonition-title">Note</p>
@@ -42,134 +27,101 @@ The LangGraph CLI requires a JSON configuration file with the following keys:
 </div>
 
 Example:
-
 ```json
 {
-  "dependencies": ["langchain_openai", "./your_package"],
-  "graphs": {
-    "my_graph_id": "./your_package/your_file.py:variable"
-  },
-  "env": "./.env"
+    "dependencies": [
+        "langchain_openai",
+        "./your_package"
+    ],
+    "graphs": {
+        "my_graph_id": "./your_package/your_file.py:variable"
+    },
+    "env": "./.env"
 }
 ```
 
 Example:
-
 ```json
 {
-  "python_version": "3.11",
-  "dependencies": ["langchain_openai", "."],
-  "graphs": {
-    "my_graph_id": "./your_package/your_file.py:make_graph"
-  },
-  "env": {
-    "OPENAI_API_KEY": "secret-key"
-  }
+    "python_version": "3.11",
+    "dependencies": [
+        "langchain_openai",
+        "."
+    ],
+    "graphs": {
+        "my_graph_id": "./your_package/your_file.py:make_graph"
+    },
+    "env": {
+        "OPENAI_API_KEY": "secret-key"
+    }
 }
 ```
 
 ## Commands
-
 The base command for the LangGraph CLI is `langgraph`.
 
 **Usage**
-
 ```
 langgraph [OPTIONS] COMMAND [ARGS]
 ```
 
 ### `build`
-
 Build LangGraph Cloud API server Docker image.
 
 **Usage**
-
 ```
 langgraph build [OPTIONS]
 ```
 
 **Options**
 
-| Option               | Default          | Description                                                                                                                  |
-|----------------------|------------------|------------------------------------------------------------------------------------------------------------------------------|
-| `--platform TEXT`    |                  | Target platform(s) to build the Docker image for. Example: `langgraph build --platform linux/amd64,linux/arm64`              |
-| `-t, --tag TEXT`     |                  | **Required**. Tag for the Docker image. Example: `langgraph build -t my-image`                                               |
-| `--pull / --no-pull` | `--pull`         | Build with latest remote Docker image. Use `--no-pull` for running the LangGraph Cloud API server with locally built images. |
-| `-c, --config FILE`  | `langgraph.json` | Path to configuration file declaring dependencies, graphs and environment variables.                                         |
-| `--help`             |                  | Display command documentation.                                                                                               |
+| Option | Default | Description |
+| ------ | ------- | ----------- |
+| `--platform TEXT` | | Target platform(s) to build the Docker image for. Example: `langgraph build --platform linux/amd64,linux/arm64` |
+| `-t, --tag TEXT` | | **Required**. Tag for the Docker image. Example: `langgraph build -t my-image` |
+| `--pull / --no-pull` | `--pull` | Build with latest remote Docker image. Use `--no-pull` for running the LangGraph Cloud API server with locally built images. |
+| `-c, --config FILE` | `langgraph.json` | Path to configuration file declaring dependencies, graphs and environment variables. |
+| `--help` | | Display command documentation. |
 
 ### `up`
-
 Start langgraph API server. For local testing, requires a LangSmith API key with access to LangGraph Cloud closed beta. Requires a license key for production use.
 
 **Usage**
-
 ```
 langgraph up [OPTIONS]
 ```
 
 **Options**
 
-| Option                       | Default                   | Description                                                                                                           |
-|------------------------------|---------------------------|-----------------------------------------------------------------------------------------------------------------------|
-| `--wait`                     |                           | Wait for services to start before returning. Implies --detach                                                         |
-| `--postgres-uri TEXT`        | Local database            | Postgres URI to use for the database.                                                                                 |
-| `--watch`                    |                           | Restart on file changes                                                                                               |
-| `--debugger-base-url TEXT`   | `http://127.0.0.1:[PORT]` | URL used by the debugger to access LangGraph API.                                                                     |
-| `--debugger-port INTEGER`    |                           | Pull the debugger image locally and serve the UI on specified port                                                    |
-| `--verbose`                  |                           | Show more output from the server logs.                                                                                |
-| `-c, --config FILE`          | `langgraph.json`          | Path to configuration file declaring dependencies, graphs and environment variables.                                  |
-| `-d, --docker-compose FILE`  |                           | Path to docker-compose.yml file with additional services to launch.                                                   |
-| `-p, --port INTEGER`         | `8123`                    | Port to expose. Example: `langgraph test --port 8000`                                                                 |
-| `--pull / --no-pull`         | `pull`                    | Pull latest images. Use --no-pull for running the server with locally-built images. Example: `langgraph up --no-pull` |
-| `--recreate / --no-recreate` | `no-recreate`             | Recreate containers even if their configuration and image haven't changed                                             |
-| `--help`                     |                           | Display command documentation.                                                                                        |
+| Option | Default | Description |
+| ------ | ------- | ----------- |
+| `--wait` | | Wait for services to start before returning. Implies --detach |
+| `--postgres-uri TEXT` | Local database | Postgres URI to use for the database. |
+| `--watch` | | Restart on file changes |
+| `--debugger-base-url TEXT` | `http://127.0.0.1:[PORT]` | URL used by the debugger to access LangGraph API. |
+| `--debugger-port INTEGER` | | Pull the debugger image locally and serve the UI on specified port |
+| `--verbose` | | Show more output from the server logs. |
+| `-c, --config FILE` | `langgraph.json` | Path to configuration file declaring dependencies, graphs and environment variables. |
+| `-d, --docker-compose FILE` | | Path to docker-compose.yml file with additional services to launch. |
+| `-p, --port INTEGER` | `8123` | Port to expose. Example: `langgraph test --port 8000` |
+| `--pull / --no-pull` | `pull` | Pull latest images. Use --no-pull for running the server with locally-built images. Example: `langgraph up --no-pull` |
+| `--recreate / --no-recreate` | `no-recreate` | Recreate containers even if their configuration and image haven't changed |
+| `--help` | | Display command documentation. | 
 
-### `dockerfile`
-
-Generate a Dockerfile for building a LangGraph Cloud API server Docker image.
+### `test`
+Test your LangGraph in the cloud. The only function you can call from the SDK after testing your graph is `client.runs.stream(thread_id=None, ...)`
 
 **Usage**
-
 ```
-langgraph dockerfile [OPTIONS] SAVE_PATH
+langgraph test [OPTIONS]
 ```
 
 **Options**
 
-| Option              | Default          | Description                                                                                                     |
-|---------------------|------------------|-----------------------------------------------------------------------------------------------------------------|
-| `-c, --config FILE` | `langgraph.json` | Path to the [configuration file](#configuration-file) declaring dependencies, graphs and environment variables. |
-| `--help`            |                  | Show this message and exit.                                                                                     |
-
-Example:
-
-```bash
-langgraph dockerfile -c langgraph.json Dockerfile
-```
-
-Would generate something like the following:
-
-```text
-FROM langchain/langgraph-api:3.11
-
-ADD ./pipconf.txt /pipconfig.txt
-
-RUN PIP_CONFIG_FILE=/pipconfig.txt PYTHONDONTWRITEBYTECODE=1 pip install --no-cache-dir -c /api/constraints.txt langchain_community langchain_anthropic langchain_openai wikipedia scikit-learn
-
-ADD ./graphs /deps/__outer_graphs/src
-RUN set -ex && \
-    for line in '[project]' \
-                'name = "graphs"' \
-                'version = "0.1"' \
-                '[tool.setuptools.package-data]' \
-                '"*" = ["**/*"]'; do \
-        echo "$line" >> /deps/__outer_graphs/pyproject.toml; \
-    done
-
-RUN PIP_CONFIG_FILE=/pipconfig.txt PYTHONDONTWRITEBYTECODE=1 pip install --no-cache-dir -c /api/constraints.txt -e /deps/*
-
-ENV LANGSERVE_GRAPHS='{"agent": "/deps/__outer_graphs/src/agent.py:graph", "storm": "/deps/__outer_graphs/src/storm.py:graph"}'
-```
-
-You can then customize, build images, push, and deploy from this file.
+| Option | Default | Description |
+| ------ | ------- | ----------- |
+| `--verbose` | | Show more output from the server logs. |
+| `-c, --config FILE` | `langgraph.json` | Path to configuration file declaring dependencies, graphs and environment variables. |
+| `-p, --port INTEGER` | `8123` | Port to expose. Example: `langgraph test --port 8000` |
+| `--pull / --no-pull` | `pull` | Pull latest images. Use --no-pull for running the server with locally-built images. Example: `langgraph up --no-pull` |
+| `--help` | | Display command documentation. |

docs/docs/concepts/agentic_concepts.md

@@ -103,15 +103,15 @@ Parallel processing is vital for efficient multi-agent systems and complex tasks
 
 For practical implementation, see our [map-reduce tutorial](../how-tos/map-reduce.ipynb).
 
-### Subgraphs
+### Sub-graphs
 
-[Subgraphs](./low_level.md#subgraphs) are essential for managing complex agent architectures, particularly in [multi-agent systems](./multi_agent.md). They allow:
+Sub-graphs are essential for managing complex agent architectures, particularly in multi-agent systems. They allow:
 
 - Isolated state management for individual agents
 - Hierarchical organization of agent teams
 - Controlled communication between agents and the main system
 
-Subgraphs communicate with the parent graph through overlapping keys in the state schema. This enables flexible, modular agent design. For implementation details, refer to our [subgraph how-to guide](../how-tos/subgraph.ipynb).
+Sub-graphs communicate with the parent graph through overlapping keys in the state schema. This enables flexible, modular agent design. For implementation details, refer to our [sub-graph tutorial](../how-tos/subgraph.ipynb).
 
 ### Reflection
 

docs/docs/concepts/application_structure.md

@@ -1,167 +0,0 @@
-# Application Structure
-
-!!! info "Prerequisites"
-
-    - [LangGraph Server](./langgraph_server.md)
-    - [LangGraph Glossary](./low_level.md)
-
-## Overview
-
-A LangGraph application consists of one or more graphs, a LangGraph API Configuration file (`langgraph.json`), a file that specifies dependencies, and an optional .env file that specifies environment variables.
-
-This guide shows a typical structure for a LangGraph application and shows how the required information to deploy a LangGraph application using the LangGraph Platform is specified.
-
-## Key Concepts
-
-To deploy using the LangGraph Platform, the following information should be provided:
-
-1. A [LangGraph API Configuration file](#configuration-file) (`langgraph.json`) that specifies the dependencies, graphs, environment variables to use for the application.
-2. The [graphs](#graphs) that implement the logic of the application.
-3. A file that specifies [dependencies](#dependencies) required to run the application.
-4. [Environment variable](#environment-variables) that are required for the application to run.
-
-## File Structure
-
-Below are examples of directory structures for Python and JavaScript applications:
-
-=== "Python (requirements.txt)"
-
-    ```plaintext
-    my-app/
-    ├── my_agent # all project code lies within here
-    │   ├── utils # utilities for your graph
-    │   │   ├── __init__.py
-    │   │   ├── tools.py # tools for your graph
-    │   │   ├── nodes.py # node functions for you graph
-    │   │   └── state.py # state definition of your graph
-    │   ├── requirements.txt # package dependencies
-    │   ├── __init__.py
-    │   └── agent.py # code for constructing your graph
-    ├── .env # environment variables
-    └── langgraph.json # configuration file for LangGraph
-    ```
-=== "Python (pyproject.toml)"
-
-    ```plaintext
-    my-app/
-    ├── my_agent # all project code lies within here
-    │   ├── utils # utilities for your graph
-    │   │   ├── __init__.py
-    │   │   ├── tools.py # tools for your graph
-    │   │   ├── nodes.py # node functions for you graph
-    │   │   └── state.py # state definition of your graph
-    │   ├── __init__.py
-    │   └── agent.py # code for constructing your graph
-    ├── .env # environment variables
-    ├── langgraph.json  # configuration file for LangGraph
-    └── pyproject.toml # dependencies for your project
-    ```
-
-=== "JS (package.json)"
-
-    ```plaintext
-    my-app/
-    ├── src # all project code lies within here
-    │   ├── utils # optional utilities for your graph
-    │   │   ├── tools.ts # tools for your graph
-    │   │   ├── nodes.ts # node functions for you graph
-    │   │   └── state.ts # state definition of your graph
-    │   └── agent.ts # code for constructing your graph
-    ├── package.json # package dependencies
-    ├── .env # environment variables
-    └── langgraph.json # configuration file for LangGraph
-    ```
-
-!!! note
-
-    The directory structure of a LangGraph application can vary depending on the programming language and the package manager used.
-
-
-## Configuration File
-
-The `langgraph.json` file is a JSON file that specifies the dependencies, graphs, environment variables, and other settings required to deploy a LangGraph application.
-
-The file supports specification of the following information:
-
-
-| Key                | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-|--------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `dependencies`     | **Required**. Array of dependencies for LangGraph API server. Dependencies can be one of the following: (1) `"."`, which will look for local Python packages, (2) `pyproject.toml`, `setup.py` or `requirements.txt` in the app directory `"./local_package"`, or (3) a package name.                                                                                                                                                                                                                                                        |
-| `graphs`           | **Required**. Mapping from graph ID to path where the compiled graph or a function that makes a graph is defined. Example: <ul><li>`./your_package/your_file.py:variable`, where `variable` is an instance of `langgraph.graph.state.CompiledStateGraph`</li><li>`./your_package/your_file.py:make_graph`, where `make_graph` is a function that takes a config dictionary (`langchain_core.runnables.RunnableConfig`) and creates an instance of `langgraph.graph.state.StateGraph` / `langgraph.graph.state.CompiledStateGraph`.</li></ul> |
-| `env`              | Path to `.env` file or a mapping from environment variable to its value.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| `python_version`   | `3.11` or `3.12`. Defaults to `3.11`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| `pip_config_file`  | Path to `pip` config file.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| `dockerfile_lines` | Array of additional lines to add to Dockerfile following the import from parent image.                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-!!! tip
-
-    The LangGraph CLI defaults to using the configuration file **langgraph.json** in the current directory.
-
-
-### Examples
-
-=== "Python"
-
-    * The dependencies involve a custom local package and the `langchain_openai` package.
-    * A single graph will be loaded from the file `./your_package/your_file.py` with the variable `variable`.
-    * The environment variables are loaded from the `.env` file.
-
-    ```json
-    {
-        "dependencies": [
-            "langchain_openai",
-            "./your_package"
-        ],
-        "graphs": {
-            "my_agent": "./your_package/your_file.py:agent"
-        },
-        "env": "./.env"
-    }
-    ```
-
-=== "JavaScript"
-
-    * The dependencies will be loaded from a dependency file in the local directory (e.g., `package.json`).
-    * A single graph will be loaded from the file `./your_package/your_file.js` with the function `agent`.
-    * The environment variable `OPENAI_API_KEY` is set inline.
-
-    ```json
-    {
-        "dependencies": [
-            "."
-        ],
-        "graphs": {
-            "my_agent": "./your_package/your_file.js:agent"
-        },
-        "env": {
-            "OPENAI_API_KEY": "secret-key"
-        }
-    }
-    ```
-
-## Dependencies
-
-A LangGraph application may depend on other Python packages or JavaScript libraries (depending on the programming language in which the application is written).
-
-You will generally need to specify the following information for dependencies to be set up correctly:
-
-1. A file in the directory that specifies the dependencies (e.g., `requirements.txt`, `pyproject.toml`, or `package.json`).
-2. A `dependencies` key in the [LangGraph configuration file](#configuration-file) that specifies the dependencies required to run the LangGraph application.
-3. Any additional binaries or system libraries can be specified using `dockerfile_lines` key in the [LangGraph configuration file](#configuration-file).
-
-## Graphs
-
-Use the `graphs` key in the [LangGraph configuration file](#configuration-file) to specify which graphs will be available in the deployed LangGraph application.
-
-You can specify one or more graphs in the configuration file. Each graph is identified by a name (which should be unique) and a path for either: (1) the compiled graph or (2) a function that makes a graph is defined.
-
-## Environment Variables
-
-If you're working with a deployed LangGraph application locally, you can configure environment variables in the `env` key of the [LangGraph configuration file](#configuration-file).
-
-For a production deployment, you will typically want to configure the environment variables in the deployment environment.
-
-## Related
-
-Please see the following resources for more information:
-
-- How-to guides for [Application Structure](../how-tos/index.md#application-structure).

docs/docs/concepts/assistants.md

@@ -1,37 +0,0 @@
-# Assistants
-
-!!! info "Prerequisites"
-
-    - [LangGraph Server](./langgraph_server.md)
-
-When building agents, it is fairly common to make rapid changes that *do not* alter the graph logic. For example, simply changing prompts or the LLM selection can have significant impacts on the behavior of the agents. Assistants offer an easy way to make and save these types of changes to agent configuration. This can have at least two use-cases:
-
-* Assistants give developers a quick and easy way to modify and version agents for experimentation.
-* Assistants can be modified via LangGraph Studio, offering a no-code way to configure agents  (e.g., for business users). 
-
-Assistants build off the concept of ["configuration"](low_level.md#configuration). 
-While ["configuration"](low_level.md#configuration) is available in the open source LangGraph library as well,  assistants are only present in [LangGraph Platform](langgraph_platform.md).
-This is because Assistants are tightly coupled to your deployed graph, and so we can only make them available when we are also deploying the graphs.
-
-## Configuring Assistants
-
-In practice, an assistant is just an *instance* of a graph with a specific configuration. Because of this, multiple assistants can reference the same graph but can contain different configurations, such as prompts, models, and other graph configuration options. The LangGraph Cloud API provides several endpoints for creating and managing assistants. See the [API reference](../cloud/reference/api/api_ref.html) and [this how-to](../cloud/how-tos/configuration_cloud.md) for more details on how to create assistants.
-
-## Versioning Assistants
-
-Once you've created an assistant, you can save and version it to track changes to the configuration over time. You can think about this at three levels:
-
-1) The graph lays out the general agent application logic 
-2) The agent configuration options represent parameters that can be changed 
-3) Assistant versions save and track specific settings of the agent configuration options 
-
-For example, let's imagine you have a general writing agent. You have created a general graph architecture that works well for writing. However, there are different types of writing, e.g. blogs vs tweets. In order to get the best performance on each use case, you need to make some minor changes to the models and prompts used. In this setup, you could create an assistant for each use case - one for blog writing and one for tweeting. These would share the same graph structure, but they may use different models and different prompts. Read [this how-to](../cloud/how-tos/assistant_versioning.md) to learn how you can use assistant versioning through both the [Studio](../concepts/langgraph_studio.md) and the SDK.
-
-![assistant versions](img/assistants.png)
-
-
-## Resources
-
-For more information on assistants, see the following resources:
-
-- [Assistants how-to guides](../how-tos/index.md#assistants)

docs/docs/concepts/bring_your_own_cloud.md

@@ -1,54 +0,0 @@
-# Bring Your Own Cloud (BYOC)
-
-!!! note Prerequisites
-
-    - [LangGraph Platform](./langgraph_platform.md)
-    - [Deployment Options](./deployment_options.md)
-
-## Architecture
-
-Split control plane (hosted by us) and data plane (hosted by you, managed by us).
-
-|                             | Control Plane                   | Data Plane                                    |
-|-----------------------------|---------------------------------|-----------------------------------------------|
-| What it does                | Manages deployments, revisions. | Runs your LangGraph graphs, stores your data. |
-| Where it is hosted          | LangChain Cloud account         | Your cloud account                            |
-| Who provisions and monitors | LangChain                       | LangChain                                     |
-
-LangChain has no direct access to the resources created in your cloud account, and can only interact with them via AWS APIs. Your data never leaves your cloud account / VPC at rest or in transit.
-
-![Architecture](img/byoc_architecture.png)
-
-## Requirements
-
-- You’re using AWS already.
-- You use `langgraph-cli` and/or [LangGraph Studio](./langgraph_studio.md) app to test graph locally.
-- You use `langgraph build` command to build image and then push it to your AWS ECR repository (`docker push`).
-
-## How it works
-
-- We provide you a [Terraform module](https://github.com/langchain-ai/terraform/tree/main/modules/langgraph_cloud_setup) which you run to set up our requirements
-    1. Creates an AWS role (which our control plane will later assume to provision and monitor resources)
-        - https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonVPCReadOnlyAccess.html
-            - Read VPCS to find subnets
-        - https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonECS_FullAccess.html
-            - Used to create/delete ECS resources for your LangGraph Cloud instances
-        - https://docs.aws.amazon.com/aws-managed-policy/latest/reference/SecretsManagerReadWrite.html
-            - Create secrets for your ECS resources
-        - https://docs.aws.amazon.com/aws-managed-policy/latest/reference/CloudWatchReadOnlyAccess.html
-            - Read CloudWatch metrics/logs to monitor your instances/push deployment logs
-        - https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonRDSFullAccess.html
-            - Provision `RDS` instances for your LangGraph Cloud instances
-    2. Either
-        - Tags an existing vpc / subnets as `langgraph-cloud-enabled`
-        - Creates a new vpc and subnets and tags them as `langgraph-cloud-enabled`
-- You create a LangGraph Cloud Project in `smith.langchain.com` providing
-    - the ID of the AWS role created in the step above
-    - the AWS ECR repo to pull the service image from
-- We provision the resources in your cloud account using the role above
-- We monitor those resources to ensure uptime and recovery from errors
-
-Notes for customers using [self-hosted LangSmith](https://docs.smith.langchain.com/self_hosting):
-
-- Creation of new LangGraph Cloud projects and revisions currently needs to be done on smith.langchain.com.
-- You can however set up the project to trace to your self-hosted LangSmith instance if desired

docs/docs/concepts/deployment_options.md

@@ -1,96 +0,0 @@
-# Deployment Options
-
-!!! info "Prerequisites"
-
-    - [LangGraph Platform](./langgraph_platform.md)
-    - [LangGraph Server](./langgraph_server.md)
-    - [LangGraph Platform Plans](./plans.md)
-
-## Overview
-
-There are 4 main options for deploying with the LangGraph Platform:
-
-1. **[Self-Hosted Lite](#self-hosted-lite)**: Available for all plans.
-
-2. **[Self-Hosted Enterprise](#self-hosted-enterprise)**: Available for the **Enterprise** plan.
-
-3. **[Cloud SaaS](#cloud-saas)**: Available for **Plus** and **Enterprise** plans.
-
-4. **[Bring Your Own Cloud](#bring-your-own-cloud)**: Available only for **Enterprise** plans and **only on AWS**.
-
-Please see the [LangGraph Platform Plans](./plans.md) for more information on the different plans.
-
-The guide below will explain the differences between the deployment options.
-
-## Self-Hosted Enterprise
-
-!!! important
-
-    The Self-Hosted Enterprise version is only available for the **Enterprise** plan.
-
-With a Self-Hosted Enterprise deployment, you are responsible for managing the infrastructure, including setting up and maintaining required databases and Redis instances.
-
-You’ll build a Docker image using the [LangGraph CLI](./langgraph_cli.md), which can then be deployed on your own infrastructure.
-
-For more information, please see:
-
-* [Self-Hosted conceptual guide](./self_hosted.md)
-* [Self-Hosted Deployment how-to guide](../how-tos/deploy-self-hosted.md)
-
-## Self-Hosted Lite
-
-!!! important
-
-    The Self-Hosted Lite version is available for all plans.
-
-The Self-Hosted Lite deployment option is a free (up to 1 million nodes executed), limited version of LangGraph Platform that you can run locally or in a self-hosted manner.
-
-With a Self-Hosted Lite deployment, you are responsible for managing the infrastructure, including setting up and maintaining required databases and Redis instances.
-
-You’ll build a Docker image using the [LangGraph CLI](./langgraph_cli.md), which can then be deployed on your own infrastructure.
-
-
-For more information, please see:
-
-* [Self-Hosted conceptual guide](./self_hosted.md)
-* [Self-Hosted deployment how-to guide](../how-tos/deploy-self-hosted.md)
-
-## Cloud SaaS
-
-!!! important
-
-    The Cloud SaaS version of LangGraph Platform is only available for **Plus** and **Enterprise** plans.
-
-
-The [Cloud SaaS](./langgraph_cloud.md) version of LangGraph Platform is hosted as part of [LangSmith](https://smith.langchain.com/).
-
-The Cloud SaaS version of LangGraph Platform provides a simple way to deploy and manage your LangGraph applications.
-
-This deployment option provides an integration with GitHub, allowing you to deploy code from any of your repositories on GitHub.
-
-For more information, please see:
-
-* [Cloud SaaS Conceptual Guide](./langgraph_cloud.md)
-* [How to deploy to Cloud SaaS](../cloud/deployment/cloud.md)
-
-
-## Bring Your Own Cloud
-
-!!! important
-
-    The Bring Your Own Cloud version of LangGraph Platform is only available for **Enterprise** plans.
-
-
-This combines the best of both worlds for Cloud and Self-Hosted. We manage the infrastructure, so you don't have to, but the infrastructure all runs within your cloud. This is currently only available on AWS.
-
-For more information please see:
-
-* [Bring Your Own Cloud Conceptual Guide](./bring_your_own_cloud.md)
-
-## Related
-
-For more information, please see:
-
-* [LangGraph Platform plans](./plans.md)
-* [LangGraph Platform pricing](https://www.langchain.com/langgraph-platform-pricing)
-* [Deployment how-to guides](../how-tos/index.md#deployment)

docs/docs/concepts/double_texting.md

@@ -1,42 +0,0 @@
-# Double Texting
-
-!!! info "Prerequisites"
-    - [LangGraph Server](./langgraph_server.md)
-
-Many times users might interact with your graph in unintended ways. 
-For instance, a user may send one message and before the graph has finished running send a second message. 
-More generally, users may invoke the graph a second time before the first run has finished.
-We call this "double texting".
-
-Currently, LangGraph only addresses this as part of [LangGraph Platform](langgraph_platform.md), not in the open source.
-The reason for this is that in order to handle this we need to know how the graph is deployed, and since LangGraph Platform deals with deployment the logic needs to live there.
-If you do not want to use LangGraph Platform, we describe the options we have implemented in detail below.
-
-![](img/double_texting.png)
-
-## Reject
-
-This is the simplest option, this just rejects any follow up runs and does not allow double texting. 
-See the [how-to guide](../cloud/how-tos/reject_concurrent.md) for configuring the reject double text option.
-
-## Enqueue
-
-This is a relatively simple option which continues the first run until it completes the whole run, then sends the new input as a separate run. 
-See the [how-to guide](../cloud/how-tos/enqueue_concurrent.md) for configuring the enqueue double text option.
-
-## Interrupt
-
-This option interrupts the current execution but saves all the work done up until that point. 
-It then inserts the user input and continues from there. 
-
-If you enable this option, your graph should be able to handle weird edge cases that may arise. 
-For example, you could have called a tool but not yet gotten back a result from running that tool.
-You may need to remove that tool call in order to not have a dangling tool call.
-
-See the [how-to guide](../cloud/how-tos/interrupt_concurrent.md) for configuring the interrupt double text option.
-
-## Rollback
-
-This option interrupts the current execution AND rolls back all work done up until that point, including the original run input. It then sends the new user input in, basically as if it was the original input.
-
-See the [how-to guide](../cloud/how-tos/rollback_concurrent.md) for configuring the rollback double text option.

docs/docs/concepts/faq.md

@@ -2,58 +2,9 @@
 
 Common questions and their answers!
 
-## Do I need to use LangChain to use LangGraph? What’s the difference?
+## Do I need to use LangChain in order to use LangGraph?
 
-No. LangGraph is an orchestration framework for complex agentic systems and is more low-level and controllable than LangChain agents. LangChain provides a standard interface to interact with models and other components, useful for straight-forward chains and retrieval flows.
-
-## How is LangGraph different from other agent frameworks?
-
-Other agentic frameworks can work for simple, generic tasks but fall short for complex tasks bespoke to a company’s needs. LangGraph provides a more expressive framework to handle companies’ unique tasks without restricting users to a single black-box cognitive architecture.
-
-## Does LangGraph impact the performance of my app?
-
-LangGraph will not add any overhead to your code and is specifically designed with streaming workflows in mind.
-
-## Is LangGraph open source? Is it free?
-
-Yes. LangGraph is an MIT-licensed open-source library and is free to use.
-
-## How are LangGraph and LangGraph Platform different?
-
-LangGraph is a stateful, orchestration framework that brings added control to agent workflows. LangGraph Platform is a service for deploying and scaling LangGraph applications, with an opinionated API for building agent UXs, plus an integrated developer studio.
-
-| Features | LangGraph (open source) | LangGraph Platform |
-|----------|------------------------|-------------------|
-| Description | Stateful orchestration framework for agentic applications | Scalable infrastructure for deploying LangGraph applications |
-| SDKs | Python and JavaScript | Python and JavaScript |
-| HTTP APIs | None | Yes - useful for retrieving & updating state or long-term memory, or creating a configurable assistant |
-| Streaming | Basic | Dedicated mode for token-by-token messages |
-| Checkpointer | Community contributed | Supported out-of-the-box |
-| Persistence Layer | Self-managed | Managed Postgres with efficient storage |
-| Deployment | Self-managed | • Cloud SaaS <br> • Free self-hosted <br> • Enterprise (BYOC or paid self-hosted) |
-| Scalability | Self-managed | Auto-scaling of task queues and servers |
-| Fault-tolerance | Self-managed | Automated retries |
-| Concurrency Control | Simple threading | Supports double-texting |
-| Scheduling | None | Cron scheduling |
-| Monitoring | None | Integrated with LangSmith for observability |
-| IDE integration | LangGraph Studio for Desktop | LangGraph Studio for Desktop & Cloud |
-
-## What are my deployment options for LangGraph Platform?
-
-We currently have the following deployment options for LangGraph applications:
-
-- [‍Self-Hosted Lite](./deployment_options.md#self-hosted-lite): A free (up to 1M nodes executed), limited version of LangGraph Platform that you can run locally or in a self-hosted manner. This version requires a LangSmith API key and logs all usage to LangSmith. Fewer features are available than in paid plans.
-- [Cloud SaaS](./deployment_options.md#cloud-saas): Fully managed and hosted as part of LangSmith, with automatic updates and zero maintenance.
-- [‍Bring Your Own Cloud (BYOC)](./deployment_options.md#bring-your-own-cloud): Deploy LangGraph Platform within your VPC, provisioned and run as a service. Keep data in your environment while outsourcing the management of the service.
-- [Self-Hosted Enterprise](./deployment_options.md#self-hosted-enterprise): Deploy LangGraph entirely on your own infrastructure.
-
-## Is LangGraph Platform open source?
-
-No. LangGraph Platform is proprietary software.
-
-There is a free, self-hosted version of LangGraph Platform with access to basic features. The Cloud SaaS deployment option is free while in beta, but will eventually be a paid service. We will always give ample notice before charging for a service and reward our early adopters with preferential pricing. The Bring Your Own Cloud (BYOC) and Self-Hosted Enterprise options are also paid services. [Contact our sales team](https://www.langchain.com/contact-sales) to learn more.
-
-For more information, see our [LangGraph Platform pricing page](https://www.langchain.com/pricing-langgraph-platform).
+No! LangGraph is a general-purpose framework - the nodes and edges are nothing more than Python functions. You can use LangChain, raw HTTP requests, or even other frameworks inside these nodes and edges.
 
 ## Does LangGraph work with LLMs that don't support tool calling?
 

docs/docs/concepts/high_level.md

@@ -55,4 +55,4 @@ Once you've built a graph, you often want to test and debug it. [LangGraph Studi
 
 ## Deployment
 
-Once you have confidence in your LangGraph application, many developers want an easy path to deployment. [LangGraph Platform](../concepts/index.md#langgraph-platform) offers a range of options for deploying LangGraph graphs.
+Once you have confidence in your LangGraph application, many developers want an easy path to deployment. [LangGraph Cloud](../cloud/index.md) is an opinionated, simple way to deploy LangGraph objects from the LangChain team. Of course, you can also use services like [FastAPI](https://fastapi.tiangolo.com/) and call your graph from inside the FastAPI server as you see fit.

docs/docs/concepts/index.md

@@ -1,76 +0,0 @@
----
-hide:
-  - navigation
-title: Concepts
-description: Conceptual Guide for LangGraph
----
-
-# Conceptual Guide
-
-This guide provides explanations of the key concepts behind the LangGraph framework and AI applications more broadly.
-
-We recommend that you go through at least the [Quick Start](../tutorials/introduction.ipynb) before diving into the conceptual guide. This will provide practical context that will make it easier to understand the concepts discussed here.
-
-The conceptual guide does not cover step-by-step instructions or specific implementation examples — those are found in the [Tutorials](../tutorials/index.md) and [How-to guides](../how-tos/index.md). For detailed reference material, please see the [API reference](../reference/index.md).
-
-## LangGraph
-
-**High Level**
-
-- [Why LangGraph?](high_level.md): A high-level overview of LangGraph and its goals.
-
-**Concepts**
-
-- [LangGraph Glossary](low_level.md): LangGraph workflows are designed as graphs, with nodes representing different components and edges representing the flow of information between them. This guide provides an overview of the key concepts associated with LangGraph graph primitives.
-- [Common Agentic Patterns](agentic_concepts.md): An agent uses an LLM to pick its own control flow to solve more complex problems! Agents are a key building block in many LLM applications. This guide explains the different types of agent architectures and how they can be used to control the flow of an application.
-- [Multi-Agent Systems](multi_agent.md): Complex LLM applications can often be broken down into multiple agents, each responsible for a different part of the application. This guide explains common patterns for building multi-agent systems.
-- [Human-in-the-Loop](human_in_the_loop.md): Explains different ways of integrating human feedback into a LangGraph application.
-- [Persistence](persistence.md): LangGraph has a built-in persistence layer, implemented through checkpointers. This persistence layer helps to support powerful capabilities like human-in-the-loop, memory, time travel, and fault-tolerance.
-- [Memory](memory.md): Memory in AI applications refers to the ability to process, store, and effectively recall information from past interactions. With memory, your agents can learn from feedback and adapt to users' preferences.  
-- [Streaming](streaming.md): Streaming is crucial for enhancing the responsiveness of applications built on LLMs. By displaying output progressively, even before a complete response is ready, streaming significantly improves user experience (UX), particularly when dealing with the latency of LLMs. 
-- [FAQ](faq.md): Frequently asked questions about LangGraph.
-
-## LangGraph Platform 
-
-LangGraph Platform is a commercial solution for deploying agentic applications in production, built on the open-source LangGraph framework.
-
-The LangGraph Platform offers a few different deployment options described in the [deployment options guide](./deployment_options.md).
-
-
-!!! tip
-
-    * LangGraph is an MIT-licensed open-source library, which we are committed to maintaining and growing for the community.
-    * You can always deploy LangGraph applications on your own infrastructure using the open-source LangGraph project without using LangGraph Platform.
-
-### High Level
-
-- [Why LangGraph Platform?](./langgraph_platform.md): The LangGraph platform is an opinionated way to deploy and manage LangGraph applications. This guide provides an overview of the key features and concepts behind LangGraph Platform.
-- [Deployment Options](./deployment_options.md): LangGraph Platform offers four deployment options: [Self-Hosted Lite](./self_hosted.md#self-hosted-lite), [Self-Hosted Enterprise](./self_hosted.md#self-hosted-enterprise), [bring your own cloud (BYOC)](./bring_your_own_cloud.md), and [Cloud SaaS](./langgraph_cloud.md). This guide explains the differences between these options, and which Plans they are available on.
-- [Plans](./plans.md): LangGraph Platforms offer three different plans: Developer, Plus, Enterprise. This guide explains the differences between these options, what deployment options are available for each, and how to sign up for each one.
-- [Template Applications](./template_applications.md): Reference applications designed to help you get started quickly when building with LangGraph.
-
-### Components
-
-The LangGraph Platform comprises several components that work together to support the deployment and management of LangGraph applications:
-
-- [LangGraph Server](./langgraph_server.md): The LangGraph Server is designed to support a wide range of agentic application use cases, from background processing to real-time interactions. 
-- [LangGraph Studio](./langgraph_studio.md): LangGraph Studio is a specialized IDE that can connect to a LangGraph Server to enable visualization, interaction, and debugging of the application locally.
-- [LangGraph CLI](./langgraph_cli.md): LangGraph CLI is a command-line interface that helps to interact with a local LangGraph
-- [Python/JS SDK](./sdk.md): The Python/JS SDK provides a programmatic way to interact with deployed LangGraph Applications.
-- [Remote Graph](../how-tos/use-remote-graph.md): A RemoteGraph allows you to interact with any deployed LangGraph application as though it were running locally.
-
-### LangGraph Server
-
-- [Application Structure](./application_structure.md): A LangGraph application consists of one or more graphs, a LangGraph API Configuration file (`langgraph.json`), a file that specifies dependencies, and environment variables.
-- [Assistants](./assistants.md): Assistants are a way to save and manage different configurations of your LangGraph applications.
-- [Web-hooks](./langgraph_server.md#webhooks): Webhooks allow your running LangGraph application to send data to external services on specific events.
-- [Cron Jobs](./langgraph_server.md#cron-jobs): Cron jobs are a way to schedule tasks to run at specific times in your LangGraph application.
-- [Double Texting](./double_texting.md): Double texting is a common issue in LLM applications where users may send multiple messages before the graph has finished running. This guide explains how to handle double texting with LangGraph Deploy.
-
-### Deployment Options
-
-
-- [Self-Hosted Lite](./self_hosted.md): A free (up to 1 million nodes executed), limited version of LangGraph Platform that you can run locally or in a self-hosted manner
-- [Cloud SaaS](./langgraph_cloud.md): Hosted as part of LangSmith.
-- [Bring Your Own Cloud](./bring_your_own_cloud.md): We manage the infrastructure, so you don't have to, but the infrastructure all runs within your cloud.
-- [Self-Hosted Enterprise](./self_hosted.md): Completely managed by you.

docs/docs/concepts/langgraph_cli.md

@@ -1,43 +0,0 @@
-# LangGraph CLI
-
-!!! info "Prerequisites"
-    - [LangGraph Platform](./langgraph_platform.md)
-    - [LangGraph Server](./langgraph_server.md)
-
-The LangGraph CLI is a multi-platform command-line tool for building and running the [LangGraph API server](./langgraph_server.md) locally. This offers an alternative to the [LangGraph Studio desktop app](./langgraph_studio.md) for developing and testing agents across all major operating systems (Linux, Windows, MacOS). The resulting server includes all API endpoints for your graph's runs, threads, assistants, etc. as well as the other services required to run your agent, including a managed database for checkpointing and storage.
-
-## Installation
-
-The LangGraph CLI can be installed via Homebrew (on macOS) or pip:
-
-=== "Homebrew"
-    ```bash
-    brew install langgraph-cli
-    ```
-
-=== "pip" 
-    ```bash
-    pip install langgraph-cli
-    ```
-
-## Commands
-
-The CLI provides the following core functionality:
-
-### `build`
-
-The `langgraph build` command builds a Docker image for the [LangGraph API server](./langgraph_server.md) that can be directly deployed.
-
-### `up`
-
-The `langgraph up` command starts an instance of the [LangGraph API server](./langgraph_server.md) locally. This requires docker to be installed and running locally. It also requires a LangSmith API key for local development or a license key for production use.
-
-The server includes all API endpoints for your graph's runs, threads, assistants, etc. as well as the other services required to run your agent, including a managed database for checkpointing and storage.
-
-### `dockerfile`
-
-The `langgraph dockerfile` command generates a [Dockerfile](https://docs.docker.com/reference/dockerfile/) that can be used to build images for and deploy instances of the [LangGraph API server](./langgraph_server.md). This is useful if you want to further customize the dockerfile or deploy in a more custom way.
-
-## Related
-
-- [LangGraph CLI API Reference](../cloud/reference/cli.md)

docs/docs/concepts/langgraph_cloud.md

@@ -1,38 +0,0 @@
-# Cloud SaaS
-
-!!! info "Prerequisites" 
-    - [LangGraph Platform](./langgraph_platform.md) 
-    - [LangGraph Server](./langgraph_server.md)
-
-## Overview
-
-LangGraph's Cloud SaaS is a managed service for deploying LangGraph APIs, regardless of its definition or dependencies. The service offers managed implementations of checkpointers and stores, allowing you to focus on building the right cognitive architecture for your use case. By handling scalable & secure infrastructure, LangGraph Cloud offers the fastest path to getting your LangGraph API deployed to production.
-
-## Deployment
-
-A **deployment** is an instance of a LangGraph API. A single deployment can have many [revisions](#revision). When a deployment is created, all the necessary infrastructure (e.g. database, containers, secrets store) are automatically provisioned. See the [architecture diagram](#architecture) below for more details.
-
-See the [how-to guide](../cloud/deployment/cloud.md#create-new-deployment) for creating a new deployment.
-
-## Revision
-
-A revision is an iteration of a [deployment](#deployment). When a new deployment is created, an initial revision is automatically created. To deploy new code changes or update environment variable configurations for a deployment, a new revision must be created. When a revision is created, a new container image is built automatically.
-
-See the [how-to guide](../cloud/deployment/cloud.md#create-new-revision) for creating a new revision.
-
-## Asynchronous Deployment
-
-Infrastructure for [deployments](#deployment) and [revisions](#revision) are provisioned and deployed asynchronously. They are not deployed immediately after submission. Currently, deployment can take up to several minutes.
-
-## Architecture
-
-!!! warning "Subject to Change"
-The Cloud SaaS deployment architecture may change in the future.
-
-A high-level diagram of a Cloud SaaS deployment.
-
-![diagram](img/langgraph_cloud_architecture.png)
-
-## Related
-
-- [Deployment Options](./deployment_options.md)

docs/docs/concepts/langgraph_platform.md

@@ -1,62 +0,0 @@
-# LangGraph Platform
-
-## Overview
-
-LangGraph Platform is a commercial solution for deploying agentic applications to production, built on the open-source [LangGraph framework](./high_level.md).
-
-The LangGraph Platform consists of several components that work together to support the development, deployment, debugging, and monitoring of LangGraph applications:
-
-- [LangGraph Server](./langgraph_server.md): The server defines an opinionated API and architecture that incorporates best practices for deploying agentic applications, allowing you to focus on building your agent logic rather than developing server infrastructure.
-- [LangGraph Studio](./langgraph_studio.md): LangGraph Studio is a specialized IDE that can connect to a LangGraph Server to enable visualization, interaction, and debugging of the application locally.
-- [LangGraph CLI](./langgraph_cli.md): LangGraph CLI is a command-line interface that helps to interact with a local LangGraph
-- [Python/JS SDK](./sdk.md): The Python/JS SDK provides a programmatic way to interact with deployed LangGraph Applications.
-- [Remote Graph](../how-tos/use-remote-graph.md): A RemoteGraph allows you to interact with any deployed LangGraph application as though it were running locally.
-
-![](img/lg_platform.png)
-
-The LangGraph Platform offers a few different deployment options described in the [deployment options guide](./deployment_options.md).
-
-## Why Use LangGraph Platform?
-
-LangGraph Platform is designed to make deploying agentic applications seamless and production-ready. 
-
-For simpler applications, deploying a LangGraph agent can be as straightforward as using your own server logic—for example, setting up a FastAPI endpoint and invoking LangGraph directly.
-
-### Option 1: Deploying with Custom Server Logic
-
-For basic LangGraph applications, you may choose to handle deployment using your custom server infrastructure. Setting up endpoints with frameworks like [FastAPI](https://fastapi.tiangolo.com/) allows you to quickly deploy and run LangGraph as you would any other Python application:
-
-```python
-from fastapi import FastAPI
-from your_agent_package import graph
-
-app = FastAPI()
-
-@app.get("/foo")
-async def foo(...):
-    return await graph.ainvoke({...})
-```
-
-This approach works well for simple applications with straightforward needs and provides you with full control over the deployment setup. For example, you might use this for a single-assistant application that doesn’t require long-running sessions or persistent memory.
-
-### Option 2: Leveraging LangGraph Platform for Complex Deployments
-
-As your applications scale or add complex features, the deployment requirements often evolve. Running an application with more nodes, longer processing times, or a need for persistent memory can introduce challenges that quickly become time-consuming and difficult to manage manually. [LangGraph Platform](./langgraph_platform.md) is built to handle these challenges seamlessly, allowing you to focus on agent logic rather than server infrastructure.
-
-Here are some common issues that arise in complex deployments, which LangGraph Platform addresses:
-
-- **[Streaming Support](streaming.md)**: As agents grow more sophisticated, they often benefit from streaming both token outputs and intermediate states back to the user. Without this, users are left waiting for potentially long operations with no feedback. LangGraph Server provides [multiple streaming modes](streaming.md) optimized for various application needs.
-
-- **Background Runs**: For agents that take longer to process (e.g., hours), maintaining an open connection can be impractical. The LangGraph Server supports launching agent runs in the background and provides both polling endpoints and webhooks to monitor run status effectively.
- 
-- **Support for long runs**: Vanilla server setups often encounter timeouts or disruptions when handling requests that take a long time to complete. LangGraph Server’s API provides robust support for these tasks by sending regular heartbeat signals, preventing unexpected connection closures during prolonged processes.
-
-- **Handling Burstiness**: Certain applications, especially those with real-time user interaction, may experience "bursty" request loads where numerous requests hit the server simultaneously. LangGraph Server includes a task queue, ensuring requests are handled consistently without loss, even under heavy loads.
-
-- **[Double Texting](double_texting.md)**: In user-driven applications, it’s common for users to send multiple messages rapidly. This “double texting” can disrupt agent flows if not handled properly. LangGraph Server offers built-in strategies to address and manage such interactions.
-
-- **[Checkpointers and Memory Management](persistence.md#checkpoints)**: For agents needing persistence (e.g., conversation memory), deploying a robust storage solution can be complex. LangGraph Platform includes optimized [checkpointers](persistence.md#checkpoints) and a [memory store](persistence.md#memory-store), managing state across sessions without the need for custom solutions.
-
-- **[Human-in-the-loop Support](human_in_the_loop.md)**: In many applications, users require a way to intervene in agent processes. LangGraph Server provides specialized endpoints for human-in-the-loop scenarios, simplifying the integration of manual oversight into agent workflows.
-
-By using LangGraph Platform, you gain access to a robust, scalable deployment solution that mitigates these challenges, saving you the effort of implementing and maintaining them manually. This allows you to focus more on building effective agent behavior and less on solving deployment infrastructure issues.

docs/docs/concepts/langgraph_server.md

@@ -1,130 +0,0 @@
-# LangGraph Server
-
-!!! info "Prerequisites"
-    - [LangGraph Platform](./langgraph_platform.md)
-    - [LangGraph Glossary](low_level.md)
-
-## Overview
-
-LangGraph Server offers an API for creating and managing agent-based applications. It is built on the concept of [assistants](assistants.md), which are agents configured for specific tasks, and includes built-in [persistence](persistence.md#memory-store) and a **task queue**. This versatile API supports a wide range of agentic application use cases, from background processing to real-time interactions.
-
-## Key Features
-
-The LangGraph Platform incorporates best practices for agent deployment, so you can focus on building your agent logic.
-
-* **Streaming endpoints**: Endpoints that expose [multiple different streaming modes](streaming.md). We've made these work even for long-running agents that may go minutes between consecutive stream events.
-* **Background runs**: The LangGraph Server supports launching assistants in the background with endpoints for polling the status of the assistant's run and webhooks to monitor run status effectively.
-- **Support for long runs**: Our blocking endpoints for running assistants send regular heartbeat signals, preventing unexpected connection closures when handling requests that take a long time to complete.
-* **Task queue**: We've added a task queue to make sure we don't drop any requests if they arrive in a bursty nature.
-* **Horizontally scalable infrastructure**: LangGraph Server is designed to be horizontally scalable, allowing you to scale up and down your usage as needed.
-* **Double texting support**: Many times users might interact with your graph in unintended ways. For instance, a user may send one message and before the graph has finished running send a second message. We call this ["double texting"](double_texting.md) and have added four different ways to handle this.
-* **Optimized checkpointer**: LangGraph Platform comes with a built-in [checkpointer](./persistence.md#checkpoints) optimized for LangGraph applications.
-* **Human-in-the-loop endpoints**: We've exposed all endpoints needed to support [human-in-the-loop](human_in_the_loop.md) features.
-* **Memory**: In addition to thread-level persistence (covered above by [checkpointers]l(./persistence.md#checkpoints)), LangGraph Platform also comes with a built-in [memory store](persistence.md#memory-store).
-* **Cron jobs**: Built-in support for scheduling tasks, enabling you to automate regular actions like data clean-up or batch processing within your applications.
-* **Webhooks**: Allows your application to send real-time notifications and data updates to external systems, making it easy to integrate with third-party services and trigger actions based on specific events.
-* **Monitoring**: LangGraph Server integrates seamlessly with the [LangSmith](https://docs.smith.langchain.com/) monitoring platform, providing real-time insights into your application's performance and health.
-
-## What are you deploying?
-
-When you deploy a LangGraph Server, you are deploying one or more [graphs](#graphs), a database for [persistence](persistence.md), and a task queue.
-
-### Graphs
-
-When you deploy a graph with LangGraph Server, you are deploying a "blueprint" for an [Assistant](assistants.md). 
-
-An [Assistant](assistants.md) is a graph paired with specific configuration settings. You can create multiple assistants per graph, each with unique settings to accommodate different use cases
-that can be served by the same graph.
-
-Upon deployment, LangGraph Server will automatically create a default assistant for each graph using the graph's default configuration settings.
-
-You can interact with assistants through the [LangGraph Server API](#langgraph-server-api).
-
-!!! note
-
-    We often think of a graph as implementing an [agent](agentic_concepts.md), but a graph does not necessarily need to implement an agent. For example, a graph could implement a simple
-    chatbot that only supports back-and-forth conversation, without the ability to influence any application control flow. In reality, as applications get more complex, a graph will often implement a more complex flow that may use [multiple agents](./multi_agent.md) working in tandem.
-
-### Persistence and Task Queue
-
-The LangGraph Server leverages a database for [persistence](persistence.md) and a task queue.
-
-Currently, only [Postgres](https://www.postgresql.org/) is supported as a database for LangGraph Server and [Redis](https://redis.io/) as the task queue.
-
-If you're deploying using [LangGraph Cloud](./langgraph_cloud.md), these components are managed for you. If you're deploying LangGraph Server on your own infrastructure, you'll need to set up and manage these components yourself.
-
-Please review the [deployment options](./deployment_options.md) guide for more information on how these components are set up and managed.
-
-## Application Structure
-
-To deploy a LangGraph Server application, you need to specify the graph(s) you want to deploy, as well as any relevant configuration settings, such as dependencies and environment variables.
-
-Read the [application structure](./application_structure.md) guide to learn how to structure your LangGraph application for deployment.
-
-## LangGraph Server API
-
-The LangGraph Server API allows you to create and manage [assistants](assistants.md), [threads](#threads), [runs](#runs), [cron jobs](#cron-jobs), and more.
-
-The [LangGraph Cloud API Reference](../cloud/reference/api/api_ref.html) provides detailed information on the API endpoints and data models.
-
-### Assistants
-
-An [Assistant](assistants.md) refers to a [graph](#graphs) plus specific [configuration](low_level.md#configuration) settings for that graph.
-
-You can think of an assistant as a saved configuration of an [agent](agentic_concepts.md).
-
-When building agents, it is fairly common to make rapid changes that *do not* alter the graph logic. For example, simply changing prompts or the LLM selection can have significant impacts on the behavior of the agents. Assistants offer an easy way to make and save these types of changes to agent configuration.
-
-### Threads
-
-A thread contains the accumulated state of a sequence of [runs](#runs). If a run is executed on a thread, then the [state](low_level.md#state) of the underlying graph of the assistant will be persisted to the thread.
-
-A thread's current and historical state can be retrieved. To persist state, a thread must be created prior to executing a run.
-
-The state of a thread at a particular point in time is called a [checkpoint](persistence.md#checkpoints). Checkpoints can be used to restore the state of a thread at a later time.
-
-For more on threads and checkpoints, see this section of the [LangGraph conceptual guide](low_level.md#persistence).
-
-The LangGraph Cloud API provides several endpoints for creating and managing threads and thread state. See the [API reference](../cloud/reference/api/api_ref.html#tag/threads) for more details.
-
-### Runs
-
-A run is an invocation of an [assistant](#assistants). Each run may have its own input, configuration, and metadata, which may affect execution and output of the underlying graph. A run can optionally be executed on a [thread](#threads).
-
-The LangGraph Cloud API provides several endpoints for creating and managing runs. See the [API reference](../cloud/reference/api/api_ref.html#tag/thread-runs/) for more details.
-
-### Store
-
-Store is an API for managing persistent [key-value store](./persistence.md#memory-store) that is available from any [thread](#threads).
-
-Stores are useful for implementing [memory](./memory.md) in your LangGraph application.
-
-### Cron Jobs
-
-There are many situations in which it is useful to run an assistant on a schedule. 
-
-For example, say that you're building an assistant that runs daily and sends an email summary
-of the day's news. You could use a cron job to run the assistant every day at 8:00 PM.
-
-LangGraph Cloud supports cron jobs, which run on a user-defined schedule. The user specifies a schedule, an assistant, and some input. After that, on the specified schedule, the server will:
-
-- Create a new thread with the specified assistant
-- Send the specified input to that thread
-
-Note that this sends the same input to the thread every time. See the [how-to guide](../cloud/how-tos/cron_jobs.md) for creating cron jobs.
-
-The LangGraph Cloud API provides several endpoints for creating and managing cron jobs. See the [API reference](../cloud/reference/api/api_ref.html#tag/runscreate/POST/threads/{thread_id}/runs/crons) for more details.
-
-### Webhooks
-
-Webhooks enable event-driven communication from your LangGraph Cloud application to external services. For example, you may want to issue an update to a separate service once an API call to LangGraph Cloud has finished running.
-
-Many LangGraph Cloud endpoints accept a `webhook` parameter. If this parameter is specified by a an endpoint that can accept POST requests, LangGraph Cloud will send a request at the completion of a run.
-
-See the corresponding [how-to guide](../cloud/how-tos/webhooks.md) for more detail.
-
-## Related
-
-* LangGraph [Application Structure](./application_structure.md) guide explains how to structure your LangGraph application for deployment.
-* [How-to guides for the LangGraph Platform](../how-tos/index.md).
-* The [LangGraph Cloud API Reference](../cloud/reference/api/api_ref.html) provides detailed information on the API endpoints and data models.

docs/docs/concepts/low_level.md

@@ -20,7 +20,7 @@ A super-step can be considered a single iteration over the graph nodes. Nodes th
 
 ### StateGraph
 
-The `StateGraph` class is the main graph class to use. This is parameterized by a user defined `State` object.
+The `StateGraph` class is the main graph class to uses. This is parameterized by a user defined `State` object.
 
 ### MessageGraph
 
@@ -52,12 +52,12 @@ By default, the graph will have the same input and output schemas. If you want t
 
 Typically, all graph nodes communicate with a single schema. This means that they will read and write to the same state channels. But, there are cases where we want more control over this:
 
-- Internal nodes can pass information that is not required in the graph's input / output.
-- We may also want to use different input / output schemas for the graph. The output might, for example, only contain a single relevant output key.
+* Internal nodes can pass information that is not required in the graph's input / output.
+* We may also want to use different input / output schemas for the graph. The output might, for example, only contain a single relevant output key.
 
-It is possible to have nodes write to private state channels inside the graph for internal node communication. We can simply define a private schema, `PrivateState`. See [this notebook](../how-tos/pass_private_state.ipynb) for more detail.
+It is possible to have nodes write to private state channels inside the graph for internal node communication. We can simply define a private schema, `PrivateState`. See [this notebook](../how-tos/pass_private_state.ipynb) for more detail.  
 
-It is also possible to define explicit input and output schemas for a graph. In these cases, we define an "internal" schema that contains _all_ keys relevant to graph operations. But, we also define `input` and `output` schemas that are sub-sets of the "internal" schema to constrain the input and output of the graph. See [this notebook](../how-tos/input_output_schema.ipynb) for more detail.
+It is also possible to define explicit input and output schemas for a graph. In these cases, we define an "internal" schema that contains *all* keys relevant to graph operations. But, we also define `input` and `output` schemas that are sub-sets of the "internal" schema to constrain the input and output of the graph. See [this notebook](../how-tos/input_output_schema.ipynb) for more detail.
 
 Let's look at an example:
 
@@ -101,12 +101,11 @@ graph = builder.compile()
 graph.invoke({"user_input":"My"})
 {'graph_output': 'My name is Lance'}
 ```
-
 There are two subtle and important points to note here:
 
-1. We pass `state: InputState` as the input schema to `node_1`. But, we write out to `foo`, a channel in `OverallState`. How can we write out to a state channel that is not included in the input schema? This is because a node _can write to any state channel in the graph state._ The graph state is the union of of the state channels defined at initialization, which includes `OverallState` and the filters `InputState` and `OutputState`.
+1. We pass `state: InputState` as the input schema to `node_1`. But, we write out to `foo`, a channel in `OverallState`. How can we write out to a state channel that is not included in the input schema? This is because a node *can write to any state channel in the graph state.* The graph state is the union of of the state channels defined at initialization, which includes `OverallState` and the filters `InputState` and `OutputState`.
 
-2. We initialize the graph with `StateGraph(OverallState,input=InputState,output=OutputState)`. So, how can we write to `PrivateState` in `node_2`? How does the graph gain access to this schema if it was not passed in the `StateGraph` initialization? We can do this because _nodes can also declare additional state channels_ as long as the state schema definition exists. In this case, the `PrivateState` schema is defined, so we can add `bar` as a new state channel in the graph and write to it.
+2. We initialize the graph with `StateGraph(OverallState,input=InputState,output=OutputState)`. So, how can we write to `PrivateState` in `node_2`? How does the graph gain access to this schema if it was not passed in the `StateGraph` initialization? We can do this because *nodes can also declare additional state channels* as long as the state schema definition exists. In this case, the `PrivateState` schema is defined, so we can add `bar` as a new state channel in the graph and write to it.
 
 ### Reducers
 
@@ -324,16 +323,7 @@ graph.add_conditional_edges("node_a", continue_to_jokes)
 
 ## Persistence
 
-LangGraph provides built-in persistence for your agent's state using [checkpointers][langgraph.checkpoint.base.BaseCheckpointSaver]. Checkpointers save snapshots of the graph state at every superstep, allowing resumption at any time. This enables features like human-in-the-loop interactions, memory management, and fault-tolerance. You can even directly manipulate a graph's state after its execution using the
-appropriate `get` and `update` methods. For more details, see the [persistence conceptual guide](./persistence.md).
-
-## Threads
-
-Threads in LangGraph represent individual sessions or conversations between your graph and a user. When using checkpointing, turns in a single conversation (and even steps within a single graph execution) are organized by a unique thread ID.
-
-## Storage
-
-LangGraph provides built-in document storage through the [BaseStore][langgraph.store.base.BaseStore] interface. Unlike checkpointers, which save state by thread ID, stores use custom namespaces for organizing data. This enables cross-thread persistence, allowing agents to maintain long-term memories, learn from past interactions, and accumulate knowledge over time. Common use cases include storing user profiles, building knowledge bases, and managing global preferences across all threads.
+LangGraph has a built-in persistence layer, implemented through [checkpointers][langgraph.checkpoint.base.BaseCheckpointSaver]. When you use a checkpointer with a graph, you can interact with and manage the graph's state after the execution. The checkpointer saves a _checkpoint_ (a snapshot) of the graph state at every superstep, enabling several powerful capabilities, including human-in-the-loop, memory and fault-tolerance. See this [conceptual guide](./persistence.md) for more information.
 
 ## Graph Migrations
 
@@ -391,7 +381,7 @@ Read [this how-to](https://langchain-ai.github.io/langgraph/how-tos/recursion-li
 
 It can often be useful to set breakpoints before or after certain nodes execute. This can be used to wait for human approval before continuing. These can be set when you ["compile" a graph](#compiling-your-graph). You can set breakpoints either _before_ a node executes (using `interrupt_before`) or after a node executes (using `interrupt_after`.)
 
-You **MUST** use a [checkpointer](./persistence.md) when using breakpoints. This is because your graph needs to be able to resume execution.
+You **MUST** use a [checkpoiner](./persistence.md) when using breakpoints. This is because your graph needs to be able to resume execution.
 
 In order to resume execution, you can just invoke your graph with `None` as the input.
 
@@ -417,112 +407,10 @@ def my_node(state: State) -> State:
     return state
 ```
 
-## Subgraphs
-
-A subgraph is a [graph](#graphs) that is used as a [node](#nodes) in another graph. This is nothing more than the age-old concept of encapsulation, applied to LangGraph. Some reasons for using subgraphs are:
-
-- building [multi-agent systems](./multi_agent.md)
-
-- when you want to reuse a set of nodes in multiple graphs, which maybe share some state, you can define them once in a subgraph and then use them in multiple parent graphs
-
-- when you want different teams to work on different parts of the graph independently, you can define each part as a subgraph, and as long as the subgraph interface (the input and output schemas) is respected, the parent graph can be built without knowing any details of the subgraph
-
-There are two ways to add subgraphs to a parent graph:
-
-- add a node with the compiled subgraph: this is useful when the parent graph and the subgraph share state keys and you don't need to transform state on the way in or out
-
-```python
-builder.add_node("subgraph", subgraph_builder.compile())
-```
-
-- add a node with a function that invokes the subgraph: this is useful when the parent graph and the subgraph have different state schemas and you need to transform state before or after calling the subgraph
-
-```python
-subgraph = subgraph_builder.compile()
-
-def call_subgraph(state: State):
-    return subgraph.invoke({"subgraph_key": state["parent_key"]})
-
-builder.add_node("subgraph", call_subgraph)
-```
-
-Let's take a look at examples for each.
-
-### As a compiled graph
-
-The simplest way to create subgraph nodes is by using a [compiled subgraph](#compiling-your-graph) directly. When doing so, it is **important** that the parent graph and the subgraph [state schemas](#state) share at least one key which they can use to communicate. If your graph and subgraph do not share any keys, you should use write a function [invoking the subgraph](#as-a-function) instead.
-
-!!! Note
-    If you pass extra keys to the subgraph node (i.e., in addition to the shared keys), they will be ignored by the subgraph node. Similarly, if you return extra keys from the subgraph, they will be ignored by the parent graph.
-
-```python
-from langgraph.graph import START, StateGraph
-from typing import TypedDict
-
-class State(TypedDict):
-    foo: str
-
-class SubgraphState(TypedDict):
-    foo: str  # note that this key is shared with the parent graph state
-    bar: str
-
-# Define subgraph
-def subgraph_node(state: SubgraphState):
-    # note that this subgraph node can communicate with the parent graph via the shared "foo" key
-    return {"foo": state["foo"] + "bar"}
-
-subgraph_builder = StateGraph(SubgraphState)
-subgraph_builder.add_node(subgraph_node)
-...
-subgraph = subgraph_builder.compile()
-
-# Define parent graph
-builder = StateGraph(State)
-builder.add_node("subgraph", subgraph)
-...
-graph = builder.compile()
-```
-
-### As a function
-
-You might want to define a subgraph with a completely different schema. In this case, you can create a node function that invokes the subgraph. This function will need to [transform](../how-tos/subgraph-transform-state.ipynb) the input (parent) state to the subgraph state before invoking the subgraph, and transform the results back to the parent state before returning the state update from the node.
-
-```python
-class State(TypedDict):
-    foo: str
-
-class SubgraphState(TypedDict):
-    # note that none of these keys are shared with the parent graph state
-    bar: str
-    baz: str
-
-# Define subgraph
-def subgraph_node(state: SubgraphState):
-    return {"bar": state["bar"] + "baz"}
-
-subgraph_builder = StateGraph(SubgraphState)
-subgraph_builder.add_node(subgraph_node)
-...
-subgraph = subgraph_builder.compile()
-
-# Define parent graph
-def node(state: State):
-    # transform the state to the subgraph state
-    response = subgraph.invoke({"bar": state["foo"]})
-    # transform response back to the parent state
-    return {"foo": response["bar"]}
-
-builder = StateGraph(State)
-# note that we are using `node` function instead of a compiled subgraph
-builder.add_node(node)
-...
-graph = builder.compile()
-```
-
 ## Visualization
 
 It's often nice to be able to visualize graphs, especially as they get more complex. LangGraph comes with several built-in ways to visualize graphs. See [this how-to guide](../how-tos/visualization.ipynb) for more info.
 
 ## Streaming
 
-LangGraph is built with first class support for streaming, including streaming updates from graph nodes during the execution, streaming tokens from LLM calls and more. See this [conceptual guide](./streaming.md) for more information.
+LangGraph is built with first class support for streaming, including streaming updates from graph nodes during the execution, streaming tokens from LLM calls and more. See this [conceptual guide](./streaming.md) for more information.

docs/docs/concepts/memory.md

@@ -2,145 +2,41 @@
 
 ## What is Memory?
 
-[Memory](https://pmc.ncbi.nlm.nih.gov/articles/PMC10410470/) is a cognitive function that allows people to store, retrieve, and use information to understand their present and future. Consider the frustration of working with a colleague who forgets everything you tell them, requiring constant repetition! As AI agents undertake more complex tasks involving numerous user interactions, equipping them with memory becomes equally crucial for efficiency and user satisfaction. With memory, agents can learn from feedback and adapt to users' preferences. This guide covers two types of memory based on recall scope:
+Memory in the context of LLMs and AI applications refers to the ability to process, retain, and utilize information from past interactions or data sources. Examples include:
 
-**Short-term memory**, or [thread](persistence.md#threads)-scoped memory, can be recalled at any time **from within** a single conversational thread with a user. LangGraph manages short-term memory as a part of your agent's [state](low_level.md#state). State is persisted to a database using a [checkpointer](persistence.md#checkpoints) so the thread can be resumed at any time. Short-term memory updates when the graph is invoked or a step is completed, and the State is read at the start of each step.
+- Managing what messages (e.g., from a long message history) are sent to a chat model to limit token usage
+- Summarizing past conversations to give a chat model context from prior interactions
+- Selecting few shot examples (e.g., from a dataset) to guide model responses
+- Maintaining persistent data (e.g., user preferences) across multiple chat sessions
+- Allowing an LLM to update its own prompt using past information (e.g., meta-prompting)
+- Retrieving information relevant to a conversation or question from a long-term storage system
 
-**Long-term memory** is shared **across** conversational threads. It can be recalled _at any time_ and **in any thread**. Memories are scoped to any custom namespace, not just within a single thread ID. LangGraph provides [stores](persistence.md#memory-store) ([reference doc](https://langchain-ai.github.io/langgraph/reference/store/#langgraph.store.base.BaseStore)) to let you save and recall long-term memories.
+Below, we'll discuss each of these examples in some detail. 
 
-Both are important to understand and implement for your application.
-
-![](img/memory/short-vs-long.png)
-
-## Short-term memory
-
-Short-term memory lets your application remember previous interactions within a single [thread](persistence.md#threads) or conversation. A [thread](persistence.md#threads) organizes multiple interactions in a session, similar to the way email groups messages in a single conversation.
-
-LangGraph manages short-term memory as part of the agent's state, persisted via thread-scoped checkpoints. This state can normally include the conversation history along with other stateful data, such as uploaded files, retrieved documents, or generated artifacts. By storing these in the graph's state, the bot can access the full context for a given conversation while maintaining separation between different threads.
-
-Since conversation history is the most common form of representing short-term memory, in the next section, we will cover techniques for managing conversation history when the list of messages becomes **long**. If you want to stick to the high-level concepts, continue on to the [long-term memory](#long-term-memory) section.
-
-### Managing long conversation history
-
-Long conversations pose a challenge to today's LLMs. The full history may not even fit inside an LLM's context window, resulting in an irrecoverable error. Even _if_ your LLM technically supports the full context length, most LLMs still perform poorly over long contexts. They get "distracted" by stale or off-topic content, all while suffering from slower response times and higher costs.
-
-Managing short-term memory is an exercise of balancing [precision & recall](https://en.wikipedia.org/wiki/Precision_and_recall#:~:text=Precision%20can%20be%20seen%20as,irrelevant%20ones%20are%20also%20returned) with your application's other performance requirements (latency & cost). As always, it's important to think critically about how you represent information for your LLM and to look at your data. We cover a few common techniques for managing message lists below and hope to provide sufficient context for you to pick the best tradeoffs for your application:
-
-- [Editing message lists](#editing-message-lists): How to think about trimming and filtering a list of messages before passing to language model.
-- [Summarizing past conversations](#summarizing-past-conversations): A common technique to use when you don't just want to filter the list of messages.
+## Managing Messages
 
 ### Editing message lists
 
-Chat models accept context using [messages](https://python.langchain.com/docs/concepts/#messages), which include developer provided instructions (a system message) and user inputs (human messages). In chat applications, messages alternate between human inputs and model responses, resulting in a list of messages that grows longer over time. Because context windows are limited and token-rich message lists can be costly, many applications can benefit from using techniques to manually remove or forget stale information.
+Chat models accept instructions through [messages](https://python.langchain.com/docs/concepts/#messages), which can serve as general instructions (e.g., a system message) or user-provided instructions (e.g., human messages). In chat applications, messages often alternate between human inputs and model responses, accumulating in a list over time. Because context windows are limited and token-rich message lists can be costly, many applications can benefit from approaches to actively manage messages.    
 
-![](img/memory/filter.png)
-
-The most direct approach is to remove old messages from a list (similar to a [least-recently used cache](https://en.wikipedia.org/wiki/Page_replacement_algorithm#Least_recently_used)).
-
-The typical technique for deleting content from a list in LangGraph is to return an update from a node telling the system to delete some portion of the list. You get to define what this update looks like, but a common approach would be to let you return an object or dictionary specifying which values to retain.
+The most directed approach is to remove specific messages from a list. This can be done using [RemoveMessage](https://langchain-ai.github.io/langgraph/how-tos/memory/delete-messages/#manually-deleting-messages) based upon the message `id`, a unique identifier for each message. In the below example, we keep only the last two messages in the list using `RemoveMessage` to remove older messages based  upon their `id`.
 
 ```python
-def manage_list(existing: list, updates: Union[list, dict]):
-    if isinstance(updates, list):
-        # Normal case, add to the history
-        return existing + updates
-    elif isinstance(updates, dict) and updates["type"] == "keep":
-        # You get to decide what this looks like.
-        # For example, you could simplify and just accept a string "DELETE"
-        # and clear the entire list.
-        return existing[updates["from"]:updates["to"]]
-    # etc. We define how to interpret updates
+from langchain_core.messages import RemoveMessage
 
-class State(TypedDict):
-    my_list: Annotated[list, manage_list]
+# Message list
+messages = [AIMessage("Hi.", name="Bot", id="1")]
+messages.append(HumanMessage("Hi.", name="Lance", id="2"))
+messages.append(AIMessage("So you said you were researching ocean mammals?", name="Bot", id="3"))
+messages.append(HumanMessage("Yes, I know about whales. But what others should I learn about?", name="Lance", id="4"))
 
-def my_node(state: State):
-    return {
-        # We return an update for the field "my_list" saying to
-        # keep only values from index -5 to the end (deleting the rest)
-        "my_list": {"type": "keep", "from": -5, "to": None}
-    }
+# Isolate messages to delete
+delete_messages = [RemoveMessage(id=m.id) for m in messages[:-2]]
+print(delete_messages)
+[RemoveMessage(content='', id='1'), RemoveMessage(content='', id='2')]
 ```
 
-LangGraph will call the `manage_list` "[reducer](low_level.md#reducers)" function any time an update is returned under the key "my_list". Within that function, we define what types of updates to accept. Typically, messages will be added to the existing list (the conversation will grow); however, we've also added support to accept a dictionary that lets you "keep" certain parts of the state. This lets you programmatically drop old message context.
-
-Another common approach is to let you return a list of "remove" objects that specify the IDs of all messages to delete. If you're using the LangChain messages and the [`add_messages`](https://langchain-ai.github.io/langgraph/reference/graphs/#langgraph.graph.message.add_messages) reducer (or `MessagesState`, which uses the same underlying functionality) in LangGraph, you can do this using a `RemoveMessage`.
-
-```python
-from langchain_core.messages import RemoveMessage, AIMessage
-from langgraph.graph import add_messages
-# ... other imports
-
-class State(TypedDict):
-    # add_messages will default to upserting messages by ID to the existing list
-    # if a RemoveMessage is returned, it will delete the message in the list by ID
-    messages: Annotated[list, add_messages]
-
-def my_node_1(state: State):
-    # Add an AI message to the `messages` list in the state
-    return {"messages": [AIMessage(content="Hi")]}
-
-def my_node_2(state: State):
-    # Delete all but the last 2 messages from the `messages` list in the state
-    delete_messages = [RemoveMessage(id=m.id) for m in state['messages'][:-2]]
-    return {"messages": delete_messages}
-
-```
-
-In the example above, the `add_messages` reducer allows us to [append](https://langchain-ai.github.io/langgraph/concepts/low_level/#serialization) new messages to the `messages` state key as shown in `my_node_1`. When it sees a `RemoveMessage`, it will delete the message with that ID from the list (and the RemoveMessage will then be discarded). For more information on LangChain-specific message handling, check out [this how-to on using `RemoveMessage` ](https://langchain-ai.github.io/langgraph/how-tos/memory/delete-messages/).
-
-See this how-to [guide](https://langchain-ai.github.io/langgraph/how-tos/memory/manage-conversation-history/) and module 2 from our [LangChain Academy](https://github.com/langchain-ai/langchain-academy/tree/main/module-2) course for example usage.
-
-### Summarizing past conversations
-
-The problem with trimming or removing messages, as shown above, is that we may lose information from culling of the message queue. Because of this, some applications benefit from a more sophisticated approach of summarizing the message history using a chat model.
-
-![](img/memory/summary.png)
-
-Simple prompting and orchestration logic can be used to achieve this. As an example, in LangGraph we can extend the [MessagesState](https://langchain-ai.github.io/langgraph/concepts/low_level/#working-with-messages-in-graph-state) to include a `summary` key.
-
-```python
-from langgraph.graph import MessagesState
-class State(MessagesState):
-    summary: str
-```
-
-Then, we can generate a summary of the chat history, using any existing summary as context for the next summary. This `summarize_conversation` node can be called after some number of messages have accumulated in the `messages` state key.
-
-```python
-def summarize_conversation(state: State):
-
-    # First, we get any existing summary
-    summary = state.get("summary", "")
-
-    # Create our summarization prompt
-    if summary:
-
-        # A summary already exists
-        summary_message = (
-            f"This is a summary of the conversation to date: {summary}\n\n"
-            "Extend the summary by taking into account the new messages above:"
-        )
-
-    else:
-        summary_message = "Create a summary of the conversation above:"
-
-    # Add prompt to our history
-    messages = state["messages"] + [HumanMessage(content=summary_message)]
-    response = model.invoke(messages)
-
-    # Delete all but the 2 most recent messages
-    delete_messages = [RemoveMessage(id=m.id) for m in state["messages"][:-2]]
-    return {"summary": response.content, "messages": delete_messages}
-```
-
-See this how-to [here](https://langchain-ai.github.io/langgraph/how-tos/memory/add-summary-conversation-history/) and module 2 from our [LangChain Academy](https://github.com/langchain-ai/langchain-academy/tree/main/module-2) course for example usage.
-
-### Knowing **when** to remove messages
-
-Most LLMs have a maximum supported context window (denominated in tokens). A simple way to decide when to truncate messages is to count the tokens in the message history and truncate whenever it approaches that limit. Naive truncation is straightforward to implement on your own, though there are a few "gotchas". Some model APIs further restrict the sequence of message types (must start with human message, cannot have consecutive messages of the same type, etc.). If you're using LangChain, you can use the [`trim_messages`](https://python.langchain.com/docs/how_to/trim_messages/#trimming-based-on-token-count) utility and specify the number of tokens to keep from the list, as well as the `strategy` (e.g., keep the last `max_tokens`) to use for handling the boundary.
-
-Below is an example.
+Because the context window for chat model is denominated in tokens, it can be useful to trim message lists based upon some number of tokens that we want to retain. To do this, we can use [`trim_messages`](https://python.langchain.com/docs/how_to/trim_messages/#trimming-based-on-token-count) and specify number of token to keep from the list, as well as the `strategy` (e.g., keep the last `max_tokens`). 
 
 ```python
 from langchain_core.messages import trim_messages
@@ -150,7 +46,10 @@ trim_messages(
     strategy="last",
     # Remember to adjust based on your model
     # or else pass a custom token_encoder
-    token_counter=ChatOpenAI(model="gpt-4"),
+    token_counter=ChatOpenAI(model="gpt-4o"),
+    # Most chat models expect that chat history starts with either:
+    # (1) a HumanMessage or
+    # (2) a SystemMessage followed by a HumanMessage
     # Remember to adjust based on the desired conversation
     # length
     max_tokens=45,
@@ -168,141 +67,109 @@ trim_messages(
     include_system=True,
 )
 ```
+### Usage with LangGraph
 
-## Long-term memory
-
-Long-term memory in LangGraph allows systems to retain information across different conversations or sessions. Unlike short-term memory, which is thread-scoped, long-term memory is saved within custom "namespaces."
-
-### Storing memories
-
-LangGraph stores long-term memories as JSON documents in a [store](persistence.md#memory-store) ([reference doc](https://langchain-ai.github.io/langgraph/reference/store/#langgraph.store.base.BaseStore)). Each memory is organized under a custom `namespace` (similar to a folder) and a distinct `key` (like a filename). Namespaces often include user or org IDs or other labels that makes it easier to organize information. This structure enables hierarchical organization of memories. Cross-namespace searching is then supported through content filters. See the example below for an example.
+When building agents in LangGraph, we commonly want to manage a list of messages in the graph state. Because this is such a common use case, [MessagesState](https://langchain-ai.github.io/langgraph/concepts/low_level/#working-with-messages-in-graph-state) is a built-in LangGraph state schema that includes a `messages` key, which is a list of messages. `MessagesState` also includes an `add_messages` reducer for updating the messages list with new messages as the application runs. The `add_messages` reducer allows us to [append](https://langchain-ai.github.io/langgraph/concepts/low_level/#serialization) new messages to the `messages` state key as shown below. When we perform a state update with `{"messages": new_message}` returned from `my_node`, the `add_messages` reducer appends `new_message` to the existing list of messages.
 
 ```python
-from langgraph.store.memory import InMemoryStore
-
-# InMemoryStore saves data to an in-memory dictionary. Use a DB-backed store in production use.
-store = InMemoryStore()
-user_id = "my-user"
-application_context = "chitchat"
-namespace = (user_id, application_context)
-store.put(namespace, "a-memory", {"rules": ["User likes short, direct language", "User only speaks English & python"], "my-key": "my-value"})
-# get the "memory" by ID
-item = store.get(namespace, "a-memory")
-# list "memories" within this namespace, filtering on content equivalence
-items = store.search(namespace, filter={"my-key": "my-value"})
+def my_node(state: State):
+    # Add a new message to the state
+    new_message = HumanMessage(content="message")
+    return {"messages": new_message}
 ```
 
-### Framework for thinking about long-term memory
+The `add_messages` reducer built into `MessagesState` [also works with the `RemoveMessage` utility that we discussed above](https://langchain-ai.github.io/langgraph/how-tos/memory/delete-messages/). In this case, we can perform a state update with a list of `delete_messages` to remove specific messages from the `messages` list.
 
-Long-term memory is a complex challenge without a one-size-fits-all solution. However, the following questions provide a structure framework to help you navigate the different techniques:
+```python
+def my_node(state: State):
+    # Delete messages from state
+    delete_messages = [RemoveMessage(id=m.id) for m in state['messages'][:-2]]
+    return {"messages": delete_messages}
+```
 
-**What is the type of memory?**
+See this how-to [guide](https://langchain-ai.github.io/langgraph/how-tos/memory/manage-conversation-history/) and module 2 from our [LangChain Academy](https://github.com/langchain-ai/langchain-academy/tree/main/module-2) course for example usage.
 
-Humans use memories to remember [facts](https://en.wikipedia.org/wiki/Semantic_memory), [experiences](https://en.wikipedia.org/wiki/Episodic_memory), and [rules](https://en.wikipedia.org/wiki/Procedural_memory). AI agents can use memory in the same ways. For example, AI agents can use memory to remember specific facts about a user to accomplish a task. We expand on several types of memories in the [section below](#memory-types).
+## Summarizing Past Conversations
 
-**When do you want to update memories?**
+The problem with trimming or removing messages, as shown above, is that we may loose information from culling of the message queue. Because of this, some applications benefit from a more sophisticated approach of summarizing the message history using a chat model. 
 
-Memory can be updated as part of an agent's application logic (e.g. "on the hot path"). In this case, the agent typically decides to remember facts before responding to a user. Alternatively, memory can be updated as a background task (logic that runs in the background / asynchronously and generates memories). We explain the tradeoffs between these approaches in the [section below](#writing-memories).
+Simple prompting and orchestration logic can be used to achieve this. As an example, in LangGraph we can extend the [MessagesState](https://langchain-ai.github.io/langgraph/concepts/low_level/#working-with-messages-in-graph-state) to include a `summary` key. 
 
-## Memory types
+```python
+from langgraph.graph import MessagesState
+class State(MessagesState):
+    summary: str
+```
 
-Different applications require various types of memory. Although the analogy isn't perfect, examining [human memory types](https://www.psychologytoday.com/us/basics/memory/types-of-memory?ref=blog.langchain.dev) can be insightful. Some research (e.g., the [CoALA paper](https://arxiv.org/pdf/2309.02427)) have even mapped these human memory types to those used in AI agents.
+Then, we can generate a summary of the chat history, using any existing summary as context for the next summary. This `summarize_conversation` node can be called after some number of messages have accumulated in the `messages` state key.
 
-| Memory Type | What is Stored | Human Example | Agent Example |
-|-------------|----------------|---------------|---------------|
-| Semantic | Facts | Things I learned in school | Facts about a user |
-| Episodic | Experiences | Things I did | Past agent actions |
-| Procedural | Instructions | Instincts or motor skills | Agent system prompt |
+```python   
+def summarize_conversation(state: State):
+    
+    # First, we get any existing summary
+    summary = state.get("summary", "")
 
-### Semantic Memory
+    # Create our summarization prompt 
+    if summary:
+        
+        # A summary already exists
+        summary_message = (
+            f"This is summary of the conversation to date: {summary}\n\n"
+            "Extend the summary by taking into account the new messages above:"
+        )
+        
+    else:
+        summary_message = "Create a summary of the conversation above:"
 
-[Semantic memory](https://en.wikipedia.org/wiki/Semantic_memory), both in humans and AI agents, involves the retention of specific facts and concepts. In humans, it can include information learned in school and the understanding of concepts and their relationships. For AI agents, semantic memory is often used to personalize applications by remembering facts or concepts from past interactions. 
+    # Add prompt to our history
+    messages = state["messages"] + [HumanMessage(content=summary_message)]
+    response = model.invoke(messages)
+    
+    # Delete all but the 2 most recent messages
+    delete_messages = [RemoveMessage(id=m.id) for m in state["messages"][:-2]]
+    return {"summary": response.content, "messages": delete_messages}
+```
 
-#### Profile
+See this how-to [here](https://langchain-ai.github.io/langgraph/how-tos/memory/add-summary-conversation-history/) and module 2 from our [LangChain Academy](https://github.com/langchain-ai/langchain-academy/tree/main/module-2) course for example usage.
 
-Semantic memories can be managed in different ways. For example, memories can be a single, continuously updated "profile" of well-scoped and specific information about a user, organization, or other entity (including the agent itself). A profile is generally just a JSON document with various key-value pairs you've selected to represent your domain. 
+## Few Shot Examples
 
-When remembering a profile, you will want to make sure that you are **updating** the profile each time. As a result, you will want to pass in the previous profile and [ask the model to generate a new profile](https://github.com/langchain-ai/memory-template) (or some [JSON patch](https://github.com/hinthornw/trustcall) to apply to the old profile). This can be become error-prone as the profile gets larger, and may benefit from splitting a profile into multiple documents or **strict** decoding when generating documents to ensure the memory schemas remains valid.
+Few-shot learning is a powerful technique where LLMs can be ["programmed"](https://x.com/karpathy/status/1627366413840322562) inside the prompt with input-output examples to perform diverse tasks. While various [best-practices](https://python.langchain.com/docs/concepts/#1-generating-examples) can be used to generate few-shot examples, often the challenge lies in selecting the most relevant examples based on user input. 
 
-![](img/memory/update-profile.png)
+LangChain [`ExampleSelectors`](https://python.langchain.com/docs/how_to/#example-selectors) can be used to customize few-shot example selection from a collection of examples using criteria such as length, semantic similarity, semantic ngram overlap, or maximal marginal relevance.
 
-#### Collection
-
-Alternatively, memories can be a collection of documents that are continuously updated and extended over time. Each individual memory can be more narrowly scoped and easier to generate, which means that you're less likely to **lose** information over time. It's easier for an LLM to generate _new_ objects for new information than reconcile new information with an existing profile. As a result, a document collection tends to lead to [higher recall downstream](https://en.wikipedia.org/wiki/Precision_and_recall).
-
-However, this shifts some complexity memory updating. The model must now _delete_ or _update_ existing items in the list, which can be tricky. In addition, some models may default to over-inserting and others may default to over-updating. See the [Trustcall](https://github.com/hinthornw/trustcall) package for one way to manage this and consider evaluation (e.g., with a tool like [LangSmith](https://docs.smith.langchain.com/tutorials/Developers/evaluation)) to help you tune the behavior.
-
-Working with document collections also shifts complexity to memory **search** over the list. The `Store` currently supports [filtering by metadata](https://langchain-ai.github.io/langgraph/reference/store/#storage) and will soon add [semantic search shortly](https://python.langchain.com/docs/concepts/vectorstores/), but selecting the most relevant documents can be tricky as the list grows.
-
-Finally, using a collection of memories can make it challenging to provide comprehensive context to the model. While individual memories may follow a specific schema, this structure might not capture the full context or relationships between memories. As a result, when using these memories to generate responses, the model may lack important contextual information that would be more readily available in a unified profile approach.
-
-![](img/memory/update-list.png)
-
-Regardless of memory management approach, the central point is that the agent will use the semantic memories to [ground its responses](https://python.langchain.com/docs/concepts/rag/), which often leads to more personalized and relevant interactions.
-
-### Episodic Memory
-
-[Episodic memory](https://en.wikipedia.org/wiki/Episodic_memory), in both humans and AI agents, involves recalling past events or actions. The [CoALA paper](https://arxiv.org/pdf/2309.02427) frames this well: facts can be written to semantic memory, whereas *experiences* can be written to episodic memory. For AI agents, episodic memory is often used to help an agent remember how to accomplish a task. 
-
-In practice, episodic memories are often implemented through [few-shot example prompting](https://python.langchain.com/docs/concepts/few_shot_prompting/), where agents learn from past sequences to perform tasks correctly. Sometimes it's easier to "show" than "tell" and LLMs learn well from examples. Few-shot learning lets you ["program"](https://x.com/karpathy/status/1627366413840322562) your LLM by updating the prompt with input-output examples to illustrate the intended behavior. While various [best-practices](https://python.langchain.com/docs/concepts/#1-generating-examples) can be used to generate few-shot examples, often the challenge lies in selecting the most relevant examples based on user input.
-
-Note that the memory [store](persistence.md#memory-store) is just one way to store data as few-shot examples. If you want to have more developer involvement, or tie few-shots more closely to your evaluation harness, you can also use a [LangSmith Dataset](https://docs.smith.langchain.com/evaluation/how_to_guides/datasets/index_datasets_for_dynamic_few_shot_example_selection) to store your data. Then dynamic few-shot example selectors can be used out-of-the box to achieve this same goal. LangSmith will index the dataset for you and enable retrieval of few shot examples that are most relevant to the user input based upon keyword similarity ([using a BM25-like algorithm](https://docs.smith.langchain.com/how_to_guides/datasets/index_datasets_for_dynamic_few_shot_example_selection) for keyword based similarity). 
+If few-shot examples are stored in a [LangSmith Dataset](https://docs.smith.langchain.com/how_to_guides/datasets), then dynamic few-shot example selectors can be used out-of-the box to achieve this same goal. LangSmith will index the dataset for you and enable retrieval of few shot examples that are most relevant to the user input based upon keyword similarity ([using a BM25-like algorithm](https://docs.smith.langchain.com/how_to_guides/datasets/index_datasets_for_dynamic_few_shot_example_selection) for keyword based similarity). 
 
 See this how-to [video](https://www.youtube.com/watch?v=37VaU7e7t5o) for example usage of dynamic few-shot example selection in LangSmith. Also, see this [blog post](https://blog.langchain.dev/few-shot-prompting-to-improve-tool-calling-performance/) showcasing few-shot prompting to improve tool calling performance and this [blog post](https://blog.langchain.dev/aligning-llm-as-a-judge-with-human-preferences/) using few-shot example to align an LLMs to human preferences.
 
-### Procedural Memory
+## Maintaining Data Across Chat Sessions
 
-[Procedural memory](https://en.wikipedia.org/wiki/Procedural_memory), in both humans and AI agents, involves remembering the rules used to perform tasks. In humans, procedural memory is like the internalized knowledge of how to perform tasks, such as riding a bike via basic motor skills and balance. Episodic memory, on the other hand, involves recalling specific experiences, such as the first time you successfully rode a bike without training wheels or a memorable bike ride through a scenic route. For AI agents, procedural memory is a combination of model weights, agent code, and agent's prompt that collectively determine the agent's functionality. 
-
-In practice, it is fairly uncommon for agents to modify their model weights or rewrite their code. However, it is more common for agents to [modify their own prompts](https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/prompt-generator). 
-
-One effective approach to refining an agent's instructions is through ["Reflection"](https://blog.langchain.dev/reflection-agents/) or meta-prompting. This involves prompting the agent with its current instructions (e.g., the system prompt) along with recent conversations or explicit user feedback. The agent then refines its own instructions based on this input. This method is particularly useful for tasks where instructions are challenging to specify upfront, as it allows the agent to learn and adapt from its interactions.
-
-For example, we built a [Tweet generator](https://www.youtube.com/watch?v=Vn8A3BxfplE) using external feedback and prompt re-writing to produce high-quality paper summaries for Twitter. In this case, the specific summarization prompt was difficult to specify *a priori*, but it was fairly easy for a user to critique the generated Tweets and provide feedback on how to improve the summarization process. 
-
-The below pseudo-code shows how you might implement this with the LangGraph memory [store](persistence.md#memory-store), using the store to save a prompt, the `update_instructions` node to get the current prompt (as well as feedback from the conversation with the user captured in `state["messages"]`), update the prompt, and save the new prompt back to the store. Then, the `call_model` get the updated prompt from the store and uses it to generate a response.
+LangGraph's [persistence layer](https://langchain-ai.github.io/langgraph/concepts/persistence/#persistence) has checkpointers that utilize various storage systems, including an in-memory key-value store or different databases. These checkpoints capture the graph state at each execution step and accumulate in a thread, which can be accessed at a later time using a thread ID to resume a previous graph execution. We add persistence to our graph by passing a checkpointer to the `compile` method, as shown here.
 
 ```python
-# Node that *uses* the instructions
-def call_model(state: State, store: BaseStore):
-    namespace = ("agent_instructions", )
-    instructions = store.get(namespace, key="agent_a")[0]
-    # Application logic
-    prompt = prompt_template.format(instructions=instructions.value["instructions"])
-    ...
+# Compile the graph with a checkpointer
+checkpointer = InMemorySaver()
+graph = workflow.compile(checkpointer=checkpointer)
 
-# Node that updates instructions
-def update_instructions(state: State, store: BaseStore):
-    namespace = ("instructions",)
-    current_instructions = store.search(namespace)[0]
-    # Memory logic
-    prompt = prompt_template.format(instructions=instructions.value["instructions"], conversation=state["messages"])
-    output = llm.invoke(prompt)
-    new_instructions = output['new_instructions']
-    store.put(("agent_instructions",), "agent_a", {"instructions": new_instructions})
-    ...
+# Invoke the graph with a thread ID
+config = {"configurable": {"thread_id": "1"}}
+graph.invoke(input_state, config)
+
+# get the latest state snapshot at a later time
+config = {"configurable": {"thread_id": "1"}}
+graph.get_state(config)
 ```
 
-![](img/memory/update-instructions.png)
+Persistence is critical sustaining a long-running chat sessions. For example, a chat between a user and an AI assistant may have interruptions. Persistence ensures that a user can continue that particular chat session at any later point in time. However, what happens if a user initiates a new chat session with an assistant? This spawns a new thread, and the information from the previous session (thread) is not retained. This motivates the need for a memory service that can maintain data across chat sessions (threads). 
 
-## Writing memories
+## Meta-prompting
 
-While [humans often form long-term memories during sleep](https://medicine.yale.edu/news-article/sleeps-crucial-role-in-preserving-memory/), AI agents need a different approach. When and how should agents create new memories? There are at least two primary methods for agents to write memories: "on the hot path" and "in the background".
+Meta-prompting uses an LLM to generate or refine its own prompts or instructions. This approach allows the system to dynamically update and improve its own behavior, potentially leading to better performance on various tasks. This is particularly useful for tasks where the instructions are challenging to specify a priori. 
 
-![](img/memory/hot_path_vs_background.png)
+Meta-prompting can use past information to update the prompt. As an example, this [Tweet generator](https://www.youtube.com/watch?v=Vn8A3BxfplE) uses meta-prompting to iteratively improve the summarization prompt used to generate high quality paper summaries for Twitter. In this case, we used a LangSmith dataset to house several papers that we wanted to summarize, generated summaries using a naive summarization prompt, manually reviewed the summaries, captured feedback from human review using the LangSmith Annotation Queue, and passed this feedback to a chat model to re-generate the summarization prompt. The process was repeated in a loop until the summaries met our criteria in human review.
 
-### Writing memories in the hot path
+## Retrieving relevant information from long-term storage
 
-Creating memories during runtime offers both advantages and challenges. On the positive side, this approach allows for real-time updates, making new memories immediately available for use in subsequent interactions. It also enables transparency, as users can be notified when memories are created and stored.
+A central challenge that spans many different memory use-case can be summarized simply: how can we retrieve *relevant information* from a long-term storage system and pass it to a chat model? As an example, assume we have a system that stores a large number of specific details about a user, but the user asks a specific question related to restaurant recommendations. It would be costly to trivially extract *all* personal user information and pass it to a chat model. Instead, we want to extract only the information that is most relevant to the user's current chat interaction (e,g,. food preferences, location, etc.) and pass it to the chat model. 
 
-However, this method also presents challenges. It may increase complexity if the agent requires a new tool to decide what to commit to memory. In addition, the process of reasoning about what to save to memory can impact agent latency. Finally, the agent must multitask between memory creation and its other responsibilities, potentially affecting the quantity and quality of memories created.
-
-As an example, ChatGPT uses a [save_memories](https://openai.com/index/memory-and-new-controls-for-chatgpt/) tool to upsert memories as content strings, deciding whether and how to use this tool with each user message. See our [memory-agent](https://github.com/langchain-ai/memory-agent) template as an reference implementation.
-
-### Writing memories in the background
-
-Creating memories as a separate background task offers several advantages. It eliminates latency in the primary application, separates application logic from memory management, and allows for more focused task completion by the agent. This approach also provides flexibility in timing memory creation to avoid redundant work.
-
-However, this method has its own challenges. Determining the frequency of memory writing becomes crucial, as infrequent updates may leave other threads without new context. Deciding when to trigger memory formation is also important. Common strategies include scheduling after a set time period (with rescheduling if new events occur), using a cron schedule, or allowing manual triggers by users or the application logic.
-
-See our [memory-service](https://github.com/langchain-ai/memory-template) template as an reference implementation.
+There is a large body of work on retrieval that aims to address this challenge. See our tutorials focused on [RAG, or Retrieval Augmented Generation](https://langchain-ai.github.io/langgraph/tutorials/rag/langgraph_adaptive_rag/), our conceptual docs on [retrieval](https://python.langchain.com/docs/concepts/#retrieval), and our [open source repository](https://github.com/langchain-ai/rag-from-scratch) along with [videos](https://www.youtube.com/playlist?list=PLfaIDFEXuae2LXbO1_PKyVJiQ23ZztA0x) on this topic.

docs/docs/concepts/multi_agent.md

@@ -1,281 +1,138 @@
 # Multi-agent Systems
 
-An [agent](./agentic_concepts.md#agent-architectures) is _a system that uses an LLM to decide the control flow of an application_. As you develop these systems, they might grow more complex over time, making them harder to manage and scale. For example, you might run into the following problems:
+A multi-agent system is a system with multiple independent actors powered by LLMs that are connected in a specific way. These actors can be as simple as a prompt and an LLM call, or as complex as a [ReAct](./agentic_concepts.md#react-implementation) agent.
 
-- agent has too many tools at its disposal and makes poor decisions about which tool to call next
-- context grows too complex for a single agent to keep track of
-- there is a need for multiple specialization areas in the system (e.g. planner, researcher, math expert, etc.)
+The primary benefits of this architecture are:
 
-To tackle these, you might consider breaking your application into multiple smaller, independent agents and composing them into a **multi-agent system**. These independent agents can be as simple as a prompt and an LLM call, or as complex as a [ReAct](./agentic_concepts.md#react-implementation) agent (and more!).
+* **Modularity**: Separate agents facilitate easier development, testing, and maintenance of agentic systems.
+* **Specialization**: You can create expert agents focused on specific domains, and compose them into more complex applications
+* **Control**: You can explicitly control how agents communicate (as opposed to relying on function calling)
 
-The primary benefits of using multi-agent systems are:
+## Multi-agent systems in LangGraph
 
-- **Modularity**: Separate agents make it easier to develop, test, and maintain agentic systems.
-- **Specialization**: You can create expert agents focused on specific domains, which helps with the overall system performance.
-- **Control**: You can explicitly control how agents communicate (as opposed to relying on function calling).
+### Agents as nodes
 
-## Multi-agent architectures
+Agents can be defined as nodes in LangGraph. As any other node in the LangGraph, these agent nodes receive the graph state as an input and return an update to the state as their output.
 
-![](./img/multi_agent/architectures.png)
+* Simple **LLM nodes**: single LLMs with custom prompts
+* **Subgraph nodes**: complex graphs called inside the orchestrator graph node
 
-There are several ways to connect agents in a multi-agent system:
+![](./img/multi_agent/subgraph.png)
 
-- **Network**: each agent can communicate with [every other agent](https://langchain-ai.github.io/langgraph/tutorials/multi_agent/multi-agent-collaboration/). Any agent can decide which other agent to call next.
-- **Supervisor**: each agent communicates with a single [supervisor](https://langchain-ai.github.io/langgraph/tutorials/multi_agent/agent_supervisor/) agent. Supervisor agent makes decisions on which agent should be called next.
-- **Supervisor (tool-calling)**: this is a special case of supervisor architecture. Individual agents can be represented as tools. In this case, a supervisor agent uses a tool-calling LLM to decide which of the agent tools to call, as well as the arguments to pass to those agents.
-- **Hierarchical**: you can define a multi-agent system with [a supervisor of supervisors](https://langchain-ai.github.io/langgraph/tutorials/multi_agent/hierarchical_agent_teams/). This is a generalization of the supervisor architecture and allows for more complex control flows.
-- **Custom multi-agent workflow**: each agent communicates with only a subset of agents. Parts of the flow are deterministic, and only some agents can decide which other agents to call next.
+### Agents as tools
 
-### Network
+Agents can also be defined as tools. In this case, the orchestrator agent (e.g. ReAct agent) would use a tool-calling LLM to decide which of the agent tools to call, as well as the arguments to pass to those agents.
 
-In this architecture, agents are defined as graph nodes. Each agent can communicate with every other agent (many-to-many connections) and can decide which agent to call next. While very flexible, this architecture doesn't scale well as the number of agents grows:
+You could also take a "mega-graph" approach – incorporating subordinate agents' nodes directly into the parent, orchestrator graph. However, this is not recommended for complex subordinate agents, as it would make the overall system harder to scale, maintain and debug – you should use subgraphs or tools in those cases.
 
-- hard to enforce which agent should be called next
-- hard to determine how much [information](#shared-message-list) should be passed between the agents
+## Communication in multi-agent systems
 
-We recommend avoiding this architecture in production and using one of the below architectures instead.
+A big question in multi-agent systems is how the agents communicate amongst themselves and with the orchestrator agent. This involves both the schema of how they communicate, as well as the sequence in which they communicate. LangGraph is perfect for orchestrating these types of systems and allows you to define both.
 
-### Supervisor
+### Schema
 
-In this architecture, we define agents as nodes and add a supervisor node (LLM) that decides which agent nodes should be called next. We use [conditional edges](./low_level.md#conditional-edges) to route execution to the appropriate agent node based on supervisor's decision. This architecture also lends itself well to running multiple agents in parallel or using [map-reduce](../how-tos/map-reduce.ipynb) pattern.
+LangGraph provides a lot of flexibility for how to communicate within multi-agent architectures.
+
+* A node in LangGraph can have a [private input state schema](https://langchain-ai.github.io/langgraph/how-tos/pass_private_state/) that is distinct from the graph state schema. This allows passing additional information during the graph execution that is only needed for executing a particular node.
+* Subgraph node agents can have independent [input / output state schemas](https://langchain-ai.github.io/langgraph/how-tos/input_output_schema/). In this case it’s important to [add input / output transformations](https://langchain-ai.github.io/langgraph/how-tos/subgraph-transform-state/) so that the parent graph knows how to communicate with the subgraphs.
+* For tool-based subordinate agents, the orchestrator determines the inputs based on the tool schema. Additionally, LangGraph allows passing state to individual tools at runtime, so subordinate agents can access parent state, if needed.
+
+### Sequence
+
+LangGraph provides multiple methods to control agent communication sequence:
+
+* **Explicit control flow (graph edges)**: LangGraph allows you to define the control flow of your application (i.e. the sequence of how agents communicate) explicitly, via [graph edges](./low_level.md#edges).
 
 ```python
-from typing import Literal
 from langchain_openai import ChatOpenAI
-from langgraph.graph import StateGraph, MessagesState, START
+from langchain_core.messages import SystemMessage
+from langgraph.graph import StateGraph, MessagesState, START, END
 
-model = ChatOpenAI()
+model = ChatOpenAI(model="gpt-4o-mini")
 
-class AgentState(MessagesState):
-    next: Literal["agent_1", "agent_2", "__end__"]
-
-def supervisor(state: AgentState):
-    # you can pass relevant parts of the state to the LLM (e.g., state["messages"])
-    # to determine which agent to call next. a common pattern is to call the model
-    # with a structured output (e.g. force it to return an output with a "next_agent" field)
-    response = model.invoke(...)
-    # the "next" key will be used by the conditional edges to route execution
-    # to the appropriate agent
-    return {"next": response["next_agent"]}
-
-def agent_1(state: AgentState):
-    # you can pass relevant parts of the state to the LLM (e.g., state["messages"])
-    # and add any additional logic (different models, custom prompts, structured output, etc.)
-    response = model.invoke(...)
+def research_agent(state: MessagesState):
+    """Call research agent"""
+    messages = [SystemMessage(content="You are a research assistant. Given a topic, provide key facts and information.")] + state["messages"]
+    response = model.invoke(messages)
     return {"messages": [response]}
 
-def agent_2(state: AgentState):
-    response = model.invoke(...)
+def summarize_agent(state: MessagesState):
+    """Call summarization agent"""
+    messages = [SystemMessage(content="You are a summarization expert. Condense the given information into a brief summary.")] + state["messages"]
+    response = model.invoke(messages)
     return {"messages": [response]}
 
-builder = StateGraph(AgentState)
-builder.add_node(supervisor)
-builder.add_node(agent_1)
-builder.add_node(agent_2)
+graph = StateGraph(MessagesState)
+graph.add_node("research", research_agent)
+graph.add_node("summarize", summarize_agent)
 
-builder.add_edge(START, "supervisor")
-# route to one of the agents or exit based on the supervisor's decisiion
-# if the supervisor returns "__end__", the graph will finish execution
-builder.add_conditional_edges("supervisor", lambda state: state["next"])
-builder.add_edge("agent_1", "supervisor")
-builder.add_edge("agent_2", "supervisor")
-
-supervisor = builder.compile()
+# define the flow explicitly
+graph.add_edge(START, "research")
+graph.add_edge("research", "summarize")
+graph.add_edge("summarize", END)
 ```
 
-Check out this [tutorial](https://langchain-ai.github.io/langgraph/tutorials/multi_agent/agent_supervisor/) for an example of supervisor multi-agent architecture.
+* **Dynamic control flow (conditional edges)**: LangGraph also allows you to define [conditional edges](./low_level.md#conditional-edges), where the control flow is dependent on satisfying a given condition. In such cases, you can use an LLM to decide which subordinate agent to call next.
 
-### Supervisor (tool-calling)
 
-In this variant of the [supervisor](#supervisor) architecture, we define individual agents as **tools** and use a tool-calling LLM in the supervisor node. This can be implemented as a [ReAct](./agentic_concepts.md#react-implementation)-style agent with two nodes — an LLM node (supervisor) and a tool-calling node that executes tools (agents in this case).
+* **Implicit control flow (tool calling)**: if the orchestrator agent treats subordinate agents as tools, the tool-calling LLM powering the orchestrator will make decisions about the order in which the tools (agents) are being called.
 
 ```python
 from typing import Annotated
+from langchain_core.messages import SystemMessage, ToolMessage
 from langchain_openai import ChatOpenAI
-from langgraph.prebuilt import InjectedState, create_react_agent
+from langgraph.prebuilt import ToolNode, InjectedState, create_react_agent
 
-model = ChatOpenAI()
+model = ChatOpenAI(model="gpt-4o-mini")
 
-# this is the agent function that will be called as tool
-# notice that you can pass the state to the tool via InjectedState annotation
-def agent_1(state: Annotated[dict, InjectedState]):
-    # you can pass relevant parts of the state to the LLM (e.g., state["messages"])
-    # and add any additional logic (different models, custom prompts, structured output, etc.)
-    response = model.invoke(...)
-    # return the LLM response as a string (expected tool response format)
-    # this will be automatically turned to ToolMessage
-    # by the prebuilt create_react_agent (supervisor)
-    return response.content
+def research_agent(state: Annotated[dict, InjectedState]):
+    """Call research agent"""
+    messages = [SystemMessage(content="You are a research assistant. Given a topic, provide key facts and information.")] + state["messages"][:-1]
+    response = model.invoke(messages)
+    tool_call = state["messages"][-1].tool_calls[0]
+    return {"messages": [ToolMessage(response.content, tool_call_id=tool_call["id"])]}
 
-def agent_2(state: Annotated[dict, InjectedState]):
-    response = model.invoke(...)
-    return response.content
+def summarize_agent(state: Annotated[dict, InjectedState]):
+    """Call summarization agent"""
+    messages = [SystemMessage(content="You are a summarization expert. Condense the given information into a brief summary.")] + state["messages"][:-1]
+    response = model.invoke(messages)
+    tool_call = state["messages"][-1].tool_calls[0]
+    return {"messages": [ToolMessage(response.content, tool_call_id=tool_call["id"])]}
 
-tools = [agent_1, agent_2]
-# the simplest way to build a supervisor w/ tool-calling is to use prebuilt ReAct agent graph
-# that consists of a tool-calling LLM node (i.e. supervisor) and a tool-executing node
-supervisor = create_react_agent(model, tools)
+tool_node = ToolNode([research_agent, summarize_agent])
+graph = create_react_agent(model, [research_agent, summarize_agent], state_modifier="First research and then summarize information on a given topic.")
 ```
 
-### Hierarchical
+## Example architectures
 
-As you add more agents to your system, it might become too hard for the supervisor to manage all of them. The supervisor might start making poor decisions about which agent to call next, the context might become too complex for a single supervisor to keep track of. In other words, you end up with the same problems that motivated the multi-agent architecture in the first place.
+Below are several examples of complex multi-agent architectures that can be implemented in LangGraph.
 
-To address this, you can design your system _hierarchically_. For example, you can create separate, specialized teams of agents managed by individual supervisors, and a top-level supervisor to manage the teams.
+### Multi-Agent Collaboration
 
-```python
-from typing import Literal
-from langchain_openai import ChatOpenAI
-from langgraph.graph import StateGraph, MessagesState, START
+In this example, different agents collaborate on a **shared** scratchpad of messages (i.e. shared graph state). This means that all the work any of them do is visible to the other ones. The benefit is that the other agents can see all the individual steps done. The downside is that sometimes is it overly verbose and unnecessary to pass ALL this information along, and sometimes only the final answer from an agent is needed. We call this **collaboration** because of the shared nature the scratchpad.
 
-model = ChatOpenAI()
+In this case, the independent agents are actually just a single LLM call with a custom system message.
 
-# define team 1 (same as the single supervisor example above)
-class Team1State(MessagesState):
-    next: Literal["team_1_agent_1", "team_1_agent_2", "__end__"]
+Here is a visualization of how these agents are connected:
 
-def team_1_supervisor(state: Team1State):
-    response = model.invoke(...)
-    return {"next": response["next_agent"]}
+![](./img/multi_agent/collaboration.png)
 
-def team_1_agent_1(state: Team1State):
-    response = model.invoke(...)
-    return {"messages": [response]}
+See full code example in this [tutorial](https://langchain-ai.github.io/langgraph/tutorials/multi_agent/multi-agent-collaboration/).
 
-def team_1_agent_2(state: Team1State):
-    response = model.invoke(...)
-    return {"messages": [response]}
+### Agent Supervisor
 
-team_1_builder = StateGraph(Team1State)
-team_1_builder.add_node(team_1_supervisor)
-team_1_builder.add_node(team_1_agent_1)
-team_1_builder.add_node(team_1_agent_2)
-team_1_builder.add_edge(START, "team_1_supervisor")
-# route to one of the agents or exit based on the supervisor's decisiion
-# if the supervisor returns "__end__", the graph will finish execution
-team_1_builder.add_conditional_edges("team_1_supervisor", lambda state: state["next"])
-team_1_builder.add_edge("team_1_agent_1", "team_1_supervisor")
-team_1_builder.add_edge("team_1_agent_2", "team_1_supervisor")
+In this example, multiple agents are connected, but compared to above they do NOT share a shared scratchpad. Rather, they have their own independent scratchpads (i.e. their own state), and then their final responses are appended to a global scratchpad.
 
-team_1_graph = team_1_builder.compile()
+In this case, the independent agents are a LangGraph ReAct agent (graph). This means they have their own individual prompt, LLM, and tools. When called, it's not just a single LLM call, but rather an invocation of the graph powering the ReAct agent.
 
-# define team 2 (same as the single supervisor example above)
-class Team2State(MessagesState):
-    next: Literal["team_2_agent_1", "team_2_agent_2", "__end__"]
+![](./img/multi_agent/supervisor.png)
 
-def team_2_supervisor(state: Team2State):
-    ...
+See full code example in this [tutorial](https://langchain-ai.github.io/langgraph/tutorials/multi_agent/agent_supervisor/).
 
-def team_2_agent_1(state: Team2State):
-    ...
+### Hierarchical Agent Teams
 
-def team_2_agent_2(state: Team2State):
-    ...
+What if the job for a single worker in agent supervisor example becomes too complex? What if the number of workers becomes too large? For some applications, the system may be more effective if work is distributed hierarchically. You can do this by creating additional level of subgraphs and creating a top-level supervisor, along with mid-level supervisors:
 
-team_2_builder = StateGraph(Team2State)
-...
-team_2_graph = team_2_builder.compile()
+![](./img/multi_agent/hierarchical.png)
 
-
-# define top-level supervisor
-
-class TopLevelState(MessagesState):
-    next: Literal["team_1", "team_2", "__end__"]
-
-builder = StateGraph(TopLevelState)
-def top_level_supervisor(state: TopLevelState):
-    # you can pass relevant parts of the state to the LLM (e.g., state["messages"])
-    # to determine which team to call next. a common pattern is to call the model
-    # with a structured output (e.g. force it to return an output with a "next_team" field)
-    response = model.invoke(...)
-    # the "next" key will be used by the conditional edges to route execution
-    # to the appropriate team
-    return {"next": response["next_team"]}
-
-builder = StateGraph(TopLevelState)
-builder.add_node(top_level_supervisor)
-builder.add_node(team_1_graph)
-builder.add_node(team_2_graph)
-
-builder.add_edge(START, "top_level_supervisor")
-# route to one of the teams or exit based on the supervisor's decision
-# if the top-level supervisor returns "__end__", the graph will finish execution
-builder.add_conditional_edges("top_level_supervisor", lambda state: state["next"])
-builder.add_edge("team_1_graph", "top_level_supervisor")
-builder.add_edge("team_2_graph", "top_level_supervisor")
-
-graph = builder.compile()
-```
-
-### Custom multi-agent workflow
-
-In this architecture we add individual agents as graph nodes and define the order in which agents are called ahead of time, in a custom workflow. In LangGraph the workflow can be defined in two ways:
-
-- **Explicit control flow (normal edges)**: LangGraph allows you to explicitly define the control flow of your application (i.e. the sequence of how agents communicate) explicitly, via [normal graph edges](./low_level.md#normal-edges). This is the most deterministic variant of this architecture above — we always know which agent will be called next ahead of time.
-
-- **Dynamic control flow (conditional edges)**: in LangGraph you can allow LLMs to decide parts of your application control flow. This can be achieved by using [conditional edges](./low_level.md#conditional-edges). A special case of this is a [supervisor tool-calling](#supervisor-tool-calling) architecture. In that case, the tool-calling LLM powering the supervisor agent will make decisions about the order in which the tools (agents) are being called.
-
-```python
-from langchain_openai import ChatOpenAI
-from langgraph.graph import StateGraph, MessagesState, START
-
-model = ChatOpenAI()
-
-def agent_1(state: MessagesState):
-    response = model.invoke(...)
-    return {"messages": [response]}
-
-def agent_2(state: MessagesState):
-    response = model.invoke(...)
-    return {"messages": [response]}
-
-builder = StateGraph(MessagesState)
-builder.add_node(agent_1)
-builder.add_node(agent_2)
-# define the flow explicitly
-builder.add_edge(START, "agent_1")
-builder.add_edge("agent_1", "agent_2")
-```
-
-## Communication between agents
-
-The most important thing when building multi-agent systems is figuring out how the agents communicate. There are few different considerations:
-
-- Do agents communicate via [**via graph state or via tool calls**](#graph-state-vs-tool-calls)?
-- What if two agents have [**different state schemas**](#different-state-schemas)?
-- How to communicate over a [**shared message list**](#shared-message-list)?
-
-### Graph state vs tool calls
-
-What is the "payload" that is being passed around between agents? In most of the architectures discussed above the agents communicate via the [graph state](./low_level.md#state). In the case of the [supervisor with tool-calling](#supervisor-tool-calling), the payloads are tool call arguments.
-
-![](./img/multi_agent/request.png)
-
-#### Graph state
-
-To communicate via graph state, individual agents need to be defined as [graph nodes](./low_level.md#nodes). These can be added as functions or as entire [subgraphs](./low_level.md#subgraphs). At each step of the graph execution, agent node receives the current state of the graph, executes the agent code and then passes the updated state to the next nodes.
-
-Typically agent nodes share a single [state schema](./low_level.md#schema). However, you might want to design agent nodes with [different state schemas](#different-state-schemas).
-
-### Different state schemas
-
-An agent might need to have a different state schema from the rest of the agents. For example, a search agent might only need to keep track of queries and retrieved documents. There are two ways to achieve this in LangGraph:
-
-- Define [subgraph](./low_level.md#subgraphs) agents with a separate state schema. If there are no shared state keys (channels) between the subgraph and the parent graph, it’s important to [add input / output transformations](https://langchain-ai.github.io/langgraph/how-tos/subgraph-transform-state/) so that the parent graph knows how to communicate with the subgraphs.
-- Define agent node functions with a [private input state schema](https://langchain-ai.github.io/langgraph/how-tos/pass_private_state/) that is distinct from the overall graph state schema. This allows passing information that is only needed for executing that particular agent.
-
-### Shared message list
-
-The most common way for the agents to communicate is via a shared state channel, typically a list of messages. This assumes that there is always at least a single channel (key) in the state that is shared by the agents. When communicating via a shared message list there is an additional consideration: should the agents [share the full history](#share-full-history) of their thought process or only [the final result](#share-final-result)?
-
-![](./img/multi_agent/response.png)
-
-#### Share full history
-
-Agents can **share the full history** of their thought process (i.e. "scratchpad") with all other agents. This "scratchpad" would typically look like a [list of messages](./low_level.md#why-use-messages). The benefit of sharing full thought process is that it might help other agents make better decisions and improve reasoning ability for the system as a whole. The downside is that as the number of agents and their complexity grows, the "scratchpad" will grow quickly and might require additional strategies for [memory management](./memory.md/#managing-long-conversation-history).
-
-#### Share final result
-
-Agents can have their own private "scratchpad" and only **share the final result** with the rest of the agents. This approach might work better for systems with many agents or agents that are more complex. In this case, you would need to define agents with [different state schemas](#different-state-schemas)
-
-For agents called as tools, the supervisor determines the inputs based on the tool schema. Additionally, LangGraph allows [passing state](https://langchain-ai.github.io/langgraph/how-tos/pass-run-time-values-to-tools/#pass-graph-state-to-tools) to individual tools at runtime, so subordinate agents can access parent state, if needed.
+See full code example in this [tutorial](https://langchain-ai.github.io/langgraph/tutorials/multi_agent/hierarchical_agent_teams/).

docs/docs/concepts/persistence.md

@@ -26,7 +26,7 @@ Let's see what checkpoints are saved when a simple graph is invoked as follows:
 
 ```python
 from langgraph.graph import StateGraph, START, END
-from langgraph.checkpoint.memory import MemorySaver
+from langgraph.checkpoint.memory import InMemorySaver
 from typing import Annotated
 from typing_extensions import TypedDict
 from operator import add
@@ -49,7 +49,7 @@ workflow.add_edge(START, "node_a")
 workflow.add_edge("node_a", "node_b")
 workflow.add_edge("node_b", END)
 
-checkpointer = MemorySaver()
+checkpointer = InMemorySaver()
 graph = workflow.compile(checkpointer=checkpointer)
 
 config = {"configurable": {"thread_id": "1"}}
@@ -159,7 +159,7 @@ You must pass these when invoking the graph as part of the `configurable` portio
 # {"configurable": {"thread_id": "1", "checkpoint_id": "0c62ca34-ac19-445d-bbb0-5b4984975b2a"}}  # also valid config
 
 config = {"configurable": {"thread_id": "1"}}
-graph.invoke(None, config=config)
+graph.invoke(inputs, config=config)
 ```
 
 Importantly, LangGraph knows whether a particular checkpoint has been executed previously. If it has, LangGraph simply *re-plays* that particular step in the graph and does not re-execute the step. See this [how to guide on time-travel to learn more about replaying](../how-tos/human_in_the_loop/time-travel.ipynb).
@@ -216,153 +216,11 @@ The final thing you can optionally specify when calling `update_state` is `as_no
 
 ![Update](img/persistence/checkpoints_full_story.jpg)
 
-## Memory Store
-
-![Update](img/persistence/shared_state.png)
-
-A [state schema](low_level.md#schema) specifies a set of keys that are populated as a graph is executed. As discussed above, state can be written by a checkpointer to a thread at each graph step, enabling state persistence.
-
-But, what if we want to retrain some information *across threads*? Consider the case of a chatbot where we want to retain specific information about the user across *all* chat conversations (e.g., threads) with that user!
-
-With checkpointers alone, we cannot share information across threads. This motivates the need for the `Store` interface. As an illustration, we can define an `InMemoryStore` to store information about a user across threads. We simply compile our graph with a checkpointer, as before, and will our new `in_memory_store`.
-First, let's showcase this in isolation without using LangGraph.
-
-```python
-from langgraph.store.memory import InMemoryStore
-in_memory_store = InMemoryStore()
-```
-
-Memories are namespaced by a `tuple`, which in this specific example will be `(<user_id>, "memories")`. The namespace can be any length and represent anything, does not have be user specific.
-
-```python 
-user_id = "1"
-namespace_for_memory = (user_id, "memories")
-```
-
-We use the `store.put` to save memories to our namespace in the store. When we do this, we specify the namespace, as defined above, and a key-value pair for the memory: the key is simply a unique identifier for the memory (`memory_id`) and the value (a dictionary) is the memory itself.
-
-```python
-memory_id = str(uuid.uuid4())
-memory = {"food_preference" : "I like pizza"}
-in_memory_store.put(namespace_for_memory, memory_id, memory)
-```
-
-We can read out memories in our namespace using `store.search`, which will return all memories for a given user as a list. The most recent memory is the last in the list.
-
-```python
-memories = in_memory_store.search(namespace_for_memory)
-memories[-1].dict()
-{'value': {'food_preference': 'I like pizza'},
- 'key': '07e0caf4-1631-47b7-b15f-65515d4c1843',
- 'namespace': ['1', 'memories'],
- 'created_at': '2024-10-02T17:22:31.590602+00:00',
- 'updated_at': '2024-10-02T17:22:31.590605+00:00'}
-```
-
-Each memory type is a Python class with certain attributes. We can access it as a dictionary by converting via `.dict` as above.
-The attributes it has are:
-
-- `value`: The value (itself a dictionary) of this memory
-- `key`: The UUID for this memory in this namespace
-- `namespace`: A list of strings, the namespace of this memory type
-- `created_at`: Timestamp for when this memory was created
-- `updated_at`: Timestamp for when this memory was updated
-
-With this all in place, we use the `in_memory_store` in LangGraph. The `in_memory_store` works hand-in-hand with the checkpointer: the checkpointer saves state to threads, as discussed above, and the the `in_memory_store` allows us to store arbitrary information for access *across* threads. We compile the graph with both the checkpointer and the `in_memory_store` as follows. 
-
-```python
-from langgraph.checkpoint.memory import MemorySaver
-
-# We need this because we want to enable threads (conversations)
-checkpointer = MemorySaver()
-
-# ... Define the graph ...
-
-# Compile the graph with the checkpointer and store
-graph = graph.compile(checkpointer=checkpointer, store=in_memory_store)
-```
-
-We invoke the graph with a `thread_id`, as before, and also with a `user_id`, which we'll use to namespace our memories to this particular user as we showed above.
-
-```python
-# Invoke the graph
-user_id = "1"
-config = {"configurable": {"thread_id": "1", "user_id": user_id}}
-
-# First let's just say hi to the AI
-for update in graph.stream(
-    {"messages": [{"role": "user", "content": "hi"}]}, config, stream_mode="updates"
-):
-    print(update)
-```
-
-We can access the `in_memory_store` and the `user_id` in *any node* by passing `store: BaseStore` and `config: RunnableConfig` as node arguments. Just as we saw above, simply use the `put` method to save memories to the store.
-
-```python
-def update_memory(state: MessagesState, config: RunnableConfig, *, store: BaseStore):
-    
-    # Get the user id from the config
-    user_id = config["configurable"]["user_id"]
-    
-    # Namespace the memory
-    namespace = (user_id, "memories")
-    
-    # ... Analyze conversation and create a new memory
-    
-    # Create a new memory ID
-    memory_id = str(uuid.uuid4())
-
-    # We create a new memory
-    store.put(namespace, memory_id, {"memory": memory})
-
-```
-
-As we showed above, we can also access the store in any node and use `search` to get memories. Recall the the memories are returned as a list of objects that can be converted to a dictionary.
-
-```python
-memories[-1].dict()
-{'value': {'food_preference': 'I like pizza'},
- 'key': '07e0caf4-1631-47b7-b15f-65515d4c1843',
- 'namespace': ['1', 'memories'],
- 'created_at': '2024-10-02T17:22:31.590602+00:00',
- 'updated_at': '2024-10-02T17:22:31.590605+00:00'}
-```
-
-We can access the memories and use them in our model call.
-
-```python
-def call_model(state: MessagesState, config: RunnableConfig, *, store: BaseStore):
-    
-    # Get the user id from the config
-    user_id = config["configurable"]["user_id"]
-    
-    # Get the memories for the user from the store
-    memories = store.search(("memories", user_id))
-    info = "\n".join([d.value["memory"] for d in memories])
-    
-    # ... Use memories in the model call
-```
-
-If we create a new thread, we can still access the same memories so long as the `user_id` is the same. 
-
-```python
-# Invoke the graph
-config = {"configurable": {"thread_id": "2", "user_id": "1"}}
-
-# Let's say hi again
-for update in graph.stream(
-    {"messages": [{"role": "user", "content": "hi, tell me about my memories"}]}, config, stream_mode="updates"
-):
-    print(update)
-```
-
-When we use the LangGraph API, either locally (e.g., in LangGraph Studio) or with LangGraph Cloud, the memory store is available to use by default and does not need to be specified during graph compilation.
-
 ## Checkpointer libraries
 
 Under the hood, checkpointing is powered by checkpointer objects that conform to [BaseCheckpointSaver][langgraph.checkpoint.base.BaseCheckpointSaver] interface. LangGraph provides several checkpointer implementations, all implemented via standalone, installable libraries:
 
-* `langgraph-checkpoint`: The base interface for checkpointer savers ([BaseCheckpointSaver][langgraph.checkpoint.base.BaseCheckpointSaver]) and serialization/deserialization interface ([SerializerProtocol][langgraph.checkpoint.serde.base.SerializerProtocol]). Includes in-memory checkpointer implementation ([MemorySaver][langgraph.checkpoint.memory.MemorySaver]) for experimentation. LangGraph comes with `langgraph-checkpoint` included.
+* `langgraph-checkpoint`: The base interface for checkpointer savers ([BaseCheckpointSaver][langgraph.checkpoint.base.BaseCheckpointSaver]) and serialization/deserialization interface ([SerializerProtocol][langgraph.checkpoint.serde.base.SerializerProtocol]). Includes in-memory checkpointer implementation ([InMemorySaver][langgraph.checkpoint.memory.InMemorySaver]) for experimentation. LangGraph comes with `langgraph-checkpoint` included.
 * `langgraph-checkpoint-sqlite`: An implementation of LangGraph checkpointer that uses SQLite database ([SqliteSaver][langgraph.checkpoint.sqlite.SqliteSaver] / [AsyncSqliteSaver][langgraph.checkpoint.sqlite.aio.AsyncSqliteSaver]). Ideal for experimentation and local workflows. Needs to be installed separately.
 * `langgraph-checkpoint-postgres`: An advanced checkpointer that uses Postgres database ([PostgresSaver][langgraph.checkpoint.postgres.PostgresSaver] / [AsyncPostgresSaver][langgraph.checkpoint.postgres.aio.AsyncPostgresSaver]), used in LangGraph Cloud. Ideal for using in production. Needs to be installed separately.
 
@@ -378,7 +236,7 @@ Each checkpointer conforms to [BaseCheckpointSaver][langgraph.checkpoint.base.Ba
 If the checkpointer is used with asynchronous graph execution (i.e. executing the graph via `.ainvoke`, `.astream`, `.abatch`), asynchronous versions of the above methods will be used (`.aput`, `.aput_writes`, `.aget_tuple`, `.alist`).
 
 !!! note Note
-    For running your graph asynchronously, you can use `MemorySaver`, or async versions of Sqlite/Postgres checkpointers -- `AsyncSqliteSaver` / `AsyncPostgresSaver` checkpointers.
+    For running your graph asynchronously, you can use `InMemorySaver`, or async versions of Sqlite/Postgres checkpointers -- `AsyncSqliteSaver` / `AsyncPostgresSaver` checkpointers.
 
 ### Serializer
 

docs/docs/concepts/plans.md

@@ -1,39 +0,0 @@
-# LangGraph Platform Plans
-
-
-## Overview
-LangGraph Platform is a commercial solution for deploying agentic applications in production.
-There are three different plans for using it.
-
-- **Developer**: All [LangSmith](https://smith.langchain.com/) users have access to this plan. You can sign up for this plan simply by creating a LangSmith account. This gives you access to the [Self-Hosted Lite](./deployment_options.md#self-hosted-lite) deployment option.
-- **Plus**: All [LangSmith](https://smith.langchain.com/) users with a [Plus account](https://docs.smith.langchain.com/administration/pricing) have access to this plan. You can sign up for this plan simply by upgrading your LangSmith account to the Plus plan type. This gives you access to the [Cloud](./deployment_options.md#cloud-saas) deployment option.
-- **Enterprise**: This is separate from LangSmith plans. You can sign up for this plan by contacting sales@langchain.dev. This gives you access to all deployment options: [Cloud](./deployment_options.md#cloud-saas), [Bring-Your-Own-Cloud](./deployment_options.md#bring-your-own-cloud), and [Self Hosted Enterprise](./deployment_options.md#self-hosted-enterprise)
-
-
-## Plan Details
-
-|                                                                  | Developer                                   | Plus                                                  | Enterprise                                          |
-|------------------------------------------------------------------|---------------------------------------------|-------------------------------------------------------|-----------------------------------------------------|
-| Deployment Options                                               | Self-Hosted Lite                            | Cloud                                                 | Self-Hosted Enterprise, Cloud, Bring-Your-Own-Cloud |
-| Usage                                                     | Free, limited to 1M nodes executed per year | Free while in Beta, will be charged per node executed | Custom                                              |
-| APIs for retrieving and updating state and conversational history | ✅                                           | ✅                                                     | ✅                                                   |
-| APIs for retrieving and updating long-term memory                | ✅                                           | ✅                                                     | ✅                                                   |
-| Horizontally scalable task queues and servers                    | ✅                                           | ✅                                                     | ✅                                                   |
-| Real-time streaming of outputs and intermediate steps            | ✅                                           | ✅                                                     | ✅                                                   |
-| Assistants API (configurable templates for LangGraph apps)       | ✅                                           | ✅                                                     | ✅                                                   |
-| Cron scheduling                                                  | --                                          | ✅                                                     | ✅                                                   |
-| LangGraph Studio for prototyping                                 | Desktop only                                | Coming Soon!                                          | Coming Soon!                                        |
-| Authentication & authorization to call the LangGraph APIs        | --                                          | Coming Soon!                                          | Coming Soon!                                        |
-| Smart caching to reduce traffic to LLM API                       | --                                          | Coming Soon!                                          | Coming Soon!                                        |
-| Publish/subscribe API for state                                  | --                                          | Coming Soon!                                          | Coming Soon!                                        |
-| Scheduling prioritization                                        | --                                          | Coming Soon!                                          | Coming Soon!                                        |
-
-Please see the [LangGraph Platform Pricing](https://www.langchain.com/langgraph-platform-pricing) for information on pricing.
-
-## Related
-
-For more information, please see:
-
-* [Deployment Options conceptual guide](./deployment_options.md)
-* [LangGraph Platform Pricing](https://www.langchain.com/langgraph-platform-pricing)
-* [LangSmith Plans](https://docs.smith.langchain.com/administration/pricing)

docs/docs/concepts/sdk.md

@@ -1,56 +0,0 @@
-# LangGraph SDK
-
-!!! info "Prerequisites"
-    - [LangGraph Platform](./langgraph_platform.md)
-    - [LangGraph Server](./langgraph_server.md)
-
-The LangGraph Platform provides both a Python and JS SDK for interacting with the [LangGraph Server API](./langgraph_server.md). 
-
-## Installation
-
-You can install the packages using the appropriate package manager for your language.
-
-=== "Python"
-    ```bash
-    pip install langgraph-sdk
-    ```
-
-=== "JS"
-    ```bash
-    yarn add @langchain/langgraph-sdk
-    ```
-
-
-## API Reference
-
-You can find the API reference for the SDKs here:
-
-- [Python SDK Reference](../cloud/reference/sdk/python_sdk_ref.md)
-- [JS/TS SDK Reference](../cloud/reference/sdk/js_ts_sdk_ref.md)
-
-## Python Sync vs. Async
-
-The Python SDK provides both synchronous (`get_sync_client`) and asynchronous (`get_client`) clients for interacting with the LangGraph Server API.
-
-=== "Async"
-    ```python
-    from langgraph_sdk import get_client
-
-    client = get_client(url=..., api_key=...)
-    await client.assistants.search()
-    ```
-
-=== "Sync"
-
-    ```python
-    from langgraph_sdk import get_sync_client
-
-    client = get_sync_client(url=..., api_key=...)
-    client.assistants.search()
-    ```
-
-## Related
-
-- [LangGraph CLI API Reference](../cloud/reference/cli.md)
-- [Python SDK Reference](../cloud/reference/sdk/python_sdk_ref.md)
-- [JS/TS SDK Reference](../cloud/reference/sdk/js_ts_sdk_ref.md)

docs/docs/concepts/self_hosted.md

@@ -1,39 +0,0 @@
-# Self-Hosted
-
-!!! note Prerequisites
-
-    - [LangGraph Platform](./langgraph_platform.md)
-    - [Deployment Options](./deployment_options.md)
-
-## Versions
-
-There are two versions of the self hosted deployment: [Self-Hosted Enterprise](./deployment_options.md#self-hosted-enterprise) and [Self-Hosted Lite](./deployment_options.md#self-hosted-lite).
-
-### Self-Hosted Lite
-
-The Self-Hosted Lite version is a limited version of LangGraph Platform that you can run locally or in a self-hosted manner (up to 1 million nodes executed).
-
-When using the Self-Hosted Lite version, you authenticate with a [LangSmith](https://smith.langchain.com/) API key.
-
-### Self-Hosted Enterprise
-
-The Self-Hosted Enterprise version is the full version of LangGraph Platform.
-
-To use the Self-Hosted Enterprise version, you must acquire a license key that you will need to pass in when running the Docker image. To acquire a license key, please email sales@langchain.dev.
-
-## Requirements
-
-- You use `langgraph-cli` and/or [LangGraph Studio](./langgraph_studio.md) app to test graph locally.
-- You use `langgraph build` command to build image.
-
-## How it works
-
-- Deploy Redis and Postgres instances on your own infrastructure.
-- Build the docker image for [LangGraph Server](./langgraph_server.md) using the [LangGraph CLI](./langgraph_cli.md).
-- Deploy a web server that will run the docker image and pass in the necessary environment variables.
-
-For step-by-step instructions, see [How to set up a self-hosted deployment of LangGraph](../how-tos/deploy-self-hosted.md).
-
-## Related
-
-- [How to set up a self-hosted deployment of LangGraph](../how-tos/deploy-self-hosted.md).

docs/docs/concepts/streaming.md

@@ -9,23 +9,8 @@ There are several different modes you can specify when calling these methods (e.
 
 - [`"values"`](../how-tos/stream-values.ipynb): This streams the full value of the state after each step of the graph.
 - [`"updates"`](../how-tos/stream-updates.ipynb): This streams the updates to the state after each step of the graph. If multiple updates are made in the same step (e.g. multiple nodes are run) then those updates are streamed separately.
-- [`"custom"`](../how-tos/streaming-content.ipynb): This streams custom data from inside your graph nodes.
-- [`"messages"`](../how-tos/streaming-tokens.ipynb): This streams LLM tokens and metadata for the graph node where LLM is invoked.
 - `"debug"`: This streams as much information as possible throughout the execution of the graph.
 
-You can also specify multiple streaming modes at the same time by passing them as a list. When you do this, the streamed outputs will be tuples `(stream_mode, data)`. For example:
-
-```python
-graph.stream(..., stream_mode=["updates", "messages"])
-```
-
-```
-...
-('messages', (AIMessageChunk(content='Hi'), {'langgraph_step': 3, 'langgraph_node': 'agent', ...}))
-...
-('updates', {'agent': {'messages': [AIMessage(content="Hi, how can I help you?")]}})
-```
-
 The below visualization shows the difference between the `values` and `updates` modes:
 
 ![values vs updates](../static/values_vs_updates.png)
@@ -145,28 +130,4 @@ guide for that [here](../how-tos/streaming-tokens.ipynb).
 
 
 !!! warning "ASYNC IN PYTHON<=3.10"
-    You may fail to see events being emitted from inside a node when using `.astream_events` in Python <= 3.10. If you're using a Langchain RunnableLambda, a RunnableGenerator, or Tool asynchronously inside your node, you will have to propagate callbacks to these objects manually. This is because LangChain cannot automatically propagate callbacks to child objects in this case. Please see examples [here](../how-tos/streaming-content.ipynb) and [here](../how-tos/streaming-events-from-within-tools.ipynb).
-
-
-## LangGraph Platform
-
-Streaming is critical for making LLM applications feel responsive to end users. When creating a streaming run, the streaming mode determines what data is streamed back to the API client. LangGraph Platform supports five streaming modes:
-
-- `values`: Stream the full state of the graph after each [super-step](https://langchain-ai.github.io/langgraph/concepts/low_level/#graphs) is executed. See the [how-to guide](../cloud/how-tos/stream_values.md) for streaming values.
-- `messages-tuple`: Stream LLM tokens for any messages generated inside a node. This mode is primarily meant for powering chat applications. See the [how-to guide](../cloud/how-tos/stream_messages.md) for streaming messages.
-- `updates`: Streams updates to the state of the graph after each node is executed. See the [how-to guide](../cloud/how-tos/stream_updates.md) for streaming updates.
-- `events`: Stream all events (including the state of the graph) that occur during graph execution. See the [how-to guide](../cloud/how-tos/stream_events.md) for streaming events. This can be used to do token-by-token streaming for LLMs.
-- `debug`: Stream debug events throughout graph execution. See the [how-to guide](../cloud/how-tos/stream_debug.md) for streaming debug events.
-
-You can also specify multiple streaming modes at the same time. See the [how-to guide](../cloud/how-tos/stream_multiple.md) for configuring multiple streaming modes at the same time.
-
-See the [API reference](../cloud/reference/api/api_ref.html#tag/threads-runs/POST/threads/{thread_id}/runs/stream) for how to create streaming runs.
-
-Streaming modes `values`, `updates`, `messages-tuple` and `debug` are very similar to modes available in the LangGraph library - for a deeper conceptual explanation of those, you can see the [previous section](#streaming-graph-outputs-stream-and-astream).
-
-Streaming mode `events` is the same as using `.astream_events` in the LangGraph library - for a deeper conceptual explanation of this, you can see the [previous section](#streaming-graph-outputs-stream-and-astream).
-
-All events emitted have two attributes:
-
-- `event`: This is the name of the event
-- `data`: This is data associated with the event
+    You may fail to see events being emitted from inside a node when using `.astream_events` in Python <= 3.10. If you're using a Langchain RunnableLambda, a RunnableGenerator, or Tool asynchronously inside your node, you will have to propagate callbacks to these objects manually. This is because LangChain cannot automatically propagate callbacks to child objects in this case. Please see examples [here](../how-tos/streaming-content.ipynb) and [here](../how-tos/streaming-events-from-within-tools.ipynb).