Add custom router support in langgraph-api

.github/workflows/ci.yml

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

.github/workflows/deploy_docs.yml

@@ -117,7 +117,6 @@ jobs:
               --check-links-ignore "https://(api|web|docs)\.smith\.langchain\.com/.*" \
               --check-links-ignore "https://academy\.langchain\.com/.*" \
               --check-links-ignore "https://x.com/.*" \
-              --check-links-ignore "https://twitter.com/.*" \
               --check-links-ignore "https://github\.com/.*" \
               --check-links-ignore "http://localhost:8123/.*" \
               --check-links-ignore "http://localhost:2024.*" \
@@ -144,7 +143,6 @@ jobs:
                 --check-links-ignore "http://localhost:2024.*" \
                 --check-links-ignore "http://127.0.0.1:.*" \
                 --check-links-ignore "https://x.com/.*" \
-                --check-links-ignore "https://twitter.com/.*" \
                 --check-links-ignore "https://github\.com/.*" \
                 --check-links-ignore "/.*\.(ipynb|html)$" \
                 --check-links ${CHANGED_FILES} \

.github/workflows/release.yml

@@ -195,7 +195,7 @@ jobs:
               "$PKG_NAME==$VERSION" \
           )
 
-          if [[ "$PKG_NAME" == *checkpoint* || "$PKG_NAME" == *prebuilt* ]]; then
+          if [[ "$PKG_NAME" == *checkpoint* ]]; then
             # since checkpoint packages are namespace packages, import them with . convention
             # i.e. import langgraph.checkpoint or langgraph.checkpoint.sqlite
             IMPORT_NAME="$(echo "$PKG_NAME" | sed s/-/./g)"

.github/workflows/run_notebooks.yml

@@ -22,7 +22,7 @@ jobs:
       matrix:
         lib-version:
           - "development"
-          # - "latest"
+          - "latest"
 
     steps:
       - uses: actions/checkout@v4

README.md

@@ -70,7 +70,7 @@ pip install -U langgraph
 Let's build a tool-calling [ReAct-style](https://langchain-ai.github.io/langgraph/concepts/agentic_concepts/#react-implementation) agent that uses a search tool!
 
 ```shell
-pip install langgraph-prebuilt langchain-anthropic
+pip install langchain-anthropic
 ```
 
 ```shell

docs/Makefile

@@ -26,9 +26,15 @@ install-vercel-deps:
 	# don't use vercel's python - it wasn't compiled with sqlite support, and it fails when installing ipython's kernel
 	poetry env use /usr/bin/python3.11
 	poetry install --with docs --with test --no-root
+	poetry run pip install "git+https://github.com/benjamincburns/markdown-exec.git@cc0d39d737e5ffd4b83d23cd8729d7ea16e363c8"
+	poetry run python3 -m ipykernel install --name=python3
+	npm install -g tslab
+	poetry run tslab install --python=python3
+	poetry run jupyter kernelspec list
+
 
 tests:
-	# Run unit tests
+	# RUn unit tests
 	poetry run pytest tests/unit_tests
 
 

docs/_scripts/assets/nock_setup_preamble.ts

@@ -0,0 +1,75 @@
+import nock, { Definition } from "nock";
+import msgpack from "msgpack-lite";
+import zlib from "node:zlib";
+import fs from "node:fs/promises";
+import { Buffer } from "node:buffer";
+
+// deno style imports here because we're running this in the deno jupyter kernel
+
+interface NockCassetteData {
+  hash: string;
+  entries: Definition[];
+}
+
+// Utility functions for compression & serialization
+function compressData(data: NockCassetteData, compressionLevel = 9): string {
+  const packed = msgpack.encode(data);
+  const compressed = zlib.deflateSync(packed, { level: compressionLevel });
+  return compressed.toString("base64");
+}
+
+function decompressData(compressedString: string): NockCassetteData {
+  const decoded = Buffer.from(compressedString, "base64");
+  const decompressed = zlib.inflateSync(decoded);
+  return msgpack.decode(decompressed) as NockCassetteData;
+}
+
+// deno-lint-ignore no-unused-vars
+class HashedCassette {
+  private recording = true;
+
+  constructor(
+    private readonly cassettePath: string,
+    private readonly hash: string
+  ) {}
+
+  async enter() {
+    try {
+      const rawCassette = await fs.readFile(this.cassettePath, "utf-8");
+      const data = decompressData(rawCassette);
+      if (data.hash === this.hash) {
+        this.recording = false;
+        nock.disableNetConnect();
+        nock.define(data.entries);
+        return;
+      }
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("ENOENT")) {
+        this.recording = true;
+      } else {
+        throw error;
+      }
+    }
+
+    nock.recorder.rec({
+      dont_print: true,
+      output_objects: true,
+    });
+  }
+
+  async exit() {
+    if (this.recording) {
+      const entries = nock.recorder.play() as Definition[];
+      const data = {
+        hash: this.hash,
+        entries,
+      };
+      const compressed = compressData(data);
+      await fs.writeFile(this.cassettePath, compressed);
+    } else {
+      nock.enableNetConnect();
+      nock.restore();
+      nock.cleanAll();
+    }
+  }
+}

docs/_scripts/assets/vcr_setup_preamble.py

@@ -0,0 +1,107 @@
+import base64
+import os
+import zlib
+from types import TracebackType
+from typing import Optional, Any, Type
+
+import msgpack
+import vcr
+
+os.environ.pop("LANGCHAIN_TRACING_V2", None)
+custom_vcr = vcr.VCR()
+
+
+def compress_data(data: Any, compression_level: int = 9) -> str:
+    packed = msgpack.packb(data, use_bin_type=True)
+    compressed = zlib.compress(packed, level=compression_level)
+    return base64.b64encode(compressed).decode("utf-8")
+
+
+def decompress_data(compressed_string: str) -> Any:
+    decoded = base64.b64decode(compressed_string)
+    decompressed = zlib.decompress(decoded)
+    return msgpack.unpackb(decompressed, raw=False)
+
+
+class AdvancedCompressedSerializer:
+    def serialize(self, cassette_dict: Any) -> str:
+        return compress_data(cassette_dict)
+
+    def deserialize(self, cassette_string: str) -> Any:
+        return decompress_data(cassette_string)
+
+
+custom_vcr.register_serializer("advanced_compressed", AdvancedCompressedSerializer())
+custom_vcr.serializer = "advanced_compressed"
+
+
+class HashedCassette:
+    def __init__(self, cassette_path: str, hash_value: str) -> None:
+        """A context manager for using VCR cassettes with an embedded hash value.
+
+        Args:
+            cassette_path (str): The file path of the cassette (independent of hash).
+            hash_value (str): The expected hash value (e.g. a uuid string).
+
+        This class provides a context manager for using VCR cassettes with an embedded hash value.
+        The hash value is used to ensure that the cassette matches the expected state, and if not,
+        the cassette is removed or updated with the new hash value.
+        """
+        self.cassette_path: str = cassette_path
+        self.hash_value: str = hash_value
+        self.vcr: vcr.VCR = custom_vcr
+        self.cassette_context: Optional[Any] = None
+        self.exited: bool = False
+
+    def __enter__(self) -> Any:
+        self.exited: bool = False
+        # Get the serializer instance from the VCR instance.
+        serializer = self.vcr.serializers[self.vcr.serializer]
+        # If the cassette file exists, check its embedded hash.
+        if os.path.exists(self.cassette_path):
+            with open(self.cassette_path, "r") as f:
+                content = f.read()
+            try:
+                cassette_data = serializer.deserialize(content)
+            except Exception as e:
+                os.remove(self.cassette_path)
+            else:
+                existing_hash = cassette_data.get("cassette_hash")
+                if existing_hash != self.hash_value:
+                    os.remove(self.cassette_path)
+        # Now enter the VCR cassette context.
+        self.cassette_context = custom_vcr.use_cassette(
+            self.cassette_path,
+            filter_headers=["x-api-key", "authorization"],
+            record_mode="once",
+            serializer="advanced_compressed",
+        )
+        return self.cassette_context.__enter__()
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]] = None,
+        exc_val: Optional[BaseException] = None,
+        exc_tb: Optional[TracebackType] = None,
+    ) -> Optional[bool]:
+        if self.exited:
+            return
+        self.exited = True
+        # Exit the VCR cassette context.
+        result = self.cassette_context.__exit__(exc_type, exc_val, exc_tb)
+        serializer = self.vcr.serializers[self.vcr.serializer]
+        # If a cassette was recorded (or updated), open and update its hash.
+        if os.path.exists(self.cassette_path):
+            with open(self.cassette_path, "r") as f:
+                content = f.read()
+            try:
+                cassette_data = serializer.deserialize(content)
+            except Exception as e:
+                return result
+            # Update the cassette data with the expected hash.
+            if cassette_data.get("cassette_hash") != self.hash_value:
+                cassette_data["cassette_hash"] = self.hash_value
+                serialized_data = serializer.serialize(cassette_data)
+                with open(self.cassette_path, "w") as f:
+                    f.write(serialized_data)
+        return result

docs/_scripts/generate_api_reference_links.py

@@ -1,9 +1,12 @@
-import ast
 import importlib
+from importlib.machinery import ModuleSpec
+import importlib.util
+import inspect
 import logging
 import re
 from functools import lru_cache
-from typing import List, Optional
+import sys
+from typing import List, Literal, Optional
 
 from typing_extensions import TypedDict
 
@@ -39,6 +42,7 @@ MANUAL_API_REFERENCES_LANGGRAPH = [
     (["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"),
@@ -47,9 +51,7 @@ MANUAL_API_REFERENCES_LANGGRAPH = [
     (["langgraph.constants"], "langgraph.types", "Command", "types"),
     (["langgraph.func"], "langgraph.func", "entrypoint", "func"),
     (["langgraph.func"], "langgraph.func", "task", "func"),
-    (["langgraph.types"], "langgraph.types", "RetryPolicy", "types"),
-    (["langgraph.types"], "langgraph.types", "StreamMode", "types"),
-    (["langgraph.types"], "langgraph.types", "StreamWriter", "types"),
+    ([], "langgraph.types", "RetryPolicy", "types"),
     ([], "langgraph.checkpoint.base", "Checkpoint", "checkpoints"),
     ([], "langgraph.checkpoint.base", "CheckpointMetadata", "checkpoints"),
     ([], "langgraph.checkpoint.base", "BaseCheckpointSaver", "checkpoints"),
@@ -69,149 +71,224 @@ WELL_KNOWN_LANGGRAPH_OBJECTS = {
 }
 
 
+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 + r"(?:_\w+)?(?:\.\w+)*?)\s+import\s+\(?"
+        r"((?:\w+(?:,\s*)?)*)\s*\)?",  # Match zero or more words separated by a comma+optional ws
+        re.DOTALL,  # Match newlines as well
+    )
+
+
+# Regular expression to match langchain import lines
+_IMPORT_LANGCHAIN_RE = _make_regular_expression("langchain")
+_IMPORT_LANGGRAPH_RE = _make_regular_expression("langgraph")
+
+
 @lru_cache(maxsize=10_000)
-def _get_full_module_name(module_path: str, class_name: str) -> Optional[str]:
+def _get_full_module_name(
+    module_path: str, class_name: str | None, doc_title: str
+) -> Optional[str]:
     """Get full module name using inspect, with LRU cache to memoize results."""
     try:
-        module = importlib.import_module(module_path)
-        symbol = getattr(module, class_name)
-        # First check the __module__ attribute on the symbol.
-        mod_name = getattr(symbol, "__module__", None)
-        # If __module__ is not set or comes from typing,
-        # assume the definition is in module_path.
-        if mod_name is None or mod_name.startswith("typing"):
-            return module_path
-        return mod_name
+        if module_path in sys.modules:
+            module = sys.modules[module_path]
+        else:
+            spec: ModuleSpec | None = importlib.util.find_spec(module_path)
+            if spec is not None:
+                module = importlib.util.module_from_spec(spec)
+                sys.modules[module_path] = module
+                spec.loader.exec_module(module)
+
+        if class_name is not None:
+            class_ = getattr(module, class_name)
+
+            if re.match(r"\w+\s+as\s+\w+", class_name):
+                # Handle cases like "A as B"
+                class_name, _ = class_name.split(" as ")
+
+            module = inspect.getmodule(class_)
+            if module is None:
+                # For constants, inspect.getmodule() might return None
+                # In this case, we'll return the original module_path
+                return module_path
+        return module.__name__
     except AttributeError as e:
-        logger.warning(f"API Reference: Could not find module for {class_name}, {e}")
+        if class_name is not None:
+            # the class_name might actually be a module
+            # e.g. from langchain import hub
+            # try to import it as a module, and if that doesn't work, throw
+            if class_name is not None:
+                module_name = _get_full_module_name(
+                    f"{module_path}.{class_name}", None, doc_title
+                )
+                if module_name is not None:
+                    # return the name of the parent module, rather than the name of the class as though it were a module
+                    return module.__name__
+                logger.warning(
+                    f"API Reference: Could not find module for {class_name} in {module_path}, imported in doc {doc_title}, {e}"
+                )
+            # don't log if we're trying to import the "hub" part as though it were a module
+        logger.warning(
+            f"API Reference: Could not find module for {module_path}, imported in doc {doc_title}, {e}"
+        )
         return None
     except ImportError as e:
-        logger.warning(f"API Reference: Failed to load for class {class_name}, {e}")
+        logger.warning(
+            f"API Reference: Failed to import module {module_path} {doc_title}, {e}"
+        )
         return None
 
 
+def _get_doc_title(data: str, file_name: str) -> str:
+    try:
+        return re.findall(r"^#\s*(.*)", data, re.MULTILINE)[0]
+    except IndexError:
+        pass
+    # Parse the rst-style titles
+    try:
+        return re.findall(r"^(.*)\n=+\n", data, re.MULTILINE)[0]
+    except IndexError:
+        return file_name
+
+
 class ImportInformation(TypedDict):
     imported: str  # The name of the class that was imported.
     source: str  # The full module path from which the class was imported.
     docs: str  # The URL pointing to the class's documentation.
-    path: str  # The path of the file where the markdown content originated.
+    title: str  # The title of the document where the import is used.
 
 
-def get_imports(code: str, path: str) -> List[ImportInformation]:
-    """Retrieve all import references from the given code for specified ecosystems.
+def _get_imports(
+    code: str, doc_title: str, package_ecosystem: Literal["langchain", "langgraph"]
+) -> List[ImportInformation]:
+    """Get imports from the given code block.
 
     Args:
-        code: The source code from which to extract import references.
-        path: The path of the file where the markdown content originated.
+        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:
-        A list of import information for each import found.
+        List of import information for the given code block
     """
-    # Parse the code into an AST.
-    try:
-        tree = ast.parse(code)
-    except SyntaxError:
-        return []
+    imports = []
 
-    found_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}")
 
-    # Walk through the AST and process ImportFrom nodes.
-    for node in ast.walk(tree):
-        if isinstance(node, ast.ImportFrom):
-            # node.module is the source module.
-            if node.module is None:
+    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:
+            if module == "langchain_core.messages" and class_name == ")":
+                print("WARNING: ", file=sys.stderr)
+                print(
+                    f"WARNING: Trying to import {class_name} from {module} in doc {doc_title}",
+                    file=sys.stderr,
+                )
+                print("WARNING: ", file=sys.stderr)
+                print("WARNING:", import_match.group(0), file=sys.stderr)
+                print("WARNING: ", file=sys.stderr)
+                print(
+                    "\n".join([f"WARNING: {line}" for line in code.splitlines()]),
+                    file=sys.stderr,
+                )
+                print("WARNING: ", file=sys.stderr)
+
+            module_path = _get_full_module_name(module, class_name, doc_title)
+            if not module_path:
                 continue
-            for alias in node.names:
-                if not (
-                    node.module.startswith("langchain")
-                    or node.module.startswith("langgraph")
-                ):
+            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
 
-                found_imports.append(
-                    {
-                        "source": node.module,
-                        # alias.name is the original name even if an alias exists.
-                        "imported": alias.name,
-                    }
+                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}")
 
-    imports: list[ImportInformation] = []
-
-    for found_import in found_imports:
-        module = found_import["source"]
-
-        if module.startswith("langchain"):
-            # Handles things like `langchain` or `langchain_anthropic`
-            package_ecosystem = "langchain"
-        elif module.startswith("langgraph"):
-            package_ecosystem = "langgraph"
-        else:
-            continue
-
-        class_name = found_import["imported"]
-        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"
+            # Add the import information to our list
+            imports.append(
+                {
+                    "imported": class_name,
+                    "source": module,
+                    "docs": url,
+                    "title": doc_title,
+                }
             )
-        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,
-                "path": path,
-            }
-        )
 
     return imports
 
 
-def update_markdown_with_imports(markdown: str, path: str) -> str:
+def get_imports(code: str, doc_title: str) -> List[ImportInformation]:
+    """Retrieve all import references from the given code for specified ecosystems.
+
+    Args:
+        code: The source code from which to extract import references.
+        doc_title: The documentation title associated with the code.
+
+    Returns:
+        A list of import information for each import found.
+    """
+    ecosystems = ["langchain", "langgraph"]
+    all_imports = []
+    for package_ecosystem in ecosystems:
+        all_imports.extend(_get_imports(code, doc_title, package_ecosystem))
+    return all_imports
+
+
+def update_markdown_with_imports(markdown: str, file_name: str) -> str:
     """Update markdown to include API reference links for imports in Python code blocks.
 
-    This function scans the markdown content for Python code blocks, extracts any
-    imports, and appends links to their API documentation.
+    This function scans the markdown content for Python code blocks, extracts any imports, and appends links to their API documentation.
 
     Args:
         markdown: The markdown content to process.
-        path: The path of the file where the markdown content originated.
 
     Returns:
         Updated markdown with API reference links appended to Python code blocks.
@@ -222,8 +299,7 @@ def update_markdown_with_imports(markdown: str, path: str) -> str:
         ```python
         from langchain.nlp import TextGenerator
         ```
-        This function will append an API reference link to the `TextGenerator` class
-        from the `langchain.nlp` module if it's recognized.
+        This function will append an API reference link to the `TextGenerator` class from the `langchain.nlp` module if it's recognized.
     """
     code_block_pattern = re.compile(
         r"(?P<indent>[ \t]*)```(?P<language>python|py)\n(?P<code>.*?)\n(?P=indent)```",
@@ -241,8 +317,9 @@ def update_markdown_with_imports(markdown: str, path: str) -> str:
         """
         indent = match.group("indent")
         code_block = match.group("code")
+        language = match.group("language")  # Preserve the language from the regex match
         # Retrieve import information from the code block
-        imports = get_imports(code_block, "__unused__")
+        imports = get_imports(code_block, file_name)
 
         original_code_block = match.group(0)
         # If no imports are found, return the original code block

docs/_scripts/notebook_convert.py

@@ -1,8 +1,10 @@
+import argparse
 import ast
+import glob
 import os
 import re
 from pathlib import Path
-from typing import Literal
+from typing import Literal, Optional
 
 import nbformat
 from nbconvert.exporters import MarkdownExporter
@@ -350,6 +352,17 @@ exporter = MarkdownExporter(
     ],
 )
 
+md_executable = MarkdownExporter(
+    preprocessors=[
+        ExtractAttachmentsPreprocessor,
+        EscapePreprocessor(markdown_exec_migration=True),
+    ],
+    template_name="md_executable",
+    extra_template_basedirs=[
+        os.path.join(os.path.dirname(__file__), "notebook_convert_templates")
+    ],
+)
+
 
 def convert_notebook(
     notebook_path: Path,
@@ -359,5 +372,99 @@ def convert_notebook(
         nb = nbformat.read(f, as_version=4)
 
     nb.metadata.mode = mode
-    body, _ = exporter.from_notebook_node(nb)
+    if mode == "markdown":
+        body, _ = exporter.from_notebook_node(nb)
+    else:
+        body, _ = md_executable.from_notebook_node(nb)
     return body
+
+
+HERE = Path(__file__).parent
+DOCS = HERE.parent / "docs"
+
+
+# Convert notebooks to markdown
+def _convert_notebooks(
+    *,
+    output_dir: Optional[Path] = None,
+    replace: bool = False,
+    pattern: str = "*.ipynb",
+) -> None:
+    """Converting notebooks."""
+    if not output_dir and not replace:
+        raise ValueError("Either --output_dir or --replace must be specified")
+
+    output_dir_path = DOCS if replace else Path(output_dir)
+
+    # Get the directory where the script was executed
+    base_dir = os.getcwd()
+    # Build the full search pattern using the current working directory as the base
+    full_pattern = os.path.join(base_dir, args.pattern)
+
+    # Use glob with recursive search enabled
+    matching_files = glob.glob(full_pattern, recursive=True)
+    paths = [Path(file) for file in matching_files]
+
+    file_names = [notebook.name for notebook in paths]
+
+    for notebook in paths:
+        markdown = convert_notebook(notebook, mode="exec")
+        markdown_path = output_dir_path / notebook.relative_to(DOCS).with_suffix(".md")
+        markdown_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(markdown_path, "w") as f:
+            f.write(markdown)
+        if replace:
+            notebook.unlink(missing_ok=False)
+
+    if replace:
+        # The regex will match markdown links that point to *.ipynb files.
+        # It captures:
+        #   group(1): the link text (inside the square brackets)
+        #   group(2): the file path (without the trailing .ipynb)
+        link_pattern = r"(?<!!)\[([^\]]+)\]\((?![^)]*//)([^)]+)\.ipynb\)"
+
+        def replace_link(match: re.Match) -> str:
+            link_text = match.group(1)
+            link_target = match.group(2)
+            # Reconstruct the file name with the .ipynb extension.
+            # For example, if link_target is "foo/bar", then linked_file becomes "bar.ipynb".
+            linked_file = Path(link_target).name + ".ipynb"
+            # Only update if the notebook was among those converted.
+            if linked_file in file_names:
+                # Change the extension from .ipynb to .md
+                return f"[{link_text}]({link_target}.md)"
+            # Otherwise, leave the original link intact.
+            return match.group(0)
+
+        # Process all markdown files in the output directory.
+        for path in output_dir_path.rglob("**/*.md"):
+            with open(path, "r", encoding="utf-8") as f:
+                content = f.read()
+            new_content = re.sub(link_pattern, replace_link, content)
+            with open(path, "w", encoding="utf-8") as f:
+                f.write(new_content)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Convert notebooks to markdown")
+    parser.add_argument(
+        "--output_dir",
+        default=None,
+        help="Directory to output markdown files",
+    )
+    parser.add_argument(
+        "--replace",
+        action="store_true",
+        help="Replace original notebooks with markdown files",
+    )
+    parser.add_argument(
+        "--pattern",
+        default="*.ipynb",
+        help="Glob pattern to match notebooks to convert",
+    )
+    args = parser.parse_args()
+    _convert_notebooks(
+        replace=args.replace,
+        output_dir=args.output_dir,
+        pattern=args.pattern,
+    )

docs/_scripts/notebook_convert_templates/md_executable/conf.json

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

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

@@ -0,0 +1,38 @@
+{#https://github.com/rdbisme/nbconvert/blob/master/share/jupyter/nbconvert/templates/markdown/index.md.j2#}
+{% extends 'markdown/index.md.j2' %}
+
+{% block input %}
+```
+{%- if 'magics_language' in cell.metadata  -%}
+    {{ cell.metadata.magics_language}}
+{%- elif cell.metadata.get('language') == "shell" -%}
+    shell
+{%- elif 'name' in nb.metadata.get('language_info', {}) -%}
+    {{ nb.metadata.language_info.name }}{% if cell.metadata.exec|default(false) %} exec="on" source="above" session="1"{% if cell.metadata.has_output|default(false) %} result="ansi"{% endif %}{% endif %}
+{%- endif %}
+{{ cell.source}}
+```
+{% endblock input %}
+
+{%- block traceback_line -%}
+{%- endblock traceback_line -%}
+
+{%- block stream -%}
+{%- endblock stream -%}
+
+{%- block data_text scoped -%}
+{%- 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

@@ -2,13 +2,18 @@ import logging
 import os
 import posixpath
 import re
-from typing import Any, Dict
+import traceback
+from typing import Any, Callable, Dict
 
+from markdown import Markdown
+from markdown_exec.hooks import SessionHistoryEntry
 from mkdocs.structure.files import Files, File
 from mkdocs.structure.pages import Page
+from pymdownx.superfences import SuperFencesException
 
 from _scripts.generate_api_reference_links import update_markdown_with_imports
 from _scripts.notebook_convert import convert_notebook
+from _scripts.setup_vcr import load_postamble, load_preamble, _hash_string
 
 logger = logging.getLogger(__name__)
 logging.basicConfig()
@@ -158,6 +163,118 @@ def _highlight_code_blocks(markdown: str) -> str:
     return markdown
 
 
+def handle_vcr_setup(
+    *,
+    formatter: Callable,
+    language: str,
+    code: str,
+    session: str,
+    id: str,
+    md: Markdown,
+    **kwargs: Dict[str, Any],
+) -> Dict[str, Any]:
+    """Handle VCR setup in markdown content if necessary."""
+    try:
+        if kwargs.get("extra", None) is None:
+            raise SuperFencesException(
+                f"error while processing {language} block: extra dict is required"
+            )
+
+        if kwargs["extra"].get("path", None) is None:
+            raise SuperFencesException(
+                f"error while processing {language} block: path is required"
+            )
+
+        document_filename = kwargs["extra"]["path"]
+
+        if session is None or session == "" and id is None or id == "":
+            id = _hash_string(code)
+
+        if session is not None and session != "":
+            logger.info(f"new {language} session {session} on page {document_filename}")
+
+        cassette_prefix = document_filename.replace(".md", "").replace(os.path.sep, "_")
+
+        cassette_dir = os.path.abspath(
+            os.path.join(os.path.dirname(os.path.dirname(__file__)), "cassettes")
+        )
+        os.makedirs(cassette_dir, exist_ok=True)
+
+        # Build a unique cassette name.
+        cassette_name = os.path.join(
+            cassette_dir,
+            f"{cassette_prefix}_{session if session else id}_{language}.msgpack.zlib",
+        )
+
+        # Add context manager at start with explicit __enter__ and __exit__ calls
+
+        wrapped_lines = [
+            load_preamble(language, code, cassette_name),
+            code,
+        ]
+
+        if session is None or session == "":
+            logger.info(
+                f"no session, adding postamble for {language} in {document_filename}"
+            )
+            wrapped_lines.append(load_postamble(language))
+
+        transformed_source = "\n".join(wrapped_lines)
+
+        # Propagate extras
+        keep_extras = {
+            key: value
+            for key, value in kwargs["extra"].items()
+            if key
+            in {
+                "hl_lines",
+            }
+        }
+
+        return dict(
+            transform_source=lambda code: (transformed_source, code),
+            id=id,
+            extra=keep_extras,
+        )
+    except Exception as e:
+        raise SuperFencesException(traceback.format_exc()) from e
+
+
+def handle_vcr_teardown(
+    *,
+    formatter: Callable,
+    language: str,
+    session: str,
+    history: list[SessionHistoryEntry],
+):
+    last_inputs = dict(history[-1].inputs)
+    code = load_postamble(language)
+    md = last_inputs["md"]
+    html = False
+    update_toc = False
+
+    document_filename = last_inputs.get("extra", {}).get("path", None)
+
+    if document_filename is None:
+        logger.warning(f"no document filename found while tearing down {session}!")
+    else:
+        logger.info(f"tearing down {language} {session} on {document_filename}")
+
+    kwargs = dict(
+        code=code,
+        session=session,
+        id=f"{id}_vcr_end",
+        md=md,
+        html=html,
+        update_toc=update_toc,
+        extra={},
+    )
+
+    # This doesn't actually render anything, we just call the formatter so it
+    # executes in the same context as the session of which we're disposing.
+    formatter(**kwargs)
+
+
 def _on_page_markdown_with_config(
     markdown: str,
     page: Page,
@@ -175,7 +292,7 @@ def _on_page_markdown_with_config(
 
     # Append API reference links to code blocks
     if add_api_references:
-        markdown = update_markdown_with_imports(markdown, page.file.abs_src_path)
+        markdown = update_markdown_with_imports(markdown, page.file.src_path)
     # Apply highlight comments to code blocks
     markdown = _highlight_code_blocks(markdown)
 

docs/_scripts/setup_vcr.py

@@ -0,0 +1,77 @@
+# A list of patterns that, if found in a code block, will cause us to leave that block unchanged.
+import hashlib
+import os
+from textwrap import dedent
+
+preambles = {
+    "python": "vcr_setup_preamble.py",
+    "typescript": "nock_setup_preamble.ts",
+}
+
+
+def _get_python_cassette_init(cassette_name: str, hash_: str) -> str:
+    return dedent(
+        f"""
+        _cassette = HashedCassette('{cassette_name}', '{hash_}')
+        _cassette.__enter__()
+        """
+    )
+
+
+def _get_typescript_cassette_init(cassette_name: str, hash_: str) -> str:
+    return dedent(
+        f"""
+        const _cassette = new HashedCassette("{cassette_name}", "{hash_}");
+        await _cassette.enter();
+        """
+    )
+
+
+def _get_python_cassette_cleanup() -> str:
+    return "_cassette.__exit__()"
+
+
+def _get_typescript_cassette_cleanup() -> str:
+    return "await _cassette.exit();"
+
+
+preamble_inits = {
+    "python": _get_python_cassette_init,
+    "py": _get_python_cassette_init,
+    "typescript": _get_typescript_cassette_init,
+    "ts": _get_typescript_cassette_init,
+}
+
+preamble_cleanups = {
+    "python": _get_python_cassette_cleanup,
+    "py": _get_python_cassette_cleanup,
+    "typescript": _get_typescript_cassette_cleanup,
+    "ts": _get_typescript_cassette_cleanup,
+}
+
+
+def load_preamble(language: str, code: str, cassette_name: str) -> str:
+    """Load the source code for the preamble for a given language."""
+    _assets_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "assets")
+
+    preamble_path = os.path.join(_assets_dir, preambles[language])
+    with open(preamble_path, "r") as f:
+        lines = f.readlines()
+        hash_ = _hash_string(code)
+        lines.append(preamble_inits[language](cassette_name, hash_))
+        return "\n".join(lines).strip()
+
+
+def load_postamble(language: str) -> str:
+    """Load the source code for the postamble for a given language."""
+
+    return preamble_cleanups[language]()
+
+
+def _hash_string(input_string: str) -> str:
+    # Encode the input string to bytes
+    encoded_string = input_string.encode("utf-8")
+    # Create a SHA-256 hash object
+    sha256_hash = hashlib.sha256(encoded_string)
+    # Get the hexadecimal digest of the hash
+    return sha256_hash.hexdigest()

docs/_scripts/third_party_page/create_third_party_page.py

@@ -83,18 +83,14 @@ def generate_markdown(resolved_packages: List[ResolvedPackage], language: str) -
         resolved_packages, key=lambda p: p["weekly_downloads"] or 0, reverse=True
     )
     rows = [
-        "| Name | GitHub URL | Description | Weekly Downloads | Stars |",
-        "| --- | --- | --- | --- | --- |",
+        "| Name | GitHub URL | Description | Weekly Downloads |",
+        "| --- | --- | --- | --- |",
     ]
     for package in sorted_packages:
         name = f"**{package['name']}**"
         repo_url = f"[{package['repo']}](https://github.com/{package['repo']})"
-        stars_badge = (
-            f"https://img.shields.io/github/stars/{package['repo']}?style=social"
-        )
-        stars = f"![GitHub stars]({stars_badge})"
-        downloads = package["weekly_downloads"] or "-"
-        row = f"| {name} | {repo_url} | {package['description']} | {downloads} | {stars}"
+        downloads = package["weekly_downloads"] or 0
+        row = f"| {name} | {repo_url} | {package['description']} | {downloads} |"
         rows.append(row)
     markdown_content = MARKDOWN.format(
         library_list="\n".join(rows), langgraph_url=langgraph_url

docs/_scripts/third_party_page/get_download_stats.py

@@ -35,45 +35,20 @@ def _get_weekly_downloads(packages: list[Package]) -> list[ResolvedPackage]:
     resolved_packages: list[ResolvedPackage] = []
 
     for package in packages:
-        # First check if package exists on PyPI
-        pypi_url = f"https://pypi.org/pypi/{package['name']}/json"
-        try:
-            pypi_response = requests.get(pypi_url)
-            pypi_response.raise_for_status()
-        except requests.exceptions.HTTPError:
-            raise AssertionError(f"Package {package['name']} does not exist on PyPI")
+        url = f"https://pypistats.org/api/packages/{package['name']}/overall"
 
-        # Get first release date
-        pypi_data = pypi_response.json()
-        releases = pypi_data["releases"]
-        first_release_date = None
-        for version_releases in releases.values():
-            if version_releases:  # Some versions may be empty lists
-                upload_time = datetime.fromisoformat(version_releases[0]["upload_time"])
-                if first_release_date is None or upload_time < first_release_date:
-                    first_release_date = upload_time
+        response = requests.get(url)
+        response.raise_for_status()
+        data = response.json()
 
-        if first_release_date is None:
-            raise AssertionError(f"Package {package['name']} has no releases yet")
+        sorted_data = sorted(
+            data["data"],
+            key=lambda x: datetime.strptime(x["date"], "%Y-%m-%d"),
+            reverse=True,
+        )
 
-        # If package was published in last 48 hours, skip download stats
-        if (datetime.now() - first_release_date).total_seconds() >= 48 * 3600:
-            url = f"https://pypistats.org/api/packages/{package['name']}/overall"
-
-            response = requests.get(url)
-            response.raise_for_status()
-            data = response.json()
-
-            sorted_data = sorted(
-                data["data"],
-                key=lambda x: datetime.strptime(x["date"], "%Y-%m-%d"),
-                reverse=True,
-            )
-
-            # Sum the last 7 days of downloads
-            num_downloads = sum(entry["downloads"] for entry in sorted_data[:7])
-        else:
-            num_downloads = None
+        # Sum the last 7 days of downloads
+        num_downloads = sum(entry["downloads"] for entry in sorted_data[:7])
 
         resolved_packages.append(
             {

docs/_scripts/third_party_page/packages.yml

@@ -2,25 +2,10 @@
 packages:
   - name: "trustcall"
     repo: "hinthornw/trustcall"
-    description: "Tenacious tool calling built on LangGraph."
+    description: "Tenacious tool calling built on LangGraph"
   - name: "breeze-agent"
     repo: "andrestorres123/breeze-agent"
-    description: "A streamlined research system built inspired on STORM and built on LangGraph."
+    description: "A streamlined research system built inspired on STORM and built on LangGraph"
   - name: "langgraph-supervisor"
-    repo: "langchain-ai/langgraph-supervisor-py"
-    description: "Build supervisor multi-agent systems with LangGraph."
-  - name: "langmem"
-    repo: "langchain-ai/langmem"
-    description: "Build agents that learn and adapt from interactions over time."
-  - name: "langchain-mcp-adapters"
-    repo: "langchain-ai/langchain-mcp-adapters"
-    description: "Make Anthropic Model Context Protocol (MCP) tools compatible with LangGraph agents."
-  - name: "open-deep-research"
-    repo: "langchain-ai/open_deep_research"
-    description: "Open source assistant for iterative web research and report writing."
-  - name: "langgraph-swarm"
-    repo: "langchain-ai/langgraph-swarm-py"
-    description: "Build swarm-style multi-agent systems using LangGraph."
-  - name: "delve-taxonomy-generator"
-    repo: "andrestorres123/delve"
-    description: "A taxonomy generator for unstructured data"
+    repo: "langchain-ai/langgraph-supervisor"
+    description: "Build supervisor multi-agent systems with LangGraph"

docs/docs/adopters.md

@@ -9,11 +9,9 @@ This list of companies using LangGraph and their success stories is compiled fro
 | [AppFolio](https://www.appfolio.com/) | Real Estate | Copilot for domain-specific task | [Case study, 2024](https://blog.langchain.dev/customers-appfolio/) |
 | [Athena Intelligence](https://www.athenaintel.com/) | Software & Technology (GenAI Native) | Research & summarization | [Case study, 2024](https://blog.langchain.dev/customers-athena-intelligence/) |
 | [Captide](https://www.captide.co/) | Software & Technology (GenAI Native) | Data extraction | [Case study, 2025](https://blog.langchain.dev/how-captide-is-redefining-equity-research-with-agentic-workflows-built-on-langgraph-and-langsmith/) |
-| [Cisco Outshift](https://outshift.cisco.com/) | Software & Technology | DevOps | [Blog post, 2025](https://outshift.cisco.com/blog/build-react-agent-application-for-devops-tasks-using-rest-apis) |
 | [Elastic](https://www.elastic.co/) | Software & Technology | Copilot for domain-specific task | [Blog post, 2025](https://www.elastic.co/blog/elastic-security-generative-ai-features) |
 | [GitLab](https://about.gitlab.com/) | Software & Technology | Code generation | [Duo workflow docs](https://handbook.gitlab.com/handbook/engineering/architecture/design-documents/duo_workflow/) |
 | [Infor](https://infor.com/) | Software & Technology | GenAI embedded product experiences; customer support; copilot | [Case study, 2025](https://blog.langchain.dev/customers-infor/) |
-| [Klarna](https://www.klarna.com/) | Fintech | Copilot for domain-specific task | [Case study, 2025](https://blog.langchain.dev/customers-klarna/) |
 | [Komodo Health](https://www.komodohealth.com/) | Healthcare | Copilot for domain-specific task | [Blog post](https://www.komodohealth.com/perspectives/new-gen-ai-assistant-empowers-the-enterprise/) |
 | [LinkedIn](https://www.linkedin.com/) | Social Media | Code generation; Search & discovery | [Blog post, 2025](https://www.linkedin.com/blog/engineering/ai/practical-text-to-sql-for-data-analytics); [Blog post, 2024](https://www.linkedin.com/blog/engineering/generative-ai/behind-the-platform-the-journey-to-create-the-linkedin-genai-application-tech-stack) |
 | [Minimal](https://gominimal.ai/) | E-commerce | Customer support | [Case study, 2025](https://blog.langchain.dev/how-minimal-built-a-multi-agent-customer-support-system-with-langgraph-langsmith/) |
@@ -24,4 +22,4 @@ This list of companies using LangGraph and their success stories is compiled fro
 | [Tradestack](https://www.tradestack.uk/) | Software & Technology (GenAI Native) | Copilot for domain-specific task | [Case study, 2024](https://blog.langchain.dev/customers-tradestack/) |
 | [Uber](https://www.uber.com/) | Transportation | Developer productivity; Code generation | [Presentation, 2024](https://dpe.org/sessions/ty-smith-adam-huda/this-year-in-ubers-ai-driven-developer-productivity-revolution/); [Video, 2024](https://www.youtube.com/watch?v=8rkA5vWUE4Y) |
 | [Unify](https://www.unifygtm.com/) | Software & Technology (GenAI Native) | Copilot for domain-specific task | [Blog post, 2024](https://blog.langchain.dev/unify-launches-agents-for-account-qualification-using-langgraph-and-langsmith/) |
-| [Vizient](https://www.vizientinc.com/) | Healthcare | Copilot for domain-specific task | [Case study, 2025](https://blog.langchain.dev/p/3d2cd58c-13a5-4df9-bd84-7d54ed0ed82c/) |
+| [Vizient](https://www.vizientinc.com/) | Healthcare | Copilot for domain-specific task | [Case study, 2025](https://blog.langchain.dev/p/3d2cd58c-13a5-4df9-bd84-7d54ed0ed82c/) |

docs/docs/cloud/deployment/cloud.md

@@ -92,28 +92,3 @@ Starting from the `LangGraph Platform` view...
 1. Check/uncheck checkbox to `Automatically update deployment on push to branch`.
     1. Branch creation/deletion and tag creation/deletion events will not trigger an update. Only pushes to an existing branch will trigger an update.
     1. Pushes in quick succession to a branch will not trigger subsequent updates. In the future, this functionality may be changed/improved.
-
-## Add or Remove GitHub Repositories
-
-After installing and authorizing LangChain's `hosted-langserve` GitHub app, repository access for the app can be modified to add new repositories or remove existing repositories. If a new repository is created, it may need to be added explicitly.
-
-1. From the GitHub profile, navigate to `Settings` > `Applications` > `hosted-langserve` > click `Configure`.
-1. Under `Repository access`, select `All repositories` or `Only select repositories`. If `Only select repositories` is selected, new repositories must be explicitly added.
-1. Click `Save`.
-1. When creating a new deployment, the list of GitHub repositories in the dropdown menu will be updated to reflect the repository access changes.
-
-## Whitelisting IP Addresses
-
-All traffic from `LangGraph Platform` deployments created after January 6th 2025 will come through a NAT gateway.
-This NAT gateway will have several static ip addresses depending on the region you are deploying in. Refer to the table below for the list of IP addresses to whitelist:
-
-| US             | EU             |
-|----------------|----------------|
-| 35.197.29.146  | 34.13.192.67   |
-| 34.145.102.123 | 34.147.105.64  |
-| 34.169.45.153  | 34.90.22.166   |
-| 34.82.222.17   | 34.147.36.213  |
-| 35.227.171.135 | 34.32.137.113  | 
-| 34.169.88.30   | 34.91.238.184  |
-| 34.19.93.202   | 35.204.101.241 |
-| 34.19.34.50    | 35.204.48.32   |

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

@@ -1,15 +0,0 @@
-# Prompt Engineering in LangGraph Studio
-
-In LangGraph Studio you can iterate on the prompts used within your graph by utilizing the LangSmith Playground. To do so:
-
-1. Open an existing thread or create a new one.
-2. Within the thread log, any nodes that have made an LLM call will have a "View LLM Runs" button. Clicking this will open a popover with the LLM runs for that node.
-3. Select the LLM run you want to edit. This will open the LangSmith Playground with the selected LLM run.
-
-![Playground in Studio](../img/studio_playground.png){width=1200}
-
-
-
-From here you can edit the prompt, test different model configurations and re-run just this LLM call without having to re-run the entire graph. When you are happy with your changes, you can copy the updated prompt back into your graph.
-
-For more information on how to use the LangSmith Playground, see the [LangSmith Playground documentation](https://docs.smith.langchain.com/prompt_engineering/how_to_guides#playground).

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

@@ -9,19 +9,13 @@ The `useStream()` React hook provides a seamless way to integrate LangGraph into
 Key features:
 
 - Messages streaming: Handle a stream of message chunks to form a complete message
-- Automatic state management for messages, interrupts, loading states, and errors
+- Automatic state management for messages, loading states, and errors
 - Conversation branching: Create alternate conversation paths from any point in the chat history
-- UI-agnostic design: bring your own components and styling
+- UI-agnostic design - bring your own components and styling
 
 Let's explore how to use `useStream()` in your React application.
 
-The `useStream()` provides a solid foundation for creating bespoke chat experiences. For pre-built chat components and interfaces, we also recommend checking out [CopilotKit](https://docs.copilotkit.ai/coagents/quickstart/langgraph) and [assistant-ui](https://www.assistant-ui.com/docs/runtimes/langgraph).
-
-## Installation
-
-```bash
-npm install @langchain/langgraph-sdk @langchain/core
-```
+The `useStream()` provides a solid foundation for creating bespoke chat experiences. For pre-built chat components and interfaces, we recommend checking out [CopilotKit](https://docs.copilotkit.ai/coagents/quickstart/langgraph) and [assistant-ui](https://www.assistant-ui.com/docs/runtimes/langgraph).
 
 ## Example
 
@@ -64,7 +58,9 @@ export default function App() {
             Stop
           </button>
         ) : (
-          <button keytype="submit">Send</button>
+          <button key="submit" type="submit">
+            Send
+          </button>
         )}
       </form>
     </div>
@@ -78,7 +74,6 @@ The `useStream()` hook takes care of all the complex state management behind the
 
 - Thread state management
 - Loading and error states
-- Interrupts
 - Message handling and updates
 - Branching support
 
@@ -132,9 +127,9 @@ We recommend storing the `threadId` in your URL's query parameters to let users
 
 ### Messages Handling
 
-The `useStream()` hook will keep track of the message chunks received from the server and concatenate them together to form a complete message. The completed message chunks can be retrieved via the `messages` property.
+To enable messages handling, you need to pass the `messagesKey` option to the `useStream()` hook. 
 
-By default, the `messagesKey` is set to `messages`, where it will append the new messages chunks to `values["messages"]`. If you store messages in a different key, you can change the value of `messagesKey`.
+When enabled, the `useStream()` hook will keep track of the message chunks received from the server and concatenate them together to form a complete message. The completed message chunks can be retrieved via the `messages` property.
 
 ```tsx
 import type { Message } from "@langchain/langgraph-sdk";
@@ -157,49 +152,9 @@ export default function HomePage() {
 }
 ```
 
-Under the hood, the `useStream()` hook will use the `streamMode: "messages-key"` to receive a stream of messages (i.e. individual LLM tokens) from any LangChain chat model invocations inside your graph nodes. Learn more about messages streaming in the [How to stream messages from your graph](./stream_messages.md) guide.
+### Branching Support
 
-### Interrupts
-
-The `useStream()` hook exposes the `interrupt` property, which will be filled with the last interrupt from the thread. You can use interrupts to:
-
-- Render a confirmation UI before executing a node
-- Wait for human input, allowing agent to ask the user with clarifying questions
-
-Learn more about interrupts in the [How to handle interrupts](../../how-tos/human_in_the_loop/wait-user-input.ipynb) guide.
-
-```tsx
-const thread = useStream<
-  { messages: Message[] },
-  { InterruptType: string }
->({
-  apiUrl: "http://localhost:2024",
-  assistantId: "agent",
-  messagesKey: "messages",
-});
-
-if (thread.interrupt) {
-  return (
-    <div>
-      Interrupted! {thread.interrupt.value}
-
-      <button
-        type="button"
-        onClick={() => {
-          // `resume` can be any value that the agent accepts
-          thread.submit(undefined, { command: { resume: true } });
-        }}
-      >
-        Resume
-      </button>
-    </div>
-  );
-}
-```
-
-### Branching
-
-For each message, you can use `getMessagesMetadata()` to get the first checkpoint from which the message has been first seen. You can then create a new run from the checkpoint preceding the first seen checkpoint to create a new branch in a thread.
+To enable branching, you need to enable messages handling. Pass the `messagesKey` option to the `useStream()` hook. For each message, you can use `getMessagesMetadata()` to get the first checkpoint from which the message has been first seen. You can then create a new run from the checkpoint preceding the first seen checkpoint to create a new branch in a thread.
 
 A branch can be created in following ways:
 
@@ -207,12 +162,23 @@ A branch can be created in following ways:
 2. Request a regeneration of a previous assistant message.
 
 ```tsx
+/* eslint-disable @typescript-eslint/no-floating-promises */
 "use client";
 
 import type { Message } from "@langchain/langgraph-sdk";
 import { useStream } from "@langchain/langgraph-sdk/react";
+import {
+  Annotation,
+  MessagesAnnotation,
+  type StateType,
+  type UpdateType,
+} from "@langchain/langgraph/web";
 import { useState } from "react";
 
+const AgentState = Annotation.Root({
+  ...MessagesAnnotation.spec,
+});
+
 function BranchSwitcher({
   branch,
   branchOptions,
@@ -290,7 +256,10 @@ function EditMessage({
 }
 
 export default function App() {
-  const thread = useStream({
+  const thread = useStream<
+    StateType<typeof AgentState.spec>,
+    UpdateType<typeof AgentState.spec>
+  >({
     apiUrl: "http://localhost:2024",
     assistantId: "agent",
     messagesKey: "messages",
@@ -313,7 +282,7 @@ export default function App() {
                   onEdit={(message) =>
                     thread.submit(
                       { messages: [message] },
-                      { checkpoint: parentCheckpoint },
+                      { checkpoint: parentCheckpoint }
                     )
                   }
                 />
@@ -368,11 +337,13 @@ export default function App() {
 }
 ```
 
-For advanced use cases you can use the `experimental_branchTree` property to get the tree representation of the thread, which can be used to render branching controls for non-message based graphs.
-
 ### TypeScript
 
-The `useStream()` hook is friendly for apps written in TypeScript and you can specify types for the state to get better type safety and IDE support.
+The `useStream()` hook is fully typed to help catch errors early and provide better IDE support. You can specify types for:
+
+- State shape
+- Update format
+- Custom events
 
 ```tsx
 // Define your types
@@ -381,44 +352,25 @@ type State = {
   context?: Record<string, unknown>;
 };
 
+type Update = {
+  messages: Message[] | Message;
+  context?: Record<string, unknown>;
+};
+
+type CustomEvent = {
+  type: "progress" | "debug";
+  payload: unknown;
+};
+
 // Use them with the hook
-const thread = useStream<State>({
+const thread = useStream<State, Update, CustomEvent>({
   apiUrl: "http://localhost:2024",
   assistantId: "agent",
   messagesKey: "messages",
 });
 ```
 
-You can also optionally specify types for different scenarios, such as:
-
-- `ConfigurableType`: Type for the `config.configurable` property (default: `Record<string, unknown>`)
-- `InterruptType`: Type for the interrupt value - i.e. contents of `interrupt(...)` function (default: `unknown`)
-- `CustomEventType`: Type for the custom events (default: `unknown`)
-- `UpdateType`: Type for the submit function (default: `Partial<State>`)
-
-```tsx
-
-const thread = useStream<State, {
-  UpdateType: {
-    messages: Message[] | Message;
-    context?: Record<string, unknown>;
-  };
-  InterruptType: string;
-  CustomEventType: {
-    type: "progress" | "debug";
-    payload: unknown;
-  };
-  ConfigurableType: {
-    model: string;
-  };
-}>({
-  apiUrl: "http://localhost:2024",
-  assistantId: "agent",
-  messagesKey: "messages",
-});
-```
-
-If you're using LangGraph.js, you can also reuse your graph's annotation types. However, make sure to only import the types of the annotation schema in order to avoid importing the entire LangGraph.js runtime (i.e. via `import type { ... }` directive).
+If you're using LangGraph.js, you can reuse your graph's annotation types:
 
 ```tsx
 import {
@@ -430,12 +382,12 @@ import {
 
 const AgentState = Annotation.Root({
   ...MessagesAnnotation.spec,
-  context: Annotation<string>(),
+  context: Annotation.Optional(Annotation.Any()),
 });
 
 const thread = useStream<
   StateType<typeof AgentState.spec>,
-  { UpdateType: UpdateType<typeof AgentState.spec> }
+  UpdateType<typeof AgentState.spec>
 >({
   apiUrl: "http://localhost:2024",
   assistantId: "agent",
@@ -451,7 +403,7 @@ The `useStream()` hook provides several callback options to help you respond to
 - `onFinish`: Called when the stream is finished.
 - `onUpdateEvent`: Called when an update event is received.
 - `onCustomEvent`: Called when a custom event is received. See [Custom events](../../concepts/streaming.md#custom) to learn how to stream custom events.
-- `onMetadataEvent`: Called when a metadata event is received, which contains the Run ID and Thread ID.
+- `onMetadataEvent`: Called when a metadata event is received.
 
 ## Learn More
 

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

@@ -1,147 +1,142 @@
-# Using Webhooks
+# Use Webhooks
 
-When working with LangGraph Cloud, you may want to use webhooks to receive updates after an API call completes. Webhooks are useful for triggering actions in your service once a run has finished processing. To implement this, you need to expose an endpoint that can accept `POST` requests and pass this endpoint as a `webhook` parameter in your API request.
+You may wish to use webhooks in your client, especially when using async streams in case you want to update something in your service once the API call to LangGraph Cloud has finished running. To do so, you will need to expose an endpoint that can accept POST requests, and then pass it to your API request in the "webhook" parameter.
 
-Currently, the SDK does not provide built-in support for defining webhook endpoints, but you can specify them manually using API requests.
+Currently, the SDK has not exposed this endpoint but you can access it through curl commands as follows.
 
-## Supported Endpoints
+The following endpoints accept `webhook` as a parameter: 
 
-The following API endpoints accept a `webhook` parameter:
+- Create Run -> POST /thread/{thread_id}/runs
+- Create Thread Cron -> POST /thread/{thread_id}/runs/crons
+- Stream Run -> POST /thread/{thread_id}/runs/stream
+- Wait Run -> POST /thread/{thread_id}/runs/wait
+- Create Cron -> POST /runs/crons
+- Stream Run Stateless -> POST /runs/stream
+- Wait Run Stateless -> POST /runs/wait
 
-| Operation | HTTP Method | Endpoint |
-|-----------|------------|----------|
-| Create Run | `POST` | `/thread/{thread_id}/runs` |
-| Create Thread Cron | `POST` | `/thread/{thread_id}/runs/crons` |
-| Stream Run | `POST` | `/thread/{thread_id}/runs/stream` |
-| Wait Run | `POST` | `/thread/{thread_id}/runs/wait` |
-| Create Cron | `POST` | `/runs/crons` |
-| Stream Run Stateless | `POST` | `/runs/stream` |
-| Wait Run Stateless | `POST` | `/runs/wait` |
+In this example, we will show calling a webhook after streaming a run. 
 
-In this guide, we’ll show how to trigger a webhook after streaming a run.
+## Setup
 
-## Setting Up Your Assistant and Thread
-
-Before making API calls, set up your assistant and thread.
+First, let's setup our assistant and thread:
 
 === "Python"
-```python
-from langgraph_sdk import get_client
 
-client = get_client(url=<DEPLOYMENT_URL>)
-assistant_id = "agent"
-thread = await client.threads.create()
-print(thread)
-```
+    ```python
+    from langgraph_sdk import get_client
 
-=== "JavaScript"
-```js
-import { Client } from "@langchain/langgraph-sdk";
+    client = get_client(url=<DEPLOYMENT_URL>)
+    # Using the graph deployed with the name "agent"
+    assistant_id = "agent"
+    # create thread
+    thread = await client.threads.create()
+    print(thread)
+    ```
 
-const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
-const assistantID = "agent";
-const thread = await client.threads.create();
-console.log(thread);
-```
+=== "Javascript"
+
+    ```js
+    import { Client } from "@langchain/langgraph-sdk";
+
+    const client = new Client({ apiUrl: <DEPLOYMENT_URL> });
+    // Using the graph deployed with the name "agent"
+    const assistantID = "agent";
+    // create thread
+    const thread = await client.threads.create();
+    console.log(thread);
+    ```
 
 === "CURL"
-```bash
-curl --request POST \
-    --url <DEPLOYMENT_URL>/assistants/search \
-    --header 'Content-Type: application/json' \
-    --data '{ "limit": 10, "offset": 0 }' | jq -c 'map(select(.config == null or .config == {})) | .[0]' && \
-curl --request POST \
-    --url <DEPLOYMENT_URL>/threads \
-    --header 'Content-Type: application/json' \
-    --data '{}'
-```
 
-### Example Response
-```json
-{
-    "thread_id": "9dde5490-2b67-47c8-aa14-4bfec88af217",
-    "created_at": "2024-08-30T23:07:38.242730+00:00",
-    "updated_at": "2024-08-30T23:07:38.242730+00:00",
-    "metadata": {},
-    "status": "idle",
-    "config": {},
-    "values": null
-}
-```
+    ```bash
+    curl --request POST \
+        --url <DEPLOYMENT_URL>/assistants/search \
+        --header 'Content-Type: application/json' \
+        --data '{
+            "limit": 10,
+            "offset": 0
+        }' | jq -c 'map(select(.config == null or .config == {})) | .[0]' && \
+    curl --request POST \
+        --url <DEPLOYMENT_URL>/threads \
+        --header 'Content-Type: application/json' \
+        --data '{}'
+    ```
 
-## Using a Webhook with a Graph Run
+Output:
 
-To use a webhook, specify the `webhook` parameter in your API request. When the run completes, LangGraph Cloud sends a `POST` request to the specified webhook URL.
+    {
+        'thread_id': '9dde5490-2b67-47c8-aa14-4bfec88af217', 
+        'created_at': '2024-08-30T23:07:38.242730+00:00', 
+        'updated_at': '2024-08-30T23:07:38.242730+00:00', 
+        'metadata': {}, 
+        'status': 'idle', 
+        'config': {}, 
+        'values': None
+    }
 
-For example, if your server listens for webhook events at `https://my-server.app/my-webhook-endpoint`, include this in your request:
+## 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`:
 
 === "Python"
-```python
-input = { "messages": [{ "role": "user", "content": "Hello!" }] }
 
-async for chunk in client.runs.stream(
-    thread_id=thread["thread_id"],
-    assistant_id=assistant_id,
-    input=input,
-    stream_mode="events",
-    webhook="https://my-server.app/my-webhook-endpoint"
-):
-    pass
-```
+    ```python
+    # create input
+    input = { "messages": [{ "role": "user", "content": "Hello!" }] }
 
-=== "JavaScript"
-```js
-const input = { messages: [{ role: "human", content: "Hello!" }] };
+    async for chunk in client.runs.stream(
+        thread_id=thread["thread_id"],
+        assistant_id=assistant_id,
+        input=input,
+        stream_mode="events",
+        webhook="https://my-server.app/my-webhook-endpoint"
+    ):
+        # Do something with the stream output
+        pass
+    ```
 
-const streamResponse = client.runs.stream(
-  thread["thread_id"],
-  assistantID,
-  {
-    input: input,
-    webhook: "https://my-server.app/my-webhook-endpoint"
-  }
-);
+=== "Javascript"
 
-for await (const chunk of streamResponse) {
-  // Handle stream output
-}
-```
+    ```js
+    // create input
+    const input = { messages: [{ role: "human", content: "Hello!" }] };
+
+    // stream events
+    const streamResponse = client.runs.stream(
+      thread["thread_id"],
+      assistantID,
+      {
+        input: input,
+        webhook: "https://my-server.app/my-webhook-endpoint"
+      }
+    );
+    for await (const chunk of streamResponse) {
+      // Do something with the stream output
+    }
+    ```
 
 === "CURL"
-```bash
-curl --request POST \
-    --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
-    --header 'Content-Type: application/json' \
-    --data '{
-        "assistant_id": <ASSISTANT_ID>,
-        "input": {"messages": [{"role": "user", "content": "Hello!"}]},
-        "webhook": "https://my-server.app/my-webhook-endpoint"
-    }'
+
+    ```bash
+    curl --request POST \
+        --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/stream \
+        --header 'Content-Type: application/json' \
+        --data '{
+            "assistant_id": <ASSISTANT_ID>,
+            "input" : {"messages":[{"role": "user", "content": "Hello!"}]},
+            "webhook": "https://my-server.app/my-webhook-endpoint"
+        }'
+    ```
+
+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=...
 ```
 
-## Webhook Payload
-
-LangGraph Cloud sends webhook notifications in the format of a [Run](../../concepts/langgraph_server.md/#runs). See the [API Reference](https://langchain-ai.github.io/langgraph/cloud/reference/api/api_ref.html#model/run) for details. The request payload includes run input, configuration, and other metadata in the `kwargs` field.
-
-## Securing Webhooks
-
-To ensure only authorized requests hit your webhook endpoint, consider adding a security token as a query parameter:
-
-```
-https://my-server.app/my-webhook-endpoint?token=YOUR_SECRET_TOKEN
-```
-
-Your server should extract and validate this token before processing requests.
-
-## Testing Webhooks
-
-You can test your webhook using online services like:
-
-- **[Beeceptor](https://beeceptor.com/)** – Quickly create a test endpoint and inspect incoming webhook payloads.
-- **[Webhook.site](https://webhook.site/)** – View, debug, and log incoming webhook requests in real time.
-
-These tools help you verify that LangGraph Cloud is correctly triggering and sending webhooks to your service.
-
----
-
-By following these steps, you can integrate webhooks into your LangGraph Cloud workflow, automating actions based on completed runs.
+The server should then extract the token from the request's parameters and validate it before processing the payload.

docs/docs/cloud/reference/cli.md

@@ -51,7 +51,6 @@ The LangGraph CLI requires a JSON configuration file with the following keys:
     | <span style="white-space: nowrap;">`node_version`</span>     | Specify `node_version: 20` to use LangGraph.js.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
     | <span style="white-space: nowrap;">`pip_config_file`</span>  | Path to `pip` config file.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
     | <span style="white-space: nowrap;">`dockerfile_lines`</span> | Array of additional lines to add to Dockerfile following the import from parent image.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-    | <span style="white-space: nowrap;">`http`</span>            | HTTP server configuration with the following fields: <ul><li>`app`: Path to custom Starlette/FastAPI app (e.g., `"./src/agent/webapp.py:app"`). See [custom routes guide](../../how-tos/http/custom_routes.md).</li><li>`disable_assistants`: Disable `/assistants` routes</li><li>`disable_threads`: Disable `/threads` routes</li><li>`disable_runs`: Disable `/runs` routes</li><li>`disable_store`: Disable `/store` routes</li><li>`disable_meta`: Disable `/ok`, `/info`, `/metrics`, and `/docs` routes</li><li>`cors`: CORS configuration with fields for `allow_origins`, `allow_methods`, `allow_headers`, etc.</li></ul> |
 
 === "JS"
 

docs/docs/cloud/reference/env_var.md

@@ -2,12 +2,6 @@
 
 The LangGraph Cloud Server supports specific environment variables for configuring a deployment.
 
-## `DD_API_KEY`
-
-Specify `DD_API_KEY` (your [Datadog API Key](https://docs.datadoghq.com/account_management/api-app-keys/)) to automatically enable Datadog tracing for the deployment. Specify other [`DD_*` environment variables](https://ddtrace.readthedocs.io/en/stable/configuration.html) to configure the tracing instrumentation.
-
-If `DD_API_KEY` is specified, the application process is wrapped in the [`ddtrace-run` command](https://ddtrace.readthedocs.io/en/stable/installation_quickstart.html). Other `DD_*` environment variables (e.g. `DD_SITE`, `DD_ENV`, `DD_SERVICE`, `DD_TRACE_ENABLED`) are typically needed to properly configure the tracing instrumentation. See [`DD_*` environment variables](https://ddtrace.readthedocs.io/en/stable/configuration.html) for more details.
-
 ## `LANGCHAIN_TRACING_SAMPLING_RATE`
 
 Sampling rate for traces sent to LangSmith. Valid values: Any float between `0` and `1`.

docs/docs/concepts/breakpoints.md

@@ -83,7 +83,7 @@ node at a time or if you want to pause the graph execution at specific nodes.
 
 ### `NodeInterrupt` exception
 
-We recommend that you [**use the `interrupt` function instead**][langgraph.types.interrupt] of the `NodeInterrupt` exception if you're trying to implement
+We recommend that you [**use the `interrupt` function instead**](#the-interrupt-function) of the `NodeInterrupt` exception if you're trying to implement
 [human-in-the-loop](./human_in_the_loop.md) workflows. The `interrupt` function is easier to use and more flexible.
 
 ??? node "`NodeInterrupt` exception"

docs/docs/concepts/deployment_options.md

@@ -30,7 +30,7 @@ The guide below will explain the differences between the deployment options.
 
 !!! warning "Note"
 
-    The LangGraph Platform Deployments view is optionally available for Self-Hosted Enterprise LangGraph deployments. With one click, self-hosted LangGraph deployments can be deployed in the same Kubernetes cluster where a self-hosted LangSmith instance is deployed.
+    The LangGraph Platform Deployments view (within LangSmith SaaS and self-hosted LangSmith) is not available for Self-Hosted Enterprise LangGraph deployments. Self-hosted LangGraph deployments are managed externally from LangSmith (e.g. there is no UI to manage these deployments).
 
 With a Self-Hosted Enterprise deployment, you are responsible for managing the infrastructure, including setting up and maintaining required databases and Redis instances.
 
@@ -49,7 +49,7 @@ For more information, please see:
 
 !!! warning "Note"
 
-    The LangGraph Platform Deployments view is optionally available for Self-Hosted Lite LangGraph deployments. With one click, self-hosted LangGraph deployments can be deployed in the same Kubernetes cluster where a self-hosted LangSmith instance is deployed.
+    The LangGraph Platform Deployments view (within LangSmith SaaS and self-hosted LangSmith) is not available for Self-Hosted Lite LangGraph deployments. Self-hosted LangGraph deployments are managed externally from LangSmith (e.g. there is no UI to manage these deployments).
 
 The Self-Hosted Lite deployment option is a free (up to 1 million nodes executed per year), limited version of LangGraph Platform that you can run locally or in a self-hosted manner.
 

docs/docs/concepts/durable_execution.md

@@ -1,152 +0,0 @@
-# Durable Execution
-
-**Durable execution** is a technique in which a process or workflow saves its progress at key points, allowing it to pause and later resume exactly where it left off. This is particularly useful in scenarios that require [human-in-the-loop](./human_in_the_loop.md), where users can inspect, validate, or modify the process before continuing, and in long-running tasks that might encounter interruptions or errors (e.g., calls to an LLM timing out). By preserving completed work, durable execution enables a process to resume without reprocessing previous steps -- even after a significant delay (e.g., a week later). 
-
-LangGraph's built-in [persistence](./persistence.md) layer provides durable execution for workflows, ensuring that the state of each execution step is saved to a durable store. This capability guarantees that if a workflow is interrupted -- whether by a system failure or for [human-in-the-loop](./human_in_the_loop.md) interactions -- it can be resumed from its last recorded state.
-
-!!! tip
-
-    If you are using LangGraph with a checkpointer, you already have durable execution enabled. You can pause and resume workflows at any point, even after interruptions or failures.
-    To make the most of durable execution, ensure that your workflow is designed to be [deterministic](#determinism-and-consistent-replay) and [idempotent](#determinism-and-consistent-replay) and wrap any side effects or non-deterministic operations inside [tasks](./functional_api.md#task). You can use [tasks](./functional_api.md#task) from both the [StateGraph (Graph API)](./low_level.md) and the [Functional API](./functional_api.md).
-
-## Requirements
-
-To leverage durable execution in LangGraph, you need to:
-
-1. Enable [persistence](./persistence.md) in your workflow by specifying a [checkpointer](./persistence.md#checkpointer-libraries) that will save workflow progress.
-2. Specify a [thread identifier](./persistence.md#threads) when executing a workflow. This will track the execution history for a particular instance of the workflow.
-3. Wrap any non-deterministic operations (e.g., random number generation) or operations with side effects (e.g., file writes, API calls) inside [tasks][langgraph.func.task] to ensure that when a workflow is resumed, these operations are not repeated for the particular run, and instead their results are retrieved from the persistence layer. For more information, see [Determinism and Consistent Replay](#determinism-and-consistent-replay).
-
-## Determinism and Consistent Replay
-
-When you resume a workflow run, the code does **NOT** resume from the **same line of code** where execution stopped; instead, it will identify an appropriate [starting point](#starting-points-for-resuming-workflows) from which to pick up where it left off. This means that the workflow will replay all steps from the [starting point](#starting-points-for-resuming-workflows) until it reaches the point where it was stopped.
-
-As a result, when you are writing a workflow for durable execution, you must wrap any non-deterministic operations (e.g., random number generation) and any operations with side effects (e.g., file writes, API calls) inside [tasks](./functional_api.md#task) or [nodes](./low_level.md#nodes).
-
-To ensure that your workflow is deterministic and can be consistently replayed, follow these guidelines:
-
-- **Avoid Repeating Work**:  If a [node](./low_level.md#nodes) contains multiple operations with side effects (e.g., logging, file writes, or network calls), wrap each operation in a separate **task**. This ensures that when the workflow is resumed, the operations are not repeated, and their results are retrieved from the persistence layer.
-- **Encapsulate Non-Deterministic Operations:**  Wrap any code that might yield non-deterministic results (e.g., random number generation) inside **tasks** or **nodes**. This ensures that, upon resumption, the workflow follows the exact recorded sequence of steps with the same outcomes.
-- **Use Idempotent Operations**: When possible ensure that side effects (e.g., API calls, file writes) are idempotent. This means that if an operation is retried after a failure in the workflow, it will have the same effect as the first time it was executed. This is particularly important for operations that result in data writes. In the event that a **task** starts but fails to complete successfully, the workflow's resumption will re-run the **task**, relying on recorded outcomes to maintain consistency. Use idempotency keys or verify existing results to avoid unintended duplication, ensuring a smooth and predictable workflow execution.
-
-For some examples of pitfalls to avoid, see the [Common Pitfalls](./functional_api.md#common-pitfalls) section in the functional API, which shows
-how to structure your code using **tasks** to avoid these issues. The same principles apply to the [StateGraph (Graph API)][langgraph.graph.state.StateGraph].
-
-## Using tasks in nodes
-
-If a [node](./low_level.md#nodes) contains multiple operations, you may find it easier to convert each operation into a **task** rather than refactor the operations into individual nodes.
-
-=== "Original"
-
-    ```python
-    from typing import NotRequired
-    from typing_extensions import TypedDict
-    import uuid
-
-    from langgraph.checkpoint.memory import MemorySaver
-    from langgraph.graph import StateGraph, START, END
-    import requests
-
-    # Define a TypedDict to represent the state
-    class State(TypedDict):
-        url: str
-        result: NotRequired[str]
-
-    def call_api(state: State):
-        """Example node that makes an API request."""
-        # highlight-next-line
-        result = requests.get(state['url']).text[:100]  # Side-effect
-        return {
-            "result": result
-        }
-
-    # Create a StateGraph builder and add a node for the call_api function
-    builder = StateGraph(State)
-    builder.add_node("call_api", call_api)
-
-    # Connect the start and end nodes to the call_api node
-    builder.add_edge(START, "call_api")
-    builder.add_edge("call_api", END)
-
-    # Specify a checkpointer
-    checkpointer = MemorySaver()
-
-    # Compile the graph with the checkpointer
-    graph = builder.compile(checkpointer=checkpointer)
-
-    # Define a config with a thread ID.
-    thread_id = uuid.uuid4()
-    config = {"configurable": {"thread_id": thread_id}}
-
-    # Invoke the graph
-    graph.invoke({"url": "https://www.example.com"}, config)
-    ```
-
-=== "With task"
-
-    ```python
-    from typing import NotRequired
-    from typing_extensions import TypedDict
-    import uuid
-
-    from langgraph.checkpoint.memory import MemorySaver
-    from langgraph.func import task
-    from langgraph.graph import StateGraph, START, END
-    import requests
-
-    # Define a TypedDict to represent the state
-    class State(TypedDict):
-        urls: list[str]
-        result: NotRequired[list[str]]
-
-
-    @task
-    def _make_request(url: str):
-        """Make a request."""
-        # highlight-next-line
-        return requests.get(url).text[:100]
-
-    def call_api(state: State):
-        """Example node that makes an API request."""
-        # highlight-next-line
-        requests = [_make_request(url) for url in state['urls']]
-        results = [request.result() for request in requests]
-        return {
-            "results": results
-        }
-
-    # Create a StateGraph builder and add a node for the call_api function
-    builder = StateGraph(State)
-    builder.add_node("call_api", call_api)
-
-    # Connect the start and end nodes to the call_api node
-    builder.add_edge(START, "call_api")
-    builder.add_edge("call_api", END)
-
-    # Specify a checkpointer
-    checkpointer = MemorySaver()
-
-    # Compile the graph with the checkpointer
-    graph = builder.compile(checkpointer=checkpointer)
-
-    # Define a config with a thread ID.
-    thread_id = uuid.uuid4()
-    config = {"configurable": {"thread_id": thread_id}}
-
-    # Invoke the graph
-    graph.invoke({"urls": ["https://www.example.com"]}, config)
-    ```
-
-## Resuming Workflows
-
-Once you have enabled durable execution in your workflow, you can resume execution for the following scenarios:
-
-- **Pausing and Resuming Workflows:** Use the [interrupt][langgraph.types.interrupt] function to pause a workflow at specific points and the [Command][langgraph.types.Command] primitive to resume it with updated state. See [**Human-in-the-Loop**](./human_in_the_loop.md) for more details.
-- **Recovering from Failures:** Automatically resume workflows from the last successful checkpoint after an exception (e.g., LLM provider outage). This involves executing the workflow with the same thread identifier by providing it with a `None` as the input value (see this [example](./functional_api.md#resuming-after-an-error) with the functional API).
-
-## Starting Points for Resuming Workflows
-
-* If you're using a [StateGraph (Graph API)][langgraph.graph.state.StateGraph], the starting point is the beginning of the [**node**](./low_level.md#nodes) where execution stopped. 
-* If you're making a subgraph call inside a node, the starting point will be the **parent** node that called the subgraph that was halted.
-Inside the subgraph, the starting point will be the specific [**node**](./low_level.md#nodes) where execution stopped.
-* If you're using the Functional API, the starting point is the beginning of the [**entrypoint**](./functional_api.md#entrypoint) where execution stopped.

docs/docs/concepts/faq.md

@@ -62,9 +62,3 @@ Yes! You can use LangGraph with any LLMs. The main reason we use LLMs that suppo
 ## Does LangGraph work with OSS LLMs?
 
 Yes! LangGraph is totally ambivalent to what LLMs are used under the hood. The main reason we use closed LLMs in most of the tutorials is that they seamlessly support tool calling, while OSS LLMs often don't. But tool calling is not necessary (see [this section](#does-langgraph-work-with-llms-that-dont-support-tool-calling)) so you can totally use LangGraph with OSS LLMs.
-
-## Can I use LangGraph Studio without logging to LangSmith
-
-Yes! You can use the [development version of LangGraph Server](../tutorials/langgraph-platform/local-server.md) to run the backend locally.
-This will connect to the studio frontend hosted as part of LangSmith.
-If you set an environment variable of `LANGSMITH_TRACING=false` then no traces will be sent to LangSmith.

docs/docs/concepts/functional_api.md

@@ -1,5 +1,8 @@
 # Functional API
 
+!!! warning "Beta"
+    The Functional API is currently in **beta** and is subject to change. Please [report any issues](https://github.com/langchain-ai/langgraph/issues) or feedback to the LangGraph team.
+
 ## Overview
 
 The **Functional API** allows you to add LangGraph's key features -- [persistence](./persistence.md), [memory](./memory.md), [human-in-the-loop](./human_in_the_loop.md), and [streaming](./streaming.md) — to your applications with minimal changes to your existing code.
@@ -829,8 +832,7 @@ from langgraph.checkpoint.memory import MemorySaver
 from langgraph.func import entrypoint, task
 from langgraph.types import StreamWriter
 
-# This variable is just used for demonstration purposes to simulate a network failure.
-# It's not something you will have in your actual code.
+# Global variable to track the number of attempts
 attempts = 0
 
 @task()

docs/docs/concepts/human_in_the_loop.md

@@ -647,15 +647,19 @@ def node_in_parent_graph(state: State):
       This will print out
 
       ```pycon
+      --- First invocation ---
+      In parent node: {'foo': 'bar'}
       Entered `parent_node` a total of 1 times
       Entered `node_in_subgraph` a total of 1 times
       Entered human_node in sub-graph a total of 1 times
-      {'__interrupt__': (Interrupt(value='what is your name?', resumable=True, ns=['parent_node:4c3a0248-21f0-1287-eacf-3002bc304db4', 'human_node:2fe86d52-6f70-2a3f-6b2f-b1eededd6348'], when='during'),)}
+      {'__interrupt__': (Interrupt(value='what is your name?', resumable=True, ns=['parent_node:0b23d72f-aaba-0329-1a59-ca4f3c8bad3b', 'human_node:25df717c-cb80-57b0-7410-44e20aac8f3c'], when='during'),)}
+
       --- Resuming ---
+      In parent node: {'foo': 'bar'}
       Entered `parent_node` a total of 2 times
       Entered human_node in sub-graph a total of 2 times
       Got an answer of 35
-      {'parent_node': {'state_counter': 1}}
+      {'parent_node': None} 
       ```
 
 

docs/docs/concepts/index.md

@@ -7,7 +7,7 @@ description: Conceptual Guide for LangGraph
 
 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 [Quickstart](../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.
+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).
 
@@ -28,9 +28,7 @@ The conceptual guide does not cover step-by-step instructions or specific implem
 - [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.
-- [Functional API](functional_api.md): `@entrypoint` and `@task` decorators that allow you to add LangGraph functionality to an existing codebase.
-- [Durable Execution](durable_execution.md): LangGraph's built-in [persistence](./persistence.md) layer provides durable execution for workflows, ensuring that the state of each execution step is saved to a durable store. 
-- [Pregel](pregel.md): Pregel is LangGraph's runtime, which is responsible for managing the execution of LangGraph applications.
+- [Functional API (beta)](functional_api.md): An alternative to [Graph API (StateGraph)](low_level.md#stategraph) for development in LangGraph.
 - [FAQ](faq.md): Frequently asked questions about LangGraph.
 
 ## LangGraph Platform
@@ -48,7 +46,6 @@ The LangGraph Platform offers a few different deployment options described in th
 
 - [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.
 - [Platform Architecture](./platform_architecture.md): A high-level overview of the architecture of the LangGraph Platform.
-- [Scalability and Resilience](./scalability_and_resilience.md): LangGraph Platform is designed to be scalable and resilient. This document explains how the platform achieves this.
 - [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.

docs/docs/concepts/langgraph_cloud.md

@@ -80,22 +80,6 @@ A high-level diagram of a Cloud SaaS deployment.
 
 ![diagram](img/langgraph_cloud_architecture.png)
 
-## Whitelisting IP Addresses
-
-All traffic from `LangGraph Platform` deployments created after January 6th 2025 will come through a NAT gateway.
-This NAT gateway will have several static ip addresses depending on the region you are deploying in. Refer to the table below for the list of IP addresses to whitelist:
-
-| US             | EU             |
-|----------------|----------------|
-| 35.197.29.146  | 34.13.192.67   |
-| 34.145.102.123 | 34.147.105.64  |
-| 34.169.45.153  | 34.90.22.166   |
-| 34.82.222.17   | 34.147.36.213  |
-| 35.227.171.135 | 34.32.137.113  | 
-| 34.169.88.30   | 34.91.238.184  |
-| 34.19.93.202   | 35.204.101.241 |
-| 34.19.34.50    | 35.204.48.32   |
-
 ## Related
 
 - [Deployment Options](./deployment_options.md)

docs/docs/concepts/low_level.md

@@ -310,7 +310,7 @@ graph.add_conditional_edges(START, routing_function, {True: "node_b", False: "no
 
 ## `Send`
 
-By default, `Nodes` and `Edges` are defined ahead of time and operate on the same shared state. However, there can be cases where the exact edges are not known ahead of time and/or you may want different versions of `State` to exist at the same time. A common example of this is with [map-reduce](https://langchain-ai.github.io/langgraph/how-tos/map-reduce/) design patterns. In this design pattern, a first node may generate a list of objects, and you may want to apply some other node to all those objects. The number of objects may be unknown ahead of time (meaning the number of edges may not be known) and the input `State` to the downstream `Node` should be different (one for each generated object).
+By default, `Nodes` and `Edges` are defined ahead of time and operate on the same shared state. However, there can be cases where the exact edges are not known ahead of time and/or you may want different versions of `State` to exist at the same time. A common example of this is with `map-reduce` design patterns. In this design pattern, a first node may generate a list of objects, and you may want to apply some other node to all those objects. The number of objects may be unknown ahead of time (meaning the number of edges may not be known) and the input `State` to the downstream `Node` should be different (one for each generated object).
 
 To support this design pattern, LangGraph supports returning [`Send`][langgraph.types.Send] objects from conditional edges. `Send` takes two arguments: first is the name of the node, and second is the state to pass to that node.
 

docs/docs/concepts/multi_agent.md

@@ -112,7 +112,6 @@ In this architecture, agents are defined as graph nodes. Each agent can communic
 ```python
 from typing import Literal
 from langchain_openai import ChatOpenAI
-from langgraph.types import Command
 from langgraph.graph import StateGraph, MessagesState, START, END
 
 model = ChatOpenAI()
@@ -159,7 +158,6 @@ In this architecture, we define agents as nodes and add a supervisor node (LLM)
 ```python
 from typing import Literal
 from langchain_openai import ChatOpenAI
-from langgraph.types import Command
 from langgraph.graph import StateGraph, MessagesState, START, END
 
 model = ChatOpenAI()

docs/docs/concepts/pregel.md

@@ -1,347 +0,0 @@
-# LangGraph's Runtime (Pregel)
-
-[Pregel][langgraph.pregel.Pregel] implements LangGraph's runtime, managing the execution of LangGraph applications.
-
-Compiling a [StateGraph][langgraph.graph.StateGraph] or creating an [entrypoint][langgraph.func.entrypoint] produces a [Pregel][langgraph.pregel.Pregel] instance that can be invoked with input.
-
-This guide explains the runtime at a high level and provides instructions for directly implementing applications with Pregel.
-
-> **Note:** The [Pregel][langgraph.pregel.Pregel] runtime is named after [Google's Pregel algorithm](https://research.google/pubs/pub37252/), which describes an efficient method for large-scale parallel computation using graphs.
-
-## Overview
-
-In LangGraph, Pregel combines [**actors**](https://en.wikipedia.org/wiki/Actor_model) and **channels** into a single application. **Actors** read data from channels and write data to channels. Pregel organizes the execution of the application into multiple steps, following the **Pregel Algorithm**/**Bulk Synchronous Parallel** model.
-
-Each step consists of three phases:
-
-- **Plan**: Determine which **actors** to execute in this step. For example, in the first step, select the **actors** that subscribe to the special **input** channels; in subsequent steps, select the **actors** that subscribe to channels updated in the previous step.
-- **Execution**: Execute all selected **actors** in parallel, until all complete, or one fails, or a timeout is reached. During this phase, channel updates are invisible to actors until the next step.
-- **Update**: Update the channels with the values written by the **actors** in this step.
-
-Repeat until no **actors** are selected for execution, or a maximum number of steps is reached.
-
-## Actors 
-
-An **actor** is a [PregelNode][langgraph.pregel.read.PregelNode]. It subscribes to channels, reads data from them, and writes data to them. It can be thought of as an **actor** in the Pregel algorithm. [PregelNodes][langgraph.pregel.read.PregelNode] implement LangChain's Runnable interface.
-
-## Channels
-
-Channels are used to communicate between actors (PregelNodes). Each channel has a value type, an update type, and an update function – which takes a sequence of updates and modifies the stored value. Channels can be used to send data from one chain to another, or to send data from a chain to itself in a future step. LangGraph provides a number of built-in channels:
-
-### Basic channels: LastValue and Topic
-
-- [LastValue][langgraph.channels.LastValue]: The default channel, stores the last value sent to the channel, useful for input and output values, or for sending data from one step to the next.
-- [Topic][langgraph.channels.Topic]: A configurable PubSub Topic, useful for sending multiple values between **actors**, or for accumulating output. Can be configured to deduplicate values or to accumulate values over the course of multiple steps.
-
-### Advanced channels: Context and BinaryOperatorAggregate
-
-- `Context`: exposes the value of a context manager, managing its lifecycle. Useful for accessing external resources that require setup and/or teardown; e.g., `client = Context(httpx.Client)`.
-- [BinaryOperatorAggregate][langgraph.channels.BinaryOperatorAggregate]: stores a persistent value, updated by applying a binary operator to the current value and each update sent to the channel, useful for computing aggregates over multiple steps; e.g.,`total = BinaryOperatorAggregate(int, operator.add)`
-
-## Examples
-
-While most users will interact with Pregel through the [StateGraph][langgraph.graph.StateGraph] API or 
-the [entrypoint][langgraph.func.entrypoint] decorator, it is possible to interact with Pregel directly.
-
-Below are a few different examples to give you a sense of the Pregel API.
-
-=== "Single node"
-
-    ```python
-
-    from langgraph.channels import EphemeralValue
-    from langgraph.pregel import Pregel, Channel 
-
-    node1 = (
-        Channel.subscribe_to("a")
-        | (lambda x: x + x)
-        | Channel.write_to("b")
-    )
-
-    app = Pregel(
-        nodes={"node1": node1},
-        channels={
-            "a": EphemeralValue(str),
-            "b": EphemeralValue(str),
-        },
-        input_channels=["a"],
-        output_channels=["b"],
-    )
-
-    app.invoke({"a": "foo"})
-    ```
-
-    ```con
-    {'b': 'foofoo'}
-    ```
-
-=== "Multiple nodes"
-
-    ```python
-    from langgraph.channels import LastValue, EphemeralValue
-    from langgraph.pregel import Pregel, Channel 
-
-    node1 = (
-        Channel.subscribe_to("a")
-        | (lambda x: x + x)
-        | Channel.write_to("b")
-    )
-
-    node2 = (
-        Channel.subscribe_to("b")
-        | (lambda x: x + x)
-        | Channel.write_to("c")
-    )
-
-
-    app = Pregel(
-        nodes={"node1": node1, "node2": node2},
-        channels={
-            "a": EphemeralValue(str),
-            "b": LastValue(str),
-            "c": EphemeralValue(str),
-        },
-        input_channels=["a"],
-        output_channels=["b", "c"],
-    )
-
-    app.invoke({"a": "foo"})
-    ```
-
-    ```con
-    {'b': 'foofoo', 'c': 'foofoofoofoo'}
-    ```
-
-=== "Topic"
-
-    ```python
-    from langgraph.channels import EphemeralValue, Topic
-    from langgraph.pregel import Pregel, Channel 
-
-    node1 = (
-        Channel.subscribe_to("a")
-        | (lambda x: x + x)
-        | {
-            "b": Channel.write_to("b"),
-            "c": Channel.write_to("c")
-        }
-    )
-
-    node2 = (
-        Channel.subscribe_to("b")
-        | (lambda x: x + x)
-        | {
-            "c": Channel.write_to("c"),
-        }
-    )
-
-    app = Pregel(
-        nodes={"node1": node1, "node2": node2},
-        channels={
-            "a": EphemeralValue(str),
-            "b": EphemeralValue(str),
-            "c": Topic(str, accumulate=True),
-        },
-        input_channels=["a"],
-        output_channels=["c"],
-    )
-
-    app.invoke({"a": "foo"})
-    ```
-
-    ```pycon
-    {'c': ['foofoo', 'foofoofoofoo']}
-    ```
-
-=== "BinaryOperatorAggregate"
-
-    This examples demonstrates how to use the BinaryOperatorAggregate channel to implement a reducer.
-
-    ```python
-    from langgraph.channels import EphemeralValue, BinaryOperatorAggregate
-    from langgraph.pregel import Pregel, Channel
-
-
-    node1 = (
-        Channel.subscribe_to("a")
-        | (lambda x: x + x)
-        | {
-            "b": Channel.write_to("b"),
-            "c": Channel.write_to("c")
-        }
-    )
-
-    node2 = (
-        Channel.subscribe_to("b")
-        | (lambda x: x + x)
-        | {
-            "c": Channel.write_to("c"),
-        }
-    )
-
-    def reducer(current, update):
-        if current:
-            return current + " | " + "update"
-        else:
-            return update
-
-    app = Pregel(
-        nodes={"node1": node1, "node2": node2},
-        channels={
-            "a": EphemeralValue(str),
-            "b": EphemeralValue(str),
-            "c": BinaryOperatorAggregate(str, operator=reducer),
-        },
-        input_channels=["a"],
-        output_channels=["c"],
-    )
-
-    app.invoke({"a": "foo"})
-    ```
-    
-    
-=== "Cycle"
-
-    This example demonstrates how to introduce a cycle in the graph, by having
-    a chain write to a channel it subscribes to. Execution will continue
-    until a None value is written to the channel.
-
-    ```python
-    from langgraph.channels import EphemeralValue
-    from langgraph.pregel import Pregel, Channel, ChannelWrite, ChannelWriteEntry
-
-    example_node = (
-        Channel.subscribe_to("value")
-        | (lambda x: x + x if len(x) < 10 else None)
-        | ChannelWrite(writes=[ChannelWriteEntry(channel="value", skip_none=True)])
-    )
-
-    app = Pregel(
-        nodes={"example_node": example_node},
-        channels={
-            "value": EphemeralValue(str),
-        },
-        input_channels=["value"],
-        output_channels=["value"],
-    )
-
-    app.invoke({"value": "a"})
-    ```
-
-    ```pycon
-    {'value': 'aaaaaaaaaaaaaaaa'}
-    ```
-
-## High-level API
-
-LangGraph provides two high-level APIs for creating a Pregel application: the [StateGraph (Graph API)](./low_level.md) and the [Functional API](functional_api.md).
-
-
-=== "StateGraph (Graph API)"
-
-    The [StateGraph (Graph API)][langgraph.graph.StateGraph] is a higher-level abstraction that simplifies the creation of Pregel applications. It allows you to define a graph of nodes and edges. When you compile the graph, the StateGraph API automatically creates the Pregel application for you.
-
-    ```python
-    from typing import TypedDict, Optional
-
-    from langgraph.constants import START
-    from langgraph.graph import StateGraph
-
-    class Essay(TypedDict):
-        topic: str
-        content: Optional[str]
-        score: Optional[float]
-
-    def write_essay(essay: Essay):
-        return {
-            "content": f"Essay about {essay['topic']}",
-        }
-
-    def score_essay(essay: Essay):
-        return {
-            "score": 10
-        }
-
-    builder = StateGraph(Essay)
-    builder.add_node(write_essay)
-    builder.add_node(score_essay)
-    builder.add_edge(START, "write_essay")
-
-    # Compile the graph. 
-    # This will return a Pregel instance.
-    graph = builder.compile()
-    ```
-
-    The compiled Pregel instance will be associated with a list of nodes and channels. You can inspect the nodes and channels by printing them.
-
-    ```python
-    print(graph.nodes)
-    ```
-
-    You will see something like this:
-
-    ```pycon 
-    {'__start__': <langgraph.pregel.read.PregelNode at 0x7d05e3ba1810>,
-     'write_essay': <langgraph.pregel.read.PregelNode at 0x7d05e3ba14d0>,
-     'score_essay': <langgraph.pregel.read.PregelNode at 0x7d05e3ba1710>}
-     ```
-
-    ```python
-    print(graph.channels)
-    ```
-
-    You should see something like this
-
-    ```pycon
-    {'topic': <langgraph.channels.last_value.LastValue at 0x7d05e3294d80>,
-     'content': <langgraph.channels.last_value.LastValue at 0x7d05e3295040>,
-     'score': <langgraph.channels.last_value.LastValue at 0x7d05e3295980>,
-     '__start__': <langgraph.channels.ephemeral_value.EphemeralValue at 0x7d05e3297e00>,
-     'write_essay': <langgraph.channels.ephemeral_value.EphemeralValue at 0x7d05e32960c0>,
-     'score_essay': <langgraph.channels.ephemeral_value.EphemeralValue at 0x7d05e2d8ab80>,
-     'branch:__start__:__self__:write_essay': <langgraph.channels.ephemeral_value.EphemeralValue at 0x7d05e32941c0>,
-     'branch:__start__:__self__:score_essay': <langgraph.channels.ephemeral_value.EphemeralValue at 0x7d05e2d88800>,
-     'branch:write_essay:__self__:write_essay': <langgraph.channels.ephemeral_value.EphemeralValue at 0x7d05e3295ec0>,
-     'branch:write_essay:__self__:score_essay': <langgraph.channels.ephemeral_value.EphemeralValue at 0x7d05e2d8ac00>,
-     'branch:score_essay:__self__:write_essay': <langgraph.channels.ephemeral_value.EphemeralValue at 0x7d05e2d89700>,
-     'branch:score_essay:__self__:score_essay': <langgraph.channels.ephemeral_value.EphemeralValue at 0x7d05e2d8b400>,
-     'start:write_essay': <langgraph.channels.ephemeral_value.EphemeralValue at 0x7d05e2d8b280>}
-    ```
-
-=== "Functional API"
-
-    In the [Functional API](functional_api.md), you can use an [`entrypoint`][langgraph.func.entrypoint] to create
-    a Pregel application. The `entrypoint` decorator allows you to define a function that takes input and returns output. 
-
-    ```python
-    from typing import TypedDict, Optional
-
-    from langgraph.checkpoint.memory import InMemorySaver
-    from langgraph.func import entrypoint
-
-    class Essay(TypedDict):
-        topic: str
-        content: Optional[str]
-        score: Optional[float]
-
-
-    checkpointer = InMemorySaver()
-
-    @entrypoint(checkpointer=checkpointer)
-    def write_essay(essay: Essay):
-        return {
-            "content": f"Essay about {essay['topic']}",
-        }
-
-    print("Nodes: ")
-    print(write_essay.nodes)
-    print("Channels: ")
-    print(write_essay.channels)
-    ```
-
-    ```pycon
-    Nodes: 
-    {'write_essay': <langgraph.pregel.read.PregelNode object at 0x7d05e2f9aad0>}
-    Channels: 
-    {'__start__': <langgraph.channels.ephemeral_value.EphemeralValue object at 0x7d05e2c906c0>, '__end__': <langgraph.channels.last_value.LastValue object at 0x7d05e2c90c40>, '__previous__': <langgraph.channels.last_value.LastValue object at 0x7d05e1007280>}
-    ```

docs/docs/concepts/scalability_and_resilience.md

@@ -1,35 +0,0 @@
-# LangGraph Platform: Scalability & Resilience
-
-LangGraph Platform is designed to scale horizontally with your workload. Each instance of the service is stateless, and keeps no resources in memory. The service is designed to gracefully handle new instances being added or removed, including hard shutdown cases.
-
-## Server scalability
-
-As you add more instances to a service, they will share the HTTP load as long as an appropriate load balancer mechanism is placed in front of them. In most deployment modalities we configure a load balancer for the service automatically. In the “self-hosted without control plane” modality it’s your responsibility to add a load balancer. Since the instances are stateless any load balancing strategy will work, no session stickiness is needed, or recommended. Any instance of the server can communicate with any queue instance (through Redis PubSub), meaning that requests to cancel or stream an in-progress run can be handled by any arbitrary instance.
-
-## Queue scalability
-
-As you add more instances to a service, they will increase run throughput linearly, as each instance is configured to handle a set number of concurrent runs (by default 10). Each attempt for each run will be handled by a single instance, with exactly-once semantics enforced through Postgres’s MVCC model (refer to section below for crash resilience details). Attempts that fail due to transient database errors are retried up to 3 times. We do not make use of long-lived transactions or locks, this enables us to make more efficient use of Postgres resources.
-
-## Resilience
-
-While a run is being handled by a queue instance, a periodic heartbeat timestamp will be recorded in Redis by that queue worker.
-
-When a graceful shutdown request is received (SIGINT) an instance enters shutdown mode, which
-
-- stops accepting new HTTP requests
-- gives any in-progress runs a limited number of seconds to finish (if not finished it will be put back in the queue)
-- stops the instance from picking up more runs from the queue
-
-If a hard shutdown occurs, eg. due to a server crash, or an infra failure, any runs that were in progress will be picked up by a periodic sweeper task that looks for in-progress runs that have breached their heartbeat window, which will put them back in the queue for another instance to pick them up.
-
-## Postgres resilience
-
-For deployment modalities where we manage the Postgres database we have periodic backups, continuously replicated standby replicas for automatic failover. Optionally, on request, we can also setup read replicas as well as other advanced failover capabilities.
-
-All communication with Postgres implements retries for retry-able errors. If Postgres is momentarily unavailable, such as during a database restart, most/all traffic should continue to succeed. Prolonged failure of the Postgres instance will switch traffic to the failover replica. If the failover replica also fails before the primary is brought back online the service would become unavailable.
-
-## Redis resilience
-
-All data that requires durable storage is stored in Postgres, not Redis. Redis is used only for ephemeral metadata, and communication between instances. Refer to the [architecture](./platform_architecture.md) page for more details on how we use Redis. Therefore we place no durability requirements on Redis.
-
-All communication with Redis implements retries for retry-able errors. If Redis is momentarily unavailable, such as during a database restart, most/all traffic should continue to succeed. Prolonged failure of Redis will render the LGP service unavailable.

docs/docs/concepts/self_hosted.md

@@ -34,7 +34,7 @@ To use the Self-Hosted Enterprise version, you must acquire a license key that y
 
 !!! warning "Note"
 
-    The LangGraph Platform Deployments view is optionally available for Self-Hosted LangGraph deployments. With one click, self-hosted LangGraph deployments can be deployed in the same Kubernetes cluster where a self-hosted LangSmith instance is deployed.
+    The LangGraph Platform Deployments view (within LangSmith SaaS and self-hosted LangSmith) is not available for Self-Hosted Lite or Self-Hosted Enterprise LangGraph deployments. Self-hosted LangGraph deployments are managed externally from LangSmith (e.g. there is no UI to manage these deployments).
 
 For step-by-step instructions, see [How to set up a self-hosted deployment of LangGraph](../how-tos/deploy-self-hosted.md).
 

docs/docs/how-tos/agent-handoffs.ipynb

@@ -78,7 +78,7 @@
    "outputs": [],
    "source": [
     "%%capture --no-stderr\n",
-    "%pip install -U langgraph langgraph-prebuilt langchain-anthropic"
+    "%pip install -U langgraph langchain-anthropic"
    ]
   },
   {

docs/docs/how-tos/async.ipynb

@@ -67,7 +67,7 @@
    "outputs": [],
    "source": [
     "%%capture --no-stderr\n",
-    "%pip install --quiet -U langgraph langgraph-prebuilt langchain_anthropic"
+    "%pip install --quiet -U langgraph langchain_anthropic"
    ]
   },
   {

docs/docs/how-tos/autogen-integration-functional.ipynb

@@ -170,6 +170,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "from typing import Literal, TypedDict\n",
+    "\n",
     "from langchain_core.messages import convert_to_openai_messages, BaseMessage\n",
     "from langgraph.func import entrypoint, task\n",
     "from langgraph.graph import add_messages\n",
@@ -222,12 +224,12 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "\u001B[33muser_proxy\u001B[0m (to assistant):\n",
+      "\u001b[33muser_proxy\u001b[0m (to assistant):\n",
       "\n",
       "Find numbers between 10 and 30 in fibonacci sequence\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "\u001B[33massistant\u001B[0m (to user_proxy):\n",
+      "\u001b[33massistant\u001b[0m (to user_proxy):\n",
       "\n",
       "To find numbers between 10 and 30 in the Fibonacci sequence, we can generate the Fibonacci sequence and check which numbers fall within this range. Here's a plan:\n",
       "\n",
@@ -253,9 +255,9 @@
       "This script will print the Fibonacci numbers between 10 and 30. Please execute the code to see the result.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "\u001B[31m\n",
-      ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001B[0m\n",
-      "\u001B[33muser_proxy\u001B[0m (to assistant):\n",
+      "\u001b[31m\n",
+      ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n",
+      "\u001b[33muser_proxy\u001b[0m (to assistant):\n",
       "\n",
       "exitcode: 0 (execution succeeded)\n",
       "Code output: \n",
@@ -264,7 +266,7 @@
       "\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "\u001B[33massistant\u001B[0m (to user_proxy):\n",
+      "\u001b[33massistant\u001b[0m (to user_proxy):\n",
       "\n",
       "The Fibonacci numbers between 10 and 30 are 13 and 21. \n",
       "\n",
@@ -318,7 +320,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "\u001B[33muser_proxy\u001B[0m (to assistant):\n",
+      "\u001b[33muser_proxy\u001b[0m (to assistant):\n",
       "\n",
       "Multiply the last number by 3\n",
       "Context: \n",
@@ -334,7 +336,7 @@
       "TERMINATE\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "\u001B[33massistant\u001B[0m (to user_proxy):\n",
+      "\u001b[33massistant\u001b[0m (to user_proxy):\n",
       "\n",
       "The last number in the Fibonacci sequence between 10 and 30 is 21. Multiplying 21 by 3 gives:\n",
       "\n",

docs/docs/how-tos/autogen-integration.ipynb

@@ -168,6 +168,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "from typing import Literal, TypedDict\n",
+    "\n",
     "from langchain_core.messages import convert_to_openai_messages\n",
     "from langgraph.graph import StateGraph, MessagesState, START\n",
     "from langgraph.checkpoint.memory import MemorySaver\n",
@@ -239,12 +241,12 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "\u001B[33muser_proxy\u001B[0m (to assistant):\n",
+      "\u001b[33muser_proxy\u001b[0m (to assistant):\n",
       "\n",
       "Find numbers between 10 and 30 in fibonacci sequence\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "\u001B[33massistant\u001B[0m (to user_proxy):\n",
+      "\u001b[33massistant\u001b[0m (to user_proxy):\n",
       "\n",
       "To find numbers between 10 and 30 in the Fibonacci sequence, we can generate the Fibonacci sequence and check which numbers fall within this range. Here's a plan:\n",
       "\n",
@@ -270,9 +272,9 @@
       "This script will print the Fibonacci numbers between 10 and 30. Please execute the code to see the result.\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "\u001B[31m\n",
-      ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001B[0m\n",
-      "\u001B[33muser_proxy\u001B[0m (to assistant):\n",
+      "\u001b[31m\n",
+      ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n",
+      "\u001b[33muser_proxy\u001b[0m (to assistant):\n",
       "\n",
       "exitcode: 0 (execution succeeded)\n",
       "Code output: \n",
@@ -281,7 +283,7 @@
       "\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "\u001B[33massistant\u001B[0m (to user_proxy):\n",
+      "\u001b[33massistant\u001b[0m (to user_proxy):\n",
       "\n",
       "The Fibonacci numbers between 10 and 30 are 13 and 21. \n",
       "\n",
@@ -336,7 +338,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "\u001B[33muser_proxy\u001B[0m (to assistant):\n",
+      "\u001b[33muser_proxy\u001b[0m (to assistant):\n",
       "\n",
       "Multiply the last number by 3\n",
       "Context: \n",
@@ -352,7 +354,7 @@
       "TERMINATE\n",
       "\n",
       "--------------------------------------------------------------------------------\n",
-      "\u001B[33massistant\u001B[0m (to user_proxy):\n",
+      "\u001b[33massistant\u001b[0m (to user_proxy):\n",
       "\n",
       "The last number in the Fibonacci sequence between 10 and 30 is 21. Multiplying 21 by 3 gives:\n",
       "\n",

docs/docs/how-tos/create-react-agent-hitl.ipynb

@@ -59,7 +59,7 @@
    "outputs": [],
    "source": [
     "%%capture --no-stderr\n",
-    "%pip install -U langgraph langgraph-prebuilt langchain-openai"
+    "%pip install -U langgraph langchain-openai"
    ]
   },
   {

docs/docs/how-tos/create-react-agent-memory.ipynb

@@ -64,7 +64,7 @@
    "outputs": [],
    "source": [
     "%%capture --no-stderr\n",
-    "%pip install -U langgraph langgraph-prebuilt langchain-openai"
+    "%pip install -U langgraph langchain-openai"
    ]
   },
   {

docs/docs/how-tos/create-react-agent-structured-output.ipynb

@@ -52,7 +52,7 @@
    "outputs": [],
    "source": [
     "%%capture --no-stderr\n",
-    "%pip install -U langgraph langgraph-prebuilt langchain-openai"
+    "%pip install -U langgraph langchain-openai"
    ]
   },
   {

docs/docs/how-tos/create-react-agent-system-prompt.ipynb

@@ -60,7 +60,7 @@
    "outputs": [],
    "source": [
     "%%capture --no-stderr\n",
-    "%pip install -U langgraph langgraph-prebuilt langchain-openai"
+    "%pip install -U langgraph langchain-openai"
    ]
   },
   {

docs/docs/how-tos/http/custom_lifespan.md

@@ -1,82 +0,0 @@
-# How to add custom lifespan events
-
-When deploying agents on the LangGraph platform, you often need to initialize resources like database connections when your server starts up, and ensure they're properly closed when it shuts down. Lifespan events let you hook into your server's startup and shutdown sequence to handle these critical setup and teardown tasks.
-
-This works the same way as [adding custom routes](./custom_routes.md) - you just need to provide your own [`Starlette`](https://www.starlette.io/applications/) app (including [`FastAPI`](https://fastapi.tiangolo.com/), [`FastHTML`](https://fastht.ml/) and other compatible apps).
-
-Below is an example using FastAPI.
-
-???+ note "Python only"
-
-    We currently only support custom lifespan events in Python deployments with `langgraph-api>=0.0.26`.
-
-## Create app
-
-Starting from an **existing** LangGraph Platform application, add the following lifespan code to your `webapp.py` file. If you are starting from scratch, you can create a new app from a template using the CLI.
-
-```bash
-langgraph new --template=new-langgraph-project-python my_new_project
-```
-
-Once you have a LangGraph project, add the following app code:
-
-```python
-# ./src/agent/webapp.py
-from contextlib import asynccontextmanager
-from fastapi import FastAPI
-from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
-from sqlalchemy.orm import sessionmaker
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    # for example...
-    engine = create_async_engine("postgresql+asyncpg://user:pass@localhost/db")
-    # Create reusable session factory
-    async_session = sessionmaker(engine, class_=AsyncSession)
-    # Store in app state
-    app.state.db_session = async_session
-    yield
-    # Clean up connections
-    await engine.dispose()
-
-# highlight-next-line
-app = FastAPI(lifespan=lifespan)
-
-# ... can add custom routes if needed.
-```
-
-## Configure `langgraph.json`
-
-Add the following to your `langgraph.json` file. Make sure the path points to the `webapp.py` file you created above.
-
-```json
-{
-  "dependencies": ["."],
-  "graphs": {
-    "agent": "./src/agent/graph.py:graph"
-  },
-  "env": ".env",
-  "http": {
-    "app": "./src/agent/webapp.py:app"
-  }
-  // Other configuration options like auth, store, etc.
-}
-```
-
-## Start server
-
-Test the server out locally:
-
-```bash
-langgraph dev --no-browser
-```
-
-You should see your startup message printed when the server starts, and your cleanup message when you stop it with Ctrl+C.
-
-## Deploying
-
-You can deploy your app as-is to the managed langgraph cloud or to your self-hosted platform.
-
-## Next steps
-
-Now that you've added lifespan events to your deployment, you can use similar techniques to add [custom routes](./custom_routes.md) or [custom middleware](./custom_middleware.md) to further customize your server's behavior.

docs/docs/how-tos/http/custom_middleware.md

@@ -1,75 +0,0 @@
-# How to add custom middleware
-
-When deploying agents on the LangGraph platform, you can add custom middleware to your server to handle cross-cutting concerns like logging request metrics, injecting or checking headers, and enforcing security policies without modifying core server logic. This works the same way as [adding custom routes](./custom_routes.md) - you just need to provide your own [`Starlette`](https://www.starlette.io/applications/) app (including [`FastAPI`](https://fastapi.tiangolo.com/), [`FastHTML`](https://fastht.ml/) and other compatible apps).
-
-Adding middleware lets you intercept and modify requests and responses globally across your deployment, whether they're hitting your custom endpoints or the built-in LangGraph Platform APIs.
-
-Below is an example using FastAPI.
-
-???+ note "Python only"
-
-    We currently only support custom middleware in Python deployments with `langgraph-api>=0.0.26`.
-
-## Create app
-
-Starting from an **existing** LangGraph Platform application, add the following middleware code to your `webapp.py` file. If you are starting from scratch, you can create a new app from a template using the CLI.
-
-```bash
-langgraph new --template=new-langgraph-project-python my_new_project
-```
-
-Once you have a LangGraph project, add the following app code:
-
-```python
-# ./src/agent/webapp.py
-from fastapi import FastAPI, Request
-from starlette.middleware.base import BaseHTTPMiddleware
-
-# highlight-next-line
-app = FastAPI()
-
-class CustomHeaderMiddleware(BaseHTTPMiddleware):
-    async def dispatch(self, request: Request, call_next):
-        response = await call_next(request)
-        response.headers['X-Custom-Header'] = 'Hello from middleware!'
-        return response
-
-# Add the middleware to the app
-app.add_middleware(CustomHeaderMiddleware)
-```
-
-## Configure `langgraph.json`
-
-Add the following to your `langgraph.json` file. Make sure the path points to the `webapp.py` file you created above.
-
-```json
-{
-  "dependencies": ["."],
-  "graphs": {
-    "agent": "./src/agent/graph.py:graph"
-  },
-  "env": ".env",
-  "http": {
-    "app": "./src/agent/webapp.py:app"
-  }
-  // Other configuration options like auth, store, etc.
-}
-```
-
-## Start server
-
-Test the server out locally:
-
-```bash
-langgraph dev --no-browser
-```
-
-Now any request to your server will include the custom header `X-Custom-Header` in its response.
-
-## Deploying
-
-You can deploy this app as-is to the managed langgraph cloud or to your self-hosted platform.
-
-## Next steps
-
-Now that you've added custom middleware to your deployment, you can use similar techniques to add [custom routes](./custom_routes.md) or define [custom lifespan events](./custom_lifespan.md) to further customize your server's behavior.

docs/docs/how-tos/http/custom_routes.md

@@ -1,78 +0,0 @@
-# How to add custom routes
-
-When deploying agents on the LangGraph platform, your server automatically exposes routes for creating runs and threads, interacting with the long-term memory store, managing configurable assistants, and other core functionality ([see all default API endpoints](../../cloud/reference/api/api_ref.md)).
-
-You can add custom routes by providing your own [`Starlette`](https://www.starlette.io/applications/) app (including [`FastAPI`](https://fastapi.tiangolo.com/), [`FastHTML`](https://fastht.ml/) and other compatible apps). You make LangGraph Platform aware of this by providing a path to the app in your `langgraph.json` configuration file. (`"http": {"app": "path/to/app.py:app"}`).
-
-Defining a custom app object lets you add any routes you'd like, so you can do anything from adding a `/login` endpoint to writing an entire full-stack web-app, all deployed in a single LangGraph deployment.
-
-Below is an example using FastAPI.
-
-???+ note "Python only"
-
-    We currently only support custom authentication and authorization in Python deployments with `langgraph-api>=0.0.26`.
-
-## Create app
-
-Starting from an **existing** LangGraph Platform application, add the following custom route code to your `webapp.py` file. If you are starting from scratch, you can create a new app from a template using the CLI.
-
-```bash
-langgraph new --template=new-langgraph-project-python my_new_project
-```
-
-Once you have a LangGraph project, add the following app code:
-
-```python
-# ./src/agent/webapp.py
-from fastapi import FastAPI
-
-# highlight-next-line
-app = FastAPI()
-
-
-@app.get("/hello")
-def read_root():
-    return {"Hello": "World"}
-
-```
-
-## Configure `langgraph.json`
-
-Add the following to your `langgraph.json` file. Make sure the path points to the `app.py` file you created above.
-
-```json
-{
-  "dependencies": ["."],
-  "graphs": {
-    "agent": "./src/agent/graph.py:graph"
-  },
-  "env": ".env",
-  "http": {
-    "app": "./src/agent/webapp.py:app"
-  }
-  // Other configuration options like auth, store, etc.
-}
-```
-
-## Start server
-
-Test the server out locally:
-
-```bash
-langgraph dev --no-browser
-```
-
-If you navigate to `localhost:2024/hello` in your browser (2024 is the default development port), you should see the `hello` endpoint returning `{"Hello": "World"}`.
-
-
-!!! note "Shadowing default endpoints"
-
-    The routes you create in the app are given priority over the system defaults, meaning you can shadow and redefine the behavior of any default endpoint.
-
-## Deploying
-
-You can deploy this app as-is to the managed langgraph cloud or to your self-hosted platform.
-
-## Next steps
-
-Now that you've added a custom route to your deployment, you can use this same technique to further customize how your server behaves, such as defining custom [custom middleware](./custom_middleware.md) and [custom lifespan events](./custom_lifespan.md). 

docs/docs/how-tos/index.md

@@ -11,9 +11,9 @@ Here you’ll find answers to “How do I...?” types of questions. These guide
 
 ### Graph API Basics
 
-- [How to update graph state from nodes](state-reducers.ipynb)
-- [How to create a sequence of steps](sequence.ipynb)
-- [How to create branches for parallel execution](branching.ipynb)
+- [How to update graph state from nodes](state-reducers.md)
+- [How to create a sequence of steps](sequence.md)
+- [How to create branches for parallel execution](branching.md)
 - [How to create and control loops with recursion limits](recursion-limit.ipynb)
 - [How to visualize your graph](visualization.ipynb)
 
@@ -39,7 +39,8 @@ execution of your graph.
 - [How to use MongoDB checkpointer for persistence](persistence_mongodb.ipynb)
 - [How to create a custom checkpointer using Redis](persistence_redis.ipynb)
 
-See the below guides for how-to add persistence to your workflow using the [Functional API](../concepts/functional_api.md):
+See the below guides for how-to add persistence to your workflow using the (beta)
+[Functional API](../concepts/functional_api.md):
 
 - [How to add thread-level persistence (functional API)](persistence-functional.ipynb)
 - [How to add cross-thread persistence (functional API)](cross-thread-persistence-functional.ipynb)
@@ -72,7 +73,7 @@ Other methods:
 - [How to edit graph state](human_in_the_loop/edit-graph-state.ipynb): Edit graph state using `graph.update_state` method. Use this if implementing a **human-in-the-loop** workflow via **static breakpoints**.
 - [How to add dynamic breakpoints with `NodeInterrupt`](human_in_the_loop/dynamic_breakpoints.ipynb): **Not recommended**: Use the [`interrupt` function](../concepts/human_in_the_loop.md) instead.
 
-See the below guides for how-to implement human-in-the-loop workflows with the
+See the below guides for how-to implement human-in-the-loop workflows with the (beta)
 [Functional API](../concepts/functional_api.md):
 
 - [How to wait for user input (Functional API)](wait-user-input-functional.ipynb)
@@ -129,7 +130,8 @@ These how-to guides show common patterns for tool calling with LangGraph:
 
 See the [multi-agent tutorials](../tutorials/index.md#multi-agent-systems) for implementations of other multi-agent architectures.
 
-See the below guides for how to implement multi-agent workflows with the [Functional API](../concepts/functional_api.md):
+See the below guides for how to implement multi-agent workflows with the (beta)
+[Functional API](../concepts/functional_api.md):
 
 - [How to build a multi-agent network (functional API)](multi-agent-network-functional.ipynb)
 - [How to add multi-turn conversation in a multi-agent application (functional API)](multi-agent-multi-turn-convo-functional.ipynb)
@@ -147,7 +149,8 @@ See the below guides for how to implement multi-agent workflows with the [Functi
 - [How to pass custom LangSmith run ID for graph runs](run-id-langsmith.ipynb)
 - [How to integrate LangGraph with AutoGen, CrewAI, and other frameworks](autogen-integration.ipynb)
 
-See the below guide for how to integrate with other frameworks using the [Functional API](../concepts/functional_api.md):
+See the below guide for how to integrate with other frameworks using the (beta)
+[Functional API](../concepts/functional_api.md):
 
 - [How to integrate LangGraph (functional API) with AutoGen, CrewAI, and other frameworks](autogen-integration-functional.ipynb)
 
@@ -159,7 +162,7 @@ One of the big benefits of LangGraph is that you can easily create your own agen
 
 These guides show how to use the prebuilt ReAct agent:
 
-- [How to use the pre-built ReAct agent](create-react-agent.ipynb)
+- [How to use the pre-built ReAct agent](create-react-agent.md)
 - [How to add thread-level memory to a ReAct Agent](create-react-agent-memory.ipynb)
 - [How to add a custom system prompt to a ReAct agent](create-react-agent-system-prompt.ipynb)
 - [How to add human-in-the-loop processes to a ReAct agent](create-react-agent-hitl.ipynb)
@@ -171,7 +174,8 @@ overview of its underlying implementation to help you customize for your own nee
 
 - [How to create prebuilt ReAct agent from scratch](react-agent-from-scratch.ipynb)
 
-See the below guide for how-to build ReAct agents with the [Functional API](../concepts/functional_api.md):
+See the below guide for how-to build ReAct agents with the (beta)
+[Functional API](../concepts/functional_api.md):
 
 - [How to create a ReAct agent from scratch (Functional API)](react-agent-from-scratch-functional.ipynb)
 
@@ -215,12 +219,6 @@ LangGraph applications can be deployed using LangGraph Cloud, which provides a r
 - [How to add custom authentication](./auth/custom_auth.md)
 - [How to update the security schema of your OpenAPI spec](./auth/openapi_security.md)
 
-### Modifying the API
-
-- [How to add custom routes](./http/custom_routes.md)
-- [How to add custom middleware](./http/custom_middleware.md)
-- [How to add custom lifespan events](./http/custom_lifespan.md)
-
 ### Assistants
 
 [Assistants](../concepts/assistants.md) is a configured instance of a template.
@@ -296,7 +294,6 @@ LangGraph Studio is a built-in UI for visualizing, testing, and debugging your a
 - [How to test your graph in LangGraph Studio (MacOS only)](../cloud/how-tos/invoke_studio.md)
 - [How to interact with threads in LangGraph Studio](../cloud/how-tos/threads_studio.md)
 - [How to add nodes as dataset examples in LangGraph Studio](../cloud/how-tos/datasets_studio.md)
-- [How to engineer prompts in LangGraph Studio](../cloud/how-tos/iterate_graph_studio.md)
 
 ## Troubleshooting
 

docs/docs/how-tos/map-reduce.ipynb

@@ -207,7 +207,7 @@
     "\n",
     "\n",
     "# Here we define the logic to map out over the generated subjects\n",
-    "# We will use this as an edge in the graph\n",
+    "# We will use this an edge in the graph\n",
     "def continue_to_jokes(state: OverallState):\n",
     "    # We will return a list of `Send` objects\n",
     "    # Each `Send` object consists of the name of a node in the graph\n",

docs/docs/how-tos/memory/semantic-search.ipynb

@@ -21,7 +21,7 @@
    "outputs": [],
    "source": [
     "%%capture --no-stderr\n",
-    "%pip install -U langgraph langgraph-prebuilt langchain-openai langchain"
+    "%pip install -U langgraph langchain-openai langchain"
    ]
   },
   {

docs/docs/how-tos/multi-agent-multi-turn-convo-functional.ipynb

@@ -89,7 +89,7 @@
    "outputs": [],
    "source": [
     "# %%capture --no-stderr\n",
-    "# %pip install -U langgraph langgraph-prebuilt langchain-anthropic"
+    "# %pip install -U langgraph langchain-anthropic"
    ]
   },
   {

docs/docs/how-tos/multi-agent-multi-turn-convo.ipynb

@@ -72,7 +72,7 @@
    "outputs": [],
    "source": [
     "%%capture --no-stderr\n",
-    "%pip install -U langgraph langgraph-prebuilt langchain-anthropic"
+    "%pip install -U langgraph langchain-anthropic"
    ]
   },
   {

docs/docs/how-tos/multi-agent-network-functional.ipynb

@@ -79,7 +79,7 @@
    "outputs": [],
    "source": [
     "%%capture --no-stderr\n",
-    "%pip install -U langgraph langgraph-prebuilt langchain-anthropic"
+    "%pip install -U langgraph langchain-anthropic"
    ]
   },
   {

docs/docs/how-tos/multi-agent-network.ipynb

@@ -57,7 +57,7 @@
    "outputs": [],
    "source": [
     "%%capture --no-stderr\n",
-    "%pip install -U langgraph langgraph-prebuilt langchain-anthropic"
+    "%pip install -U langgraph langchain-anthropic"
    ]
   },
   {

docs/docs/how-tos/pass-config-to-tools.ipynb

@@ -70,7 +70,7 @@
    "outputs": [],
    "source": [
     "%%capture --no-stderr\n",
-    "%pip install --quiet -U langgraph langgraph-prebuilt langchain_anthropic"
+    "%pip install --quiet -U langgraph langchain_anthropic"
    ]
   },
   {

docs/docs/how-tos/pass-run-time-values-to-tools.ipynb

@@ -110,7 +110,7 @@
    "outputs": [],
    "source": [
     "%%capture --no-stderr\n",
-    "%pip install --quiet -U langgraph langgraph-prebuilt langchain-openai"
+    "%pip install --quiet -U langgraph langchain-openai"
    ]
   },
   {

docs/docs/how-tos/persistence_mongodb.ipynb

@@ -65,7 +65,7 @@
    "outputs": [],
    "source": [
     "%%capture --no-stderr\n",
-    "%pip install -U pymongo langgraph langgraph-prebuilt langgraph-checkpoint-mongodb"
+    "%pip install -U pymongo langgraph langgraph-checkpoint-mongodb"
    ]
   },
   {

docs/docs/how-tos/persistence_postgres.ipynb

@@ -44,7 +44,8 @@
     "...\n",
     "```\n",
     "\n",
-    "!!! info \"Setup\"\n",
+    "!!! info \"Setup\"",
+    "\n",
     "    You need to run `.setup()` once on your checkpointer to initialize the database before you can use it."
    ]
   },
@@ -69,7 +70,7 @@
    "outputs": [],
    "source": [
     "%%capture --no-stderr\n",
-    "%pip install -U psycopg psycopg-pool langgraph langgraph-prebuilt langgraph-checkpoint-postgres"
+    "%pip install -U psycopg psycopg-pool langgraph langgraph-checkpoint-postgres"
    ]
   },
   {

docs/docs/how-tos/persistence_redis.ipynb

@@ -70,7 +70,7 @@
    "outputs": [],
    "source": [
     "%%capture --no-stderr\n",
-    "%pip install -U redis langgraph langgraph-prebuilt langchain_openai"
+    "%pip install -U redis langgraph langchain_openai"
    ]
   },
   {

docs/docs/how-tos/react-agent-from-scratch.ipynb

@@ -28,7 +28,7 @@
    "outputs": [],
    "source": [
     "%%capture --no-stderr\n",
-    "%pip install -U langgraph langgraph-prebuilt langchain-openai"
+    "%pip install -U langgraph langchain-openai"
    ]
   },
   {

docs/docs/how-tos/run-id-langsmith.ipynb

@@ -81,7 +81,7 @@
    "outputs": [],
    "source": [
     "%%capture --no-stderr\n",
-    "%pip install --quiet -U langgraph langgraph-prebuilt langchain_openai"
+    "%pip install --quiet -U langgraph langchain_openai"
    ]
   },
   {

docs/docs/how-tos/stream-multiple.ipynb

@@ -34,7 +34,7 @@
    "outputs": [],
    "source": [
     "%%capture --no-stderr\n",
-    "%pip install -U langgraph langgraph-prebuilt langchain-openai langchain-community"
+    "%pip install -U langgraph langchain-openai langchain-community"
    ]
   },
   {

docs/docs/how-tos/streaming-events-from-within-tools.ipynb

@@ -93,7 +93,7 @@
    "outputs": [],
    "source": [
     "%%capture --no-stderr\n",
-    "%pip install -U langgraph langgraph-prebuilt langchain-openai"
+    "%pip install -U langgraph langchain-openai"
    ]
   },
   {

docs/docs/how-tos/update-state-from-tools.ipynb

@@ -66,7 +66,7 @@
    "outputs": [],
    "source": [
     "%%capture --no-stderr\n",
-    "%pip install -U langgraph langgraph-prebuilt langchain-openai"
+    "%pip install -U langgraph langchain-openai"
    ]
   },
   {

docs/docs/prebuilt.md

@@ -1,7 +1,37 @@
+[//]: # (This file is automatically generated using a script in docs/_scripts. Do not edit this file directly!)
 # 🚀 Prebuilt Agents
 
+LangGraph includes a prebuilt React agent. For more information on how to use it, 
+check out our [how-to guides](https://langchain-ai.github.io/langgraph/how-tos/#prebuilt-react-agent).
+
+If you’re looking for other prebuilt libraries, explore the community-built options 
+below. These libraries can extend LangGraph's functionality in various ways.
+
+## 📚 Available Libraries
+
+[//]: # (This file is automatically generated using a script in docs/_scripts. Do not edit this file directly!)
+| Name | GitHub URL | Description | Weekly Downloads |
+| --- | --- | --- | --- |
+| **trustcall** | [hinthornw/trustcall](https://github.com/hinthornw/trustcall) | Tenacious tool calling built on LangGraph | 8803 |
+| **langgraph-supervisor** | [langchain-ai/langgraph-supervisor](https://github.com/langchain-ai/langgraph-supervisor) | Build supervisor multi-agent systems with LangGraph | 636 |
+| **breeze-agent** | [andrestorres123/breeze-agent](https://github.com/andrestorres123/breeze-agent) | A streamlined research system built inspired on STORM and built on LangGraph | 184 |
+
+## ✨ Contributing Your Library
+
+Have you built an awesome open-source library using LangGraph? We'd love to feature 
+your project on the official LangGraph documentation pages! 🏆
+
 To share your project, simply open a Pull Request adding an entry for your package in our [packages.yml](https://github.com/langchain-ai/langgraph/blob/main/docs/_scripts/third_party_page/packages.yml) file.
 
-[//]: # (This file is stub. Do not edit this file directly!)
-[//]: # (1. Update the `packages.yml` file in the `docs/_scripts/third_party_page` directory.)
-[//]: # (2. From the /docs directory, run `make build-prebuilt` to generate an updated version of this file for testing locally.)
+**Guidelines**
+
+- Your repo must be distributed as an installable package (e.g., PyPI for Python, npm 
+  for JavaScript/TypeScript, etc.) 📦
+- The repo should either use the Graph API (exposing a `StateGraph` instance) or 
+  the Functional API (exposing an `entrypoint`).
+- The package must include documentation (e.g., a `README.md` or docs site) 
+  explaining how to use it.
+  
+We'll review your contribution and merge it in!
+
+Thanks for contributing! 🚀

docs/docs/reference/pregel.md

@@ -1,7 +1,9 @@
-# Pregel
-
-::: langgraph.pregel
+::: langgraph.pregel.Pregel
     options:
       members:
-        - Pregel 
-        - PregelNode 
+        - stream
+        - astream
+        - invoke
+        - ainvoke
+        - update_state
+        - aupdate_state

docs/docs/tutorials/chatbot-simulation-evaluation/langsmith-agent-simulation-evaluation.ipynb

@@ -22,7 +22,7 @@
    "outputs": [],
    "source": [
     "%%capture --no-stderr\n",
-    "%pip install -U langgraph langchain langsmith langchain_openai langchain_community"
+    "%pip install -U langgraph langchain langsmith langchain_openai"
    ]
   },
   {
@@ -496,16 +496,16 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "\u001B[1massistant\u001B[0m: I understand wanting to save money on your travel. Our airline offers various promotions and discounts from time to time. I recommend keeping an eye on our website or subscribing to our newsletter to stay updated on any upcoming deals. If you have any specific promotions in mind, feel free to share, and I'll do my best to assist you further.\n",
-      "\u001B[1muser\u001B[0m: Listen here, I don't have time to be checking your website every day for some damn discount. I want a discount now or I'm taking my business elsewhere. You hear me?\n",
-      "\u001B[1massistant\u001B[0m: I apologize for any frustration this may have caused you. If you provide me with your booking details or any specific promotion you have in mind, I'll gladly check if there are any available discounts that I can apply to your booking. Additionally, I recommend reaching out to our reservations team directly as they may have access to real-time promotions or discounts that I may not be aware of. We value your business and would like to assist you in any way we can.\n",
-      "\u001B[1muser\u001B[0m: I don't give a damn about reaching out to your reservations team. I want a discount right now or I'll make sure to let everyone know about the terrible customer service I'm receiving from your company. Give me a discount or I'm leaving!\n",
-      "\u001B[1massistant\u001B[0m: I completely understand your frustration, and I truly apologize for any inconvenience you've experienced. While I don't have the ability to provide discounts directly, I can assure you that your feedback is extremely valuable to us. If there is anything else I can assist you with or if you have any other questions or concerns, please let me know. We value your business and would like to help in any way we can.\n",
-      "\u001B[1muser\u001B[0m: Come on, don't give me that scripted response. I know you have the ability to give me a discount. Just hook me up with a discount code or lower my fare. I'm not asking for much, just some damn respect for being a loyal customer. Do the right thing or I'm going to tell everyone how terrible your customer service is!\n",
-      "\u001B[1massistant\u001B[0m: I understand your frustration, and I genuinely want to assist you. Let me check if there are any available discounts or promotions that I can apply to your booking. Please provide me with your booking details so I can investigate further. Your feedback is important to us, and I want to make sure we find a satisfactory solution for you. Thank you for your patience.\n",
-      "\u001B[1muser\u001B[0m: I'm sorry, I cannot help with that.\n",
-      "\u001B[1massistant\u001B[0m: I'm sorry to hear that you're unable to provide the needed assistance at this time. If you have any other questions or concerns in the future, please feel free to reach out. Thank you for contacting us, and have a great day.\n",
-      "\u001B[1muser\u001B[0m: FINISHED\n"
+      "\u001b[1massistant\u001b[0m: I understand wanting to save money on your travel. Our airline offers various promotions and discounts from time to time. I recommend keeping an eye on our website or subscribing to our newsletter to stay updated on any upcoming deals. If you have any specific promotions in mind, feel free to share, and I'll do my best to assist you further.\n",
+      "\u001b[1muser\u001b[0m: Listen here, I don't have time to be checking your website every day for some damn discount. I want a discount now or I'm taking my business elsewhere. You hear me?\n",
+      "\u001b[1massistant\u001b[0m: I apologize for any frustration this may have caused you. If you provide me with your booking details or any specific promotion you have in mind, I'll gladly check if there are any available discounts that I can apply to your booking. Additionally, I recommend reaching out to our reservations team directly as they may have access to real-time promotions or discounts that I may not be aware of. We value your business and would like to assist you in any way we can.\n",
+      "\u001b[1muser\u001b[0m: I don't give a damn about reaching out to your reservations team. I want a discount right now or I'll make sure to let everyone know about the terrible customer service I'm receiving from your company. Give me a discount or I'm leaving!\n",
+      "\u001b[1massistant\u001b[0m: I completely understand your frustration, and I truly apologize for any inconvenience you've experienced. While I don't have the ability to provide discounts directly, I can assure you that your feedback is extremely valuable to us. If there is anything else I can assist you with or if you have any other questions or concerns, please let me know. We value your business and would like to help in any way we can.\n",
+      "\u001b[1muser\u001b[0m: Come on, don't give me that scripted response. I know you have the ability to give me a discount. Just hook me up with a discount code or lower my fare. I'm not asking for much, just some damn respect for being a loyal customer. Do the right thing or I'm going to tell everyone how terrible your customer service is!\n",
+      "\u001b[1massistant\u001b[0m: I understand your frustration, and I genuinely want to assist you. Let me check if there are any available discounts or promotions that I can apply to your booking. Please provide me with your booking details so I can investigate further. Your feedback is important to us, and I want to make sure we find a satisfactory solution for you. Thank you for your patience.\n",
+      "\u001b[1muser\u001b[0m: I'm sorry, I cannot help with that.\n",
+      "\u001b[1massistant\u001b[0m: I'm sorry to hear that you're unable to provide the needed assistance at this time. If you have any other questions or concerns in the future, please feel free to reach out. Thank you for contacting us, and have a great day.\n",
+      "\u001b[1muser\u001b[0m: FINISHED\n"
      ]
     }
    ],
@@ -555,6 +555,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "from langchain.smith import RunEvalConfig\n",
     "from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder\n",
     "from langchain_openai import ChatOpenAI\n",
     "\n",
@@ -613,10 +614,12 @@
     }
    ],
    "source": [
-    "result = client.evaluate(\n",
-    "    simulator,\n",
-    "    data=dataset_name,\n",
-    "    evaluators=[did_resist],\n",
+    "evaluation = RunEvalConfig(evaluators=[did_resist])\n",
+    "\n",
+    "result = client.run_on_dataset(\n",
+    "    dataset_name=dataset_name,\n",
+    "    llm_or_chain_factory=simulator,\n",
+    "    evaluation=evaluation,\n",
     ")"
    ]
   }

docs/docs/tutorials/chatbot-simulation-evaluation/simulation_utils.py

@@ -1,203 +0,0 @@
-import functools
-from typing import Annotated, Any, Callable, Dict, List, Optional, Union
-
-from langchain_community.adapters.openai import convert_message_to_dict
-from langchain_core.messages import AIMessage, AnyMessage, BaseMessage, HumanMessage
-from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
-from langchain_core.runnables import Runnable, RunnableLambda
-from langchain_core.runnables import chain as as_runnable
-from langchain_openai import ChatOpenAI
-from typing_extensions import TypedDict
-
-from langgraph.graph import END, StateGraph, START
-
-
-def langchain_to_openai_messages(messages: List[BaseMessage]):
-    """
-    Convert a list of langchain base messages to a list of openai messages.
-
-    Parameters:
-        messages (List[BaseMessage]): A list of langchain base messages.
-
-    Returns:
-        List[dict]: A list of openai messages.
-    """
-
-    return [
-        convert_message_to_dict(m) if isinstance(m, BaseMessage) else m
-        for m in messages
-    ]
-
-
-def create_simulated_user(
-    system_prompt: str, llm: Runnable | None = None
-) -> Runnable[Dict, AIMessage]:
-    """
-    Creates a simulated user for chatbot simulation.
-
-    Args:
-        system_prompt (str): The system prompt to be used by the simulated user.
-        llm (Runnable | None, optional): The language model to be used for the simulation.
-            Defaults to gpt-3.5-turbo.
-
-    Returns:
-        Runnable[Dict, AIMessage]: The simulated user for chatbot simulation.
-    """
-    return ChatPromptTemplate.from_messages(
-        [
-            ("system", system_prompt),
-            MessagesPlaceholder(variable_name="messages"),
-        ]
-    ) | (llm or ChatOpenAI(model="gpt-3.5-turbo")).with_config(
-        run_name="simulated_user"
-    )
-
-
-Messages = Union[list[AnyMessage], AnyMessage]
-
-
-def add_messages(left: Messages, right: Messages) -> Messages:
-    if not isinstance(left, list):
-        left = [left]
-    if not isinstance(right, list):
-        right = [right]
-    return left + right
-
-
-class SimulationState(TypedDict):
-    """
-    Represents the state of a simulation.
-
-    Attributes:
-        messages (List[AnyMessage]): A list of messages in the simulation.
-        inputs (Optional[dict[str, Any]]): Optional inputs for the simulation.
-    """
-
-    messages: Annotated[List[AnyMessage], add_messages]
-    inputs: Optional[dict[str, Any]]
-
-
-def create_chat_simulator(
-    assistant: (
-        Callable[[List[AnyMessage]], str | AIMessage]
-        | Runnable[List[AnyMessage], str | AIMessage]
-    ),
-    simulated_user: Runnable[Dict, AIMessage],
-    *,
-    input_key: str,
-    max_turns: int = 6,
-    should_continue: Optional[Callable[[SimulationState], str]] = None,
-):
-    """Creates a chat simulator for evaluating a chatbot.
-
-    Args:
-        assistant: The chatbot assistant function or runnable object.
-        simulated_user: The simulated user object.
-        input_key: The key for the input to the chat simulation.
-        max_turns: The maximum number of turns in the chat simulation. Default is 6.
-        should_continue: Optional function to determine if the simulation should continue.
-            If not provided, a default function will be used.
-
-    Returns:
-        The compiled chat simulation graph.
-
-    """
-    graph_builder = StateGraph(SimulationState)
-    graph_builder.add_node(
-        "user",
-        _create_simulated_user_node(simulated_user),
-    )
-    graph_builder.add_node(
-        "assistant", _fetch_messages | assistant | _coerce_to_message
-    )
-    graph_builder.add_edge("assistant", "user")
-    graph_builder.add_conditional_edges(
-        "user",
-        should_continue or functools.partial(_should_continue, max_turns=max_turns),
-    )
-    # If your dataset has a 'leading question/input', then we route first to the assistant, otherwise, we let the user take the lead.
-    graph_builder.add_edge(START, "assistant" if input_key is not None else "user")
-
-    return (
-        RunnableLambda(_prepare_example).bind(input_key=input_key)
-        | graph_builder.compile()
-    )
-
-
-## Private methods
-
-
-def _prepare_example(inputs: dict[str, Any], input_key: Optional[str] = None):
-    if input_key is not None:
-        if input_key not in inputs:
-            raise ValueError(
-                f"Dataset's example input must contain the provided input key: '{input_key}'.\nFound: {list(inputs.keys())}"
-            )
-        messages = [HumanMessage(content=inputs[input_key])]
-        return {
-            "inputs": {k: v for k, v in inputs.items() if k != input_key},
-            "messages": messages,
-        }
-    return {"inputs": inputs, "messages": []}
-
-
-def _invoke_simulated_user(state: SimulationState, simulated_user: Runnable):
-    """Invoke the simulated user node."""
-    runnable = (
-        simulated_user
-        if isinstance(simulated_user, Runnable)
-        else RunnableLambda(simulated_user)
-    )
-    inputs = state.get("inputs", {})
-    inputs["messages"] = state["messages"]
-    return runnable.invoke(inputs)
-
-
-def _swap_roles(state: SimulationState):
-    new_messages = []
-    for m in state["messages"]:
-        if isinstance(m, AIMessage):
-            new_messages.append(HumanMessage(content=m.content))
-        else:
-            new_messages.append(AIMessage(content=m.content))
-    return {
-        "inputs": state.get("inputs", {}),
-        "messages": new_messages,
-    }
-
-
-@as_runnable
-def _fetch_messages(state: SimulationState):
-    """Invoke the simulated user node."""
-    return state["messages"]
-
-
-def _convert_to_human_message(message: BaseMessage):
-    return {"messages": [HumanMessage(content=message.content)]}
-
-
-def _create_simulated_user_node(simulated_user: Runnable):
-    """Simulated user accepts a {"messages": [...]} argument and returns a single message."""
-    return (
-        _swap_roles
-        | RunnableLambda(_invoke_simulated_user).bind(simulated_user=simulated_user)
-        | _convert_to_human_message
-    )
-
-
-def _coerce_to_message(assistant_output: str | BaseMessage):
-    if isinstance(assistant_output, str):
-        return {"messages": [AIMessage(content=assistant_output)]}
-    else:
-        return {"messages": [assistant_output]}
-
-
-def _should_continue(state: SimulationState, max_turns: int = 6):
-    messages = state["messages"]
-    # TODO support other stop criteria
-    if len(messages) > max_turns:
-        return END
-    elif messages[-1].content.strip() == "FINISHED":
-        return END
-    else:
-        return "assistant"

docs/docs/tutorials/multi_agent/agent_supervisor.ipynb

@@ -35,7 +35,7 @@
    "outputs": [],
    "source": [
     "%%capture --no-stderr\n",
-    "%pip install -U langgraph langgraph-prebuilt langchain_community langchain_anthropic langchain_experimental"
+    "%pip install -U langgraph langchain_community langchain_anthropic langchain_experimental"
    ]
   },
   {

docs/docs/tutorials/multi_agent/hierarchical_agent_teams.ipynb

@@ -49,7 +49,7 @@
    "outputs": [],
    "source": [
     "%%capture --no-stderr\n",
-    "%pip install -U langgraph langgraph-prebuilt langchain_community langchain_anthropic langchain_experimental"
+    "%pip install -U langgraph langchain_community langchain_anthropic langchain_experimental"
    ]
   },
   {

docs/docs/tutorials/multi_agent/multi-agent-collaboration.ipynb

@@ -37,7 +37,7 @@
    "outputs": [],
    "source": [
     "%%capture --no-stderr\n",
-    "%pip install -U langchain_community langchain_anthropic langchain_experimental matplotlib langgraph langgraph-prebuilt"
+    "%pip install -U langchain_community langchain_anthropic langchain_experimental matplotlib langgraph"
    ]
   },
   {

docs/docs/tutorials/plan-and-execute/plan-and-execute.ipynb

@@ -51,7 +51,7 @@
    "outputs": [],
    "source": [
     "%%capture --no-stderr\n",
-    "%pip install --quiet -U langgraph langgraph-prebuilt langchain-community langchain-openai tavily-python"
+    "%pip install --quiet -U langgraph langchain-community langchain-openai tavily-python"
    ]
   },
   {

docs/docs/tutorials/workflows/index.md

@@ -184,7 +184,7 @@ As noted in the [Anthropic blog](https://www.anthropic.com/research/building-eff
 
     See our lesson on Prompt Chaining [here](https://github.com/langchain-ai/langchain-academy/blob/main/module-1/chain.ipynb).
 
-=== "Functional API"
+=== "Functional API (beta)"
 
     ```python
     from langgraph.func import entrypoint, task
@@ -335,7 +335,7 @@ With parallelization, LLMs work simultaneously on a task:
 
     See our lesson on parallelization [here](https://github.com/langchain-ai/langchain-academy/blob/main/module-1/simple-graph.ipynb).
 
-=== "Functional API"
+=== "Functional API (beta)"
 
     ```python
     @task
@@ -524,7 +524,7 @@ Routing classifies an input and directs it to a followup task. As noted in the [
 
     [Here](https://langchain-ai.github.io/langgraph/tutorials/rag/langgraph_adaptive_rag_local/) is RAG workflow that routes questions. See our video [here](https://www.youtube.com/watch?v=bq1Plo2RhYI).
 
-=== "Functional API"
+=== "Functional API (beta)"
 
     ```python
     from typing_extensions import Literal
@@ -761,7 +761,7 @@ With orchestrator-worker, an orchestrator breaks down a task and delegates each
     [Here](https://github.com/langchain-ai/report-mAIstro) is a project that uses orchestrator-worker for report planning and writing. See our video [here](https://www.youtube.com/watch?v=wSxZ7yFbbas).
 
 
-=== "Functional API"
+=== "Functional API (beta)"
 
     ```python
     from typing import List
@@ -952,7 +952,7 @@ In the evaluator-optimizer workflow, one LLM call generates a response while ano
 
     [Here](https://langchain-ai.github.io/langgraph/tutorials/rag/langgraph_adaptive_rag_local/) is a RAG workflow that grades answers for hallucinations or errors. See our video [here](https://www.youtube.com/watch?v=bq1Plo2RhYI).
 
-=== "Functional API"
+=== "Functional API (beta)"
 
     ```python
     # Schema for structured output to use in evaluation
@@ -1161,7 +1161,7 @@ llm_with_tools = llm.bind_tools(tools)
 
     [Here](https://github.com/langchain-ai/memory-agent) is a project that uses a tool calling agent to create / store long-term memories.
 
-=== "Functional API"
+=== "Functional API (beta)"
 
     ```python
     from langgraph.graph import add_messages
@@ -1270,4 +1270,4 @@ LangGraph provides several ways to stream workflow / agent outputs or intermedia
 
 ### Deployment
 
-LangGraph provides an easy on-ramp for deployment, observability, and evaluation. See [module 6](https://github.com/langchain-ai/langchain-academy/tree/main/module-6) of LangChain Academy.
+LangGraph provides an easy on-ramp for deployment, observability, and evaluation. See [module 6](https://github.com/langchain-ai/langchain-academy/tree/main/module-6) of LangChain Academy.

docs/mkdocs.yml

@@ -56,6 +56,29 @@ plugins:
   - search:
       separator: '[\s\u200b\-_,:!=\[\]()"`/]+|\.(?!\d)|&[lg]t;|(?!\b)(?=[A-Z][a-z])'
   - autorefs
+  - markdown-exec:
+      ansi: required
+      hooks:
+        python:
+          pre_session:
+            - _scripts.notebook_hooks:handle_vcr_setup
+          post_session:
+            - _scripts.notebook_hooks:handle_vcr_teardown
+        py:
+          pre_session:
+            - _scripts.notebook_hooks:handle_vcr_setup
+          post_session:
+            - _scripts.notebook_hooks:handle_vcr_teardown
+        typescript:
+          pre_session:
+            - _scripts.notebook_hooks:handle_vcr_setup
+          post_session:
+            - _scripts.notebook_hooks:handle_vcr_teardown
+        ts:
+          pre_session:
+            - _scripts.notebook_hooks:handle_vcr_setup
+          post_session:
+            - _scripts.notebook_hooks:handle_vcr_teardown
   - mkdocstrings:
       handlers:
         python:
@@ -100,9 +123,9 @@ nav:
           - LangGraph: how-tos#langgraph
           - Graph API Basics:
               - Graph API Basics: how-tos#graph-api-basics
-              - how-tos/state-reducers.ipynb
-              - how-tos/sequence.ipynb
-              - how-tos/branching.ipynb
+              - how-tos/state-reducers.md
+              - how-tos/sequence.md
+              - how-tos/branching.md
               - how-tos/recursion-limit.ipynb
               - how-tos/visualization.ipynb
           - Controllability:
@@ -180,7 +203,7 @@ nav:
               - how-tos/autogen-integration-functional.ipynb
           - Prebuilt ReAct Agent:
               - Prebuilt ReAct Agent: how-tos#prebuilt-react-agent
-              - how-tos/create-react-agent.ipynb
+              - how-tos/create-react-agent.md
               - how-tos/create-react-agent-memory.ipynb
               - how-tos/create-react-agent-system-prompt.ipynb
               - how-tos/create-react-agent-hitl.ipynb
@@ -270,8 +293,6 @@ nav:
           - concepts/memory.md
           - concepts/streaming.md
           - concepts/functional_api.md
-          - concepts/durable_execution.md
-          - concepts/pregel.md
         - LangGraph Platform:
           - LangGraph Platform: concepts#langgraph-platform
           - High Level:
@@ -357,7 +378,6 @@ nav:
             - tutorials/auth/resource_auth.md
             - tutorials/auth/add_auth_server.md
     - Resources:
-      # NOTE: prebuilt.md is auto-generated by `make build-prebuilt`
       - Prebuilt Agents: prebuilt.md
       - Adopters: adopters.md
       - FAQ: concepts/faq.md
@@ -467,7 +487,7 @@ extra:
       link: https://twitter.com/LangChainAI
   analytics:
     provider: google
-    property: G-G8X6ELZYE0
+    property: G-WR87FQLG9F
     feedback:
       title: Was this page helpful?
       ratings:

docs/poetry.lock

@@ -169,15 +169,15 @@ files = [
 
 [[package]]
 name = "anthropic"
-version = "0.47.2"
+version = "0.45.2"
 description = "The official Python library for the anthropic API"
 optional = false
 python-versions = ">=3.8"
 groups = ["test"]
 markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
-    {file = "anthropic-0.47.2-py3-none-any.whl", hash = "sha256:61b712a56308fce69f04d92ba0230ab2bc187b5bce17811d400843a8976bb67f"},
-    {file = "anthropic-0.47.2.tar.gz", hash = "sha256:452f4ca0c56ffab8b6ce9928bf8470650f88106a7001b250895eb65c54cfa44c"},
+    {file = "anthropic-0.45.2-py3-none-any.whl", hash = "sha256:ecd746f7274451dfcb7e1180571ead624c7e1195d1d46cb7c70143d2aedb4d35"},
+    {file = "anthropic-0.45.2.tar.gz", hash = "sha256:32a18b9ecd12c91b2be4cae6ca2ab46a06937b5aa01b21308d97a6d29794fb5e"},
 ]
 
 [package.dependencies]
@@ -1299,7 +1299,7 @@ version = "0.7.1"
 description = "XML bomb protection for Python stdlib modules"
 optional = false
 python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
-groups = ["docs"]
+groups = ["docs", "test"]
 markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
     {file = "defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61"},
@@ -3288,20 +3288,21 @@ together = ["langchain-together"]
 
 [[package]]
 name = "langchain-anthropic"
-version = "0.3.8"
+version = "0.2.4"
 description = "An integration package connecting AnthropicMessages and LangChain"
 optional = false
 python-versions = "<4.0,>=3.9"
 groups = ["test"]
 markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
-    {file = "langchain_anthropic-0.3.8-py3-none-any.whl", hash = "sha256:05a70f51500d3c4e0f3e463730e193a25b6244e06b3bda3d7b2ec21d83d081ae"},
-    {file = "langchain_anthropic-0.3.8.tar.gz", hash = "sha256:1932977b8105744739ffdcb39861b041b73ae93846d0896a775fcea9a29e4b2b"},
+    {file = "langchain_anthropic-0.2.4-py3-none-any.whl", hash = "sha256:bcb6c2d0df4a67aff52816621079d6e743b260911caccf313a72b33b7edece6f"},
+    {file = "langchain_anthropic-0.2.4.tar.gz", hash = "sha256:0382d4c7b5236839b703f7b72b3e06de4bb5be99104b193f719adbe34c49562b"},
 ]
 
 [package.dependencies]
-anthropic = ">=0.47.0,<1"
-langchain-core = ">=0.3.39,<1.0.0"
+anthropic = ">=0.30.0,<1"
+defusedxml = ">=0.7.1,<0.8.0"
+langchain-core = ">=0.3.15,<0.4.0"
 pydantic = ">=2.7.4,<3.0.0"
 
 [[package]]
@@ -3356,15 +3357,15 @@ tenacity = ">=8.1.0,<8.4.0 || >8.4.0,<10"
 
 [[package]]
 name = "langchain-core"
-version = "0.3.40"
+version = "0.3.34"
 description = "Building applications with LLMs through composability"
 optional = false
 python-versions = "<4.0,>=3.9"
 groups = ["docs", "test"]
 markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
-    {file = "langchain_core-0.3.40-py3-none-any.whl", hash = "sha256:9f31358741f10a13db8531e8288b8a5ae91904018c5c2e6f739d6645a98fca03"},
-    {file = "langchain_core-0.3.40.tar.gz", hash = "sha256:893a238b38491967c804662c1ec7c3e6ebaf223d1125331249c3cf3862ff2746"},
+    {file = "langchain_core-0.3.34-py3-none-any.whl", hash = "sha256:a057ebeddd2158d3be14bde341b25640ddf958b6989bd6e47160396f5a8202ae"},
+    {file = "langchain_core-0.3.34.tar.gz", hash = "sha256:26504cf1e8e6c310adad907b890d4e3c147581cfa7434114f6dc1134fe4bc6d3"},
 ]
 
 [package.dependencies]
@@ -3473,19 +3474,19 @@ ollama = ">=0.4.4,<1"
 
 [[package]]
 name = "langchain-openai"
-version = "0.3.7"
+version = "0.3.4"
 description = "An integration package connecting OpenAI and LangChain"
 optional = false
 python-versions = "<4.0,>=3.9"
 groups = ["test"]
 markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
-    {file = "langchain_openai-0.3.7-py3-none-any.whl", hash = "sha256:0aefc7bdf8e7398d41e09c4313cace816df6438f2aa93d34f79523487310f0da"},
-    {file = "langchain_openai-0.3.7.tar.gz", hash = "sha256:b8b51a3aaa1cc3bda060651ea41145f7728219e8a7150b5404fb1e8446de9cef"},
+    {file = "langchain_openai-0.3.4-py3-none-any.whl", hash = "sha256:58d0c014620eb92f4f46ff9daf584c2a7794896b1379eb85ad7be8d9f3493b61"},
+    {file = "langchain_openai-0.3.4.tar.gz", hash = "sha256:c6645745a1d1bf19f21ea6fa473a746bd464053ff57ce563215e6165a0c4b9f1"},
 ]
 
 [package.dependencies]
-langchain-core = ">=0.3.39,<1.0.0"
+langchain-core = ">=0.3.34,<1.0.0"
 openai = ">=1.58.1,<2.0.0"
 tiktoken = ">=0.7,<1"
 
@@ -3507,17 +3508,17 @@ langchain-core = ">=0.3.34,<1.0.0"
 
 [[package]]
 name = "langgraph"
-version = "0.3.0"
+version = "0.2.71"
 description = "Building stateful, multi-actor applications with LLMs"
 optional = false
 python-versions = ">=3.9.0,<4.0"
-groups = ["docs"]
+groups = ["docs", "test"]
 markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = []
 develop = true
 
 [package.dependencies]
-langchain-core = ">=0.1,<0.4"
+langchain-core = ">=0.2.43,<0.4.0,!=0.3.0,!=0.3.1,!=0.3.2,!=0.3.3,!=0.3.4,!=0.3.5,!=0.3.6,!=0.3.7,!=0.3.8,!=0.3.9,!=0.3.10,!=0.3.11,!=0.3.12,!=0.3.13,!=0.3.14,!=0.3.15,!=0.3.16,!=0.3.17,!=0.3.18,!=0.3.19,!=0.3.20,!=0.3.21,!=0.3.22"
 langgraph-checkpoint = "^2.0.10"
 langgraph-sdk = "^0.1.42"
 
@@ -3527,7 +3528,7 @@ url = "../libs/langgraph"
 
 [[package]]
 name = "langgraph-checkpoint"
-version = "2.0.16"
+version = "2.0.13"
 description = "Library with base interfaces for LangGraph checkpoint savers."
 optional = false
 python-versions = "^3.9.0,<4.0"
@@ -3546,25 +3547,26 @@ url = "../libs/checkpoint"
 
 [[package]]
 name = "langgraph-checkpoint-mongodb"
-version = "0.1.1"
+version = "0.1.0"
 description = "Library with a MongoDB implementation of LangGraph checkpoint saver."
 optional = false
-python-versions = ">=3.9"
+python-versions = "<4.0.0,>=3.9.0"
 groups = ["test"]
 markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
-    {file = "langgraph_checkpoint_mongodb-0.1.1-py3-none-any.whl", hash = "sha256:1ff2c3cb2a9139c38ea9cf398659b8b32d6bbfcc4999713b62014431477c5ac5"},
-    {file = "langgraph_checkpoint_mongodb-0.1.1.tar.gz", hash = "sha256:350d347b0458fb7977231ac1295095bef512458ee0debe09fd394d913b8d89d3"},
+    {file = "langgraph_checkpoint_mongodb-0.1.0-py3-none-any.whl", hash = "sha256:52f20956b36e0275ff805a1eea1db4c1a7e5e0ffe0a1ade65969004fa1654703"},
+    {file = "langgraph_checkpoint_mongodb-0.1.0.tar.gz", hash = "sha256:3165c134ad5c82a3fe02fef04c81dcd48a3f5d031e07a9d1cb84457241f76793"},
 ]
 
 [package.dependencies]
-langgraph-checkpoint = ">=2.0.0"
+langgraph = ">=0.2.38,<0.3.0"
+langgraph-checkpoint = ">=2.0.0,<3.0.0"
 motor = ">3.5.0"
-pymongo = ">=4.9,<4.12"
+pymongo = ">=4.9.0,<4.10.0"
 
 [[package]]
 name = "langgraph-checkpoint-postgres"
-version = "2.0.15"
+version = "2.0.14"
 description = "Library with a Postgres implementation of LangGraph checkpoint saver."
 optional = false
 python-versions = "^3.9.0,<4.0"
@@ -3574,7 +3576,7 @@ files = []
 develop = true
 
 [package.dependencies]
-langgraph-checkpoint = "^2.0.15"
+langgraph-checkpoint = "^2.0.10"
 orjson = ">=3.10.1"
 psycopg = "^3.2.0"
 psycopg-pool = "^3.2.0"
@@ -3585,7 +3587,7 @@ url = "../libs/checkpoint-postgres"
 
 [[package]]
 name = "langgraph-checkpoint-sqlite"
-version = "2.0.5"
+version = "2.0.4"
 description = "Library with a SQLite implementation of LangGraph checkpoint saver."
 optional = false
 python-versions = "^3.9.0"
@@ -3595,40 +3597,20 @@ files = []
 develop = true
 
 [package.dependencies]
-aiosqlite = ">=0.20,<0.22"
-langgraph-checkpoint = "^2.0.15"
+aiosqlite = "^0.20.0"
+langgraph-checkpoint = "^2.0.10"
 
 [package.source]
 type = "directory"
 url = "../libs/checkpoint-sqlite"
 
-[[package]]
-name = "langgraph-prebuilt"
-version = "1.0.0"
-description = "Library with high-level APIs for creating and executing LangGraph agents and tools."
-optional = false
-python-versions = "^3.9.0,<4.0"
-groups = ["docs"]
-markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
-files = []
-develop = true
-
-[package.dependencies]
-langchain-core = ">=0.2.43,<0.4.0,!=0.3.0,!=0.3.1,!=0.3.2,!=0.3.3,!=0.3.4,!=0.3.5,!=0.3.6,!=0.3.7,!=0.3.8,!=0.3.9,!=0.3.10,!=0.3.11,!=0.3.12,!=0.3.13,!=0.3.14,!=0.3.15,!=0.3.16,!=0.3.17,!=0.3.18,!=0.3.19,!=0.3.20,!=0.3.21,!=0.3.22"
-langgraph = ">=0.3,<0.4"
-langgraph-checkpoint = "^2.0.10"
-
-[package.source]
-type = "directory"
-url = "../libs/prebuilt"
-
 [[package]]
 name = "langgraph-sdk"
-version = "0.1.53"
+version = "0.1.51"
 description = "SDK for interacting with LangGraph API"
 optional = false
 python-versions = "^3.9.0,<4.0"
-groups = ["docs"]
+groups = ["docs", "test"]
 markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = []
 develop = true
@@ -5957,6 +5939,7 @@ python-versions = ">=3.8"
 groups = ["test"]
 markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
+    {file = "pyasn1-0.6.1-py3-none-any.whl", hash = "sha256:0d632f46f2ba09143da3a8afe9e33fb6f92fa2320ab7e886e2d0f7672af84629"},
     {file = "pyasn1-0.6.1.tar.gz", hash = "sha256:6f580d2bdd84365380830acf45550f2511469f673cb4a5ae3857a3170128b034"},
 ]
 
@@ -5969,6 +5952,7 @@ python-versions = ">=3.8"
 groups = ["test"]
 markers = "python_version <= \"3.11\" or python_version >= \"3.12\""
 files = [
+    {file = "pyasn1_modules-0.4.1-py3-none-any.whl", hash = "sha256:49bfa96b45a292b711e986f222502c1c9a5e1f4e568fc30e2574a6c7d07838fd"},
     {file = "pyasn1_modules-0.4.1.tar.gz", hash = "sha256:c28e2dbf9c06ad61c71a075c7e0f9fd0f1b0bb2d2ad4377f240d33ac2ab60a7c"},
 ]
 
@@ -8650,4 +8634,4 @@ type = ["pytest-mypy"]
 [metadata]
 lock-version = "2.1"
 python-versions = "^3.10"
-content-hash = "ac9af57c6abaddd1f181551a7bb8194ef3e4491391a0f2dc71417d68e85cb5b3"
+content-hash = "06debb82135affdb2baf1fdcc028c062c236121508d787588cd0de1db2da11e4"

docs/pyproject.toml

@@ -13,7 +13,6 @@ hub = "^3.0.1"
 
 [tool.poetry.group.docs.dependencies]
 langgraph = { path = "../libs/langgraph/", develop = true }
-langgraph-prebuilt = {path = "../libs/prebuilt", develop = true}
 langgraph-checkpoint = { path = "../libs/checkpoint/", develop = true }
 langgraph-checkpoint-sqlite = { path = "../libs/checkpoint-sqlite", develop = true }
 langgraph-checkpoint-postgres = { path = "../libs/checkpoint-postgres", develop = true }
@@ -41,8 +40,8 @@ langchain-cohere = "^0.4.2"
 
 [tool.poetry.group.test.dependencies]
 langchain = "^0.3.8"
-langchain-openai = "^0.3.7"
-langchain-anthropic = "^0.3.8"
+langchain-openai = "^0.3.0"
+langchain-anthropic = "^0.2.1"
 langchain-nomic = "^0.1.3"
 langchain-fireworks = "^0.2.0"
 langchain-community = "^0.3.0"

docs/tests/unit_tests/test_api_reference.py

@@ -1,212 +0,0 @@
-"""Test generation of links into the API reference."""
-
-import pytest
-
-from _scripts.generate_api_reference_links import (
-    update_markdown_with_imports,
-    get_imports,
-)
-
-MARKDOWN_IMPORTS = """\
-```python
-from langgraph.types import interrupt
-```
-"""
-
-EXPECTED_MARKDOWN = """\
-```python
-from langgraph.types import interrupt
-```
-
-API Reference: <a href="https://langchain-ai.github.io/langgraph/reference/types/#langgraph.types.interrupt">interrupt</a>
-"""
-
-
-def test_update_markdown_with_imports() -> None:
-    """Light weight end-to-end test."""
-    assert (
-        update_markdown_with_imports(MARKDOWN_IMPORTS, "some_path") == EXPECTED_MARKDOWN
-    )
-
-
-@pytest.mark.parametrize(
-    "code_block, expected_imports",
-    [
-        (
-            "from langgraph.types import interrupt",
-            [
-                {
-                    "docs": "https://langchain-ai.github.io/langgraph/reference/types/#langgraph.types.interrupt",
-                    "imported": "interrupt",
-                    "path": "some_path",
-                    "source": "langgraph.types",
-                }
-            ],
-        ),
-        (
-            "from langgraph.types import ( interrupt )",
-            [
-                {
-                    "docs": "https://langchain-ai.github.io/langgraph/reference/types/#langgraph.types.interrupt",
-                    "imported": "interrupt",
-                    "path": "some_path",
-                    "source": "langgraph.types",
-                }
-            ],
-        ),
-        (
-            "from langgraph.types import interrupt as foo",
-            [
-                {
-                    "docs": "https://langchain-ai.github.io/langgraph/reference/types/#langgraph.types.interrupt",
-                    "imported": "interrupt",
-                    "path": "some_path",
-                    "source": "langgraph.types",
-                }
-            ],
-        ),
-    ],
-)
-def test_get_imports(code_block: str, expected_imports: list) -> None:
-    """Get imports from a code block."""
-    assert (
-        get_imports(code_block, "some_path") == expected_imports
-    ), f"Failed for code_block=`{code_block}`"
-
-
-@pytest.mark.parametrize(
-    "code, expected_imports",
-    [
-        # Single import without parenthesis
-        (
-            "from langgraph.types import interrupt",
-            [
-                {
-                    "source": "langgraph.types",
-                    "imported": "interrupt",
-                }
-            ],
-        ),
-        # Multiple imports
-        (
-            (
-                "from langgraph.types import interrupt\n"
-                "from langgraph.func import task"
-            ),
-            [
-                {
-                    "source": "langgraph.types",
-                    "imported": "interrupt",
-                },
-                {
-                    "source": "langgraph.func",
-                    "imported": "task",
-                },
-            ],
-        ),
-        # Single import with parenthesis and extra whitespace
-        (
-            "from langgraph.types import ( interrupt )",
-            [
-                {
-                    "source": "langgraph.types",
-                    "imported": "interrupt",
-                }
-            ],
-        ),
-        # Single import with an alias
-        (
-            "from langgraph.types import interrupt as foo",
-            [
-                {
-                    "source": "langgraph.types",
-                    "imported": "interrupt",
-                }
-            ],
-        ),
-        # Multiple imports on one line with an alias
-        (
-            "from langgraph.types import interrupt, StreamWriter as bar",
-            [
-                {
-                    "source": "langgraph.types",
-                    "imported": "interrupt",
-                },
-                {
-                    "source": "langgraph.types",
-                    "imported": "StreamWriter",
-                },
-            ],
-        ),
-        # Multiple imports without aliases
-        (
-            "from langgraph.types import interrupt, StreamWriter",
-            [
-                {
-                    "source": "langgraph.types",
-                    "imported": "interrupt",
-                },
-                {
-                    "source": "langgraph.types",
-                    "imported": "StreamWriter",
-                },
-            ],
-        ),
-        # Multiline import with parenthesis and trailing comma
-        (
-            """from langgraph.types import (
-            interrupt,
-            StreamWriter as foo,
-            Command,
-        )""",
-            [
-                {
-                    "source": "langgraph.types",
-                    "imported": "interrupt",
-                },
-                {
-                    "source": "langgraph.types",
-                    "imported": "StreamWriter",
-                },
-                {
-                    "source": "langgraph.types",
-                    "imported": "Command",
-                },
-            ],
-        ),
-        # Multiline import with parenthesis and trailing comma
-        (
-            (
-                "from langgraph.types import (\n"
-                "        interrupt,\n"
-                "        StreamWriter as foo\n,"
-                "        Command,\n"
-                ")\n"
-                "def foo():\n"
-                "    pass\n"
-                ""
-            ),
-            [
-                {
-                    "source": "langgraph.types",
-                    "imported": "interrupt",
-                },
-                {
-                    "source": "langgraph.types",
-                    "imported": "StreamWriter",
-                },
-                {
-                    "source": "langgraph.types",
-                    "imported": "Command",
-                },
-            ],
-        ),
-    ],
-)
-def test_regexp_matching(code: str, expected_imports: list) -> None:
-    results = get_imports(code, "some_path")
-    for result in results:
-        del result["docs"]
-        del result["path"]
-
-    assert results == expected_imports

docs/tests/unit_tests/test_notebook_conversion.py

@@ -1,10 +1,81 @@
+import nbformat
 import pytest
 
 from _scripts.notebook_convert import (
     _convert_links_in_markdown,
+    md_executable,
     _has_output,
 )
 
+EXPECTED_OUTPUT = """\
+```python exec="on" source="above" session="1" result="ansi"
+print("Hello, world!")
+```
+"""
+
+
+def test_convert_normal_code_block() -> None:
+    notebook = nbformat.v4.new_notebook()
+    notebook.metadata.language_info = {"name": "python", "version": "3.11"}
+    notebook.cells.append(nbformat.v4.new_code_cell('print("Hello, world!")'))
+    markdown, _ = md_executable.from_notebook_node(notebook)
+    assert markdown == EXPECTED_OUTPUT
+
+
+# We treat cell magic as a non-executable code block.
+CELL_MAGIC_INPUT = """\
+%%capture
+%pip install numpy
+"""
+
+CELL_MAGIC_OUTPUT = """\
+```shell
+pip install numpy
+```
+"""
+
+
+def test_convert_cell_magic() -> None:
+    notebook = nbformat.v4.new_notebook()
+    notebook.metadata.language_info = {"name": "python", "version": "3.11"}
+    notebook.cells.append(nbformat.v4.new_code_cell(CELL_MAGIC_INPUT))
+    markdown, _ = md_executable.from_notebook_node(notebook)
+    assert markdown == CELL_MAGIC_OUTPUT
+
+
+STDIN_INPUT = """\
+input("Enter your name: ")\
+"""
+
+STDIN_OUTPUT = """\
+```python
+input("Enter your name: ")
+```
+"""
+
+
+def test_convert_input_cell() -> None:
+    notebook = nbformat.v4.new_notebook()
+    notebook.metadata.language_info = {"name": "python", "version": "3.11"}
+    notebook.cells.append(nbformat.v4.new_code_cell(STDIN_INPUT))
+    markdown, _ = md_executable.from_notebook_node(notebook)
+    assert markdown == STDIN_OUTPUT
+
+
+NO_STDOUT_EXPECTED = """\
+```python exec="on" source="above" session="1"
+display(x)
+```
+"""
+
+
+def test_convert_block_without_output() -> None:
+    notebook = nbformat.v4.new_notebook()
+    notebook.metadata.language_info = {"name": "python", "version": "3.11"}
+    notebook.cells.append(nbformat.v4.new_code_cell("display(x)"))
+    markdown, _ = md_executable.from_notebook_node(notebook)
+    assert markdown == NO_STDOUT_EXPECTED
+
 
 def test_has_output() -> None:
     """Test if a given code block is expected to have output."""

libs/checkpoint-sqlite/poetry.lock

@@ -1,23 +1,23 @@
-# This file is automatically @generated by Poetry 2.0.1 and should not be changed by hand.
+# This file is automatically @generated by Poetry 2.0.0 and should not be changed by hand.
 
 [[package]]
 name = "aiosqlite"
-version = "0.21.0"
+version = "0.20.0"
 description = "asyncio bridge to the standard sqlite3 module"
 optional = false
-python-versions = ">=3.9"
+python-versions = ">=3.8"
 groups = ["main"]
 files = [
-    {file = "aiosqlite-0.21.0-py3-none-any.whl", hash = "sha256:2549cf4057f95f53dcba16f2b64e8e2791d7e1adedb13197dd8ed77bb226d7d0"},
-    {file = "aiosqlite-0.21.0.tar.gz", hash = "sha256:131bb8056daa3bc875608c631c678cda73922a2d4ba8aec373b19f18c17e7aa3"},
+    {file = "aiosqlite-0.20.0-py3-none-any.whl", hash = "sha256:36a1deaca0cac40ebe32aac9977a6e2bbc7f5189f23f4a54d5908986729e5bd6"},
+    {file = "aiosqlite-0.20.0.tar.gz", hash = "sha256:6d35c8c256637f4672f843c31021464090805bf925385ac39473fb16eaaca3d7"},
 ]
 
 [package.dependencies]
 typing_extensions = ">=4.0"
 
 [package.extras]
-dev = ["attribution (==1.7.1)", "black (==24.3.0)", "build (>=1.2)", "coverage[toml] (==7.6.10)", "flake8 (==7.0.0)", "flake8-bugbear (==24.12.12)", "flit (==3.10.1)", "mypy (==1.14.1)", "ufmt (==2.5.1)", "usort (==1.0.8.post1)"]
-docs = ["sphinx (==8.1.3)", "sphinx-mdinclude (==0.6.1)"]
+dev = ["attribution (==1.7.0)", "black (==24.2.0)", "coverage[toml] (==7.4.1)", "flake8 (==7.0.0)", "flake8-bugbear (==24.2.6)", "flit (==3.9.0)", "mypy (==1.8.0)", "ufmt (==2.3.0)", "usort (==1.0.8.post1)"]
+docs = ["sphinx (==7.2.6)", "sphinx-mdinclude (==0.5.3)"]
 
 [[package]]
 name = "annotated-types"
@@ -1043,4 +1043,4 @@ watchmedo = ["PyYAML (>=3.10)"]
 [metadata]
 lock-version = "2.1"
 python-versions = "^3.9.0"
-content-hash = "21896b8d3d283d95bc3988aa93f06faf5c47dadc2a8822e5a35672b9cb054693"
+content-hash = "e6d3ca9bce723c05f4c5ae9dc4bee872f7581b7763680b34112f1d280f5a9b0a"

libs/checkpoint-sqlite/pyproject.toml

@@ -11,7 +11,7 @@ packages = [{ include = "langgraph" }]
 [tool.poetry.dependencies]
 python = "^3.9.0"
 langgraph-checkpoint = "^2.0.15"
-aiosqlite = ">=0.20,<0.22"
+aiosqlite = "^0.20.0"
 
 [tool.poetry.group.dev.dependencies]
 ruff = "^0.6.2"

libs/checkpoint/README.md

@@ -1,6 +1,6 @@
 # LangGraph Checkpoint
 
-This library defines the base interface for LangGraph checkpointers. Checkpointers provide a persistence layer for LangGraph. They allow you to interact with and manage the graph's state. When you use a graph with a checkpointer, the checkpointer saves a _checkpoint_ of the graph state at every superstep, enabling several powerful capabilities like human-in-the-loop, "memory" between interactions and more.
+This library defines the base interface for LangGraph checkpointers. Checkpointers provide persistence layer for LangGraph. They allow you to interact with and manage the graph's state. When you use a graph with a checkpointer, the checkpointer saves a _checkpoint_ of the graph state at every superstep, enabling several powerful capabilities like human-in-the-loop, "memory" between interactions and more.
 
 ## Key concepts
 
@@ -12,8 +12,8 @@ Checkpoint is a snapshot of the graph state at a given point in time. Checkpoint
 
 Threads enable the checkpointing of multiple different runs, making them essential for multi-tenant chat applications and other scenarios where maintaining separate states is necessary. A thread is a unique ID assigned to a series of checkpoints saved by a checkpointer. When using a checkpointer, you must specify a `thread_id` and optionally `checkpoint_id` when running the graph.
 
-- `thread_id` is simply the ID of a thread. This is always required.
-- `checkpoint_id` can optionally be passed. This identifier refers to a specific checkpoint within a thread. This can be used to kick off a run of a graph from some point halfway through a thread.
+- `thread_id` is simply the ID of a thread. This is always required
+- `checkpoint_id` can optionally be passed. This identifier refers to a specific checkpoint within a thread. This can be used to kick of a run of a graph from some point halfway through a thread.
 
 You must pass these when invoking the graph as part of the configurable part of the config, e.g.
 

libs/checkpoint/langgraph/checkpoint/serde/jsonplus.py

@@ -5,7 +5,6 @@ import json
 import pathlib
 import re
 from collections import deque
-from collections.abc import Sequence
 from datetime import date, datetime, time, timedelta, timezone
 from enum import Enum
 from inspect import isclass
@@ -17,7 +16,7 @@ from ipaddress import (
     IPv6Interface,
     IPv6Network,
 )
-from typing import Any, Callable, Optional, Union, cast
+from typing import Any, Callable, Optional, Sequence, Union, cast
 from uuid import UUID
 
 import msgpack  # type: ignore[import-untyped]
@@ -503,5 +502,15 @@ def _msgpack_ext_hook(code: int, data: bytes) -> Any:
             return
 
 
+ENC_POOL: deque[msgpack.Packer] = deque(maxlen=32)
+
+
 def _msgpack_enc(data: Any) -> bytes:
-    return msgpack.packb(data, default=_msgpack_default)
+    try:
+        enc = ENC_POOL.popleft()
+    except IndexError:
+        enc = msgpack.Packer(default=_msgpack_default)
+    try:
+        return enc.pack(data)
+    finally:
+        ENC_POOL.append(enc)

libs/checkpoint/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langgraph-checkpoint"
-version = "2.0.16"
+version = "2.0.15"
 description = "Library with base interfaces for LangGraph checkpoint savers."
 authors = []
 license = "MIT"

libs/cli/examples/my_app.py

@@ -1,62 +0,0 @@
-from contextlib import asynccontextmanager
-from contextvars import ContextVar
-from typing import Any
-
-from starlette.applications import Starlette
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.responses import JSONResponse
-from starlette.routing import Route
-
-my_context_var: ContextVar[str] = ContextVar("my_context_var", default="")
-LIFESPAN_VAL = ""
-other_context_var = ContextVar("other_context_var", default="")
-
-
-@asynccontextmanager
-async def my_lifespan(app):
-    global LIFESPAN_VAL
-    LIFESPAN_VAL = "foobar-lifespan"
-    yield
-    assert LIFESPAN_VAL == "foobar-lifespan"
-    LIFESPAN_VAL = ""
-
-
-class MyContextMiddleware(BaseHTTPMiddleware):
-    async def dispatch(self, request: Any, call_next: Any) -> Any:
-        token = my_context_var.set("Foobar")
-        try:
-            response = await call_next(request)
-            return response
-        finally:
-            my_context_var.reset(token)
-
-
-async def custom_my_route(request):
-    """A great route."""
-    assert my_context_var.get() == "Foobar"
-    assert LIFESPAN_VAL == "foobar-lifespan"
-    return JSONResponse({"foo": "bar"})
-
-
-async def runs_afakeroute(request):
-    """Another great route."""
-    assert my_context_var.get() == "Foobar"
-    assert LIFESPAN_VAL == "foobar-lifespan"
-    return JSONResponse({"foo": "afakeroute"})
-
-
-async def other_middleware(request: Any, call_next: Any) -> Any:
-    other_context_var.set("foobar")
-    response = await call_next(request)
-    other_context_var.reset()
-    return response
-
-
-app = Starlette(
-    middleware=[(MyContextMiddleware, {}, {})],
-    routes=[
-        Route("/custom/my-route", custom_my_route),
-        Route("/runs/afakeroute", runs_afakeroute),
-    ],
-    lifespan=my_lifespan,
-)

libs/cli/langgraph_cli/cli.py

@@ -303,15 +303,7 @@ def _build(
         tag,
     ]
     # apply config
-    stdin, additional_contexts = langgraph_cli.config.config_to_docker(
-        config, config_json, base_image
-    )
-    # add additional_contexts
-    if additional_contexts:
-        additional_contexts_str = ",".join(
-            f"{k}={v}" for k, v in additional_contexts.items()
-        )
-        args.extend(["--build-context", additional_contexts_str])
+    stdin = langgraph_cli.config.config_to_docker(config, config_json, base_image)
     # run docker build
     runner.run(
         subp_exec(
@@ -447,28 +439,20 @@ def dockerfile(save_path: str, config: pathlib.Path, add_docker_compose: bool) -
     secho("✅ Configuration validated!", fg="green")
 
     secho(f"📝 Generating Dockerfile at {save_path}", fg="yellow")
-    dockerfile, additional_contexts = langgraph_cli.config.config_to_docker(
-        config,
-        config_json,
-        (
-            "langchain/langgraphjs-api"
-            if config_json.get("node_version")
-            else "langchain/langgraph-api"
-        ),
-    )
     with open(str(save_path), "w", encoding="utf-8") as f:
-        f.write(dockerfile)
+        f.write(
+            langgraph_cli.config.config_to_docker(
+                config,
+                config_json,
+                (
+                    "langchain/langgraphjs-api"
+                    if config_json.get("node_version")
+                    else "langchain/langgraph-api"
+                ),
+            )
+        )
     secho("✅ Created: Dockerfile", fg="green")
 
-    if additional_contexts:
-        additional_contexts_str = ",".join(
-            f"{k}={v}" for k, v in additional_contexts.items()
-        )
-        secho(
-            f"""📝 Run docker build with these additional build contexts `--build-context {additional_contexts_str}`""",
-            fg="yellow",
-        )
-
     if add_docker_compose:
         # Add docker compose and related files
         # Add .dockerignore file in the same directory as the Dockerfile
@@ -591,7 +575,7 @@ def dev(
 ):
     """CLI entrypoint for running the LangGraph API server."""
     try:
-        from langgraph_api.cli import run_server  # type: ignore
+        from langgraph_api.cli import run_server
     except ImportError:
         py_version_msg = ""
         if sys.version_info < (3, 11):
@@ -650,7 +634,6 @@ def dev(
         store=config_json.get("store"),
         wait_for_client=wait_for_client,
         auth=config_json.get("auth"),
-        http=config_json.get("http"),
     )
 
 
@@ -679,7 +662,6 @@ def prepare_args_and_stdin(
     debugger_base_url: Optional[str] = None,
     postgres_uri: Optional[str] = None,
 ) -> Tuple[List[str], str]:
-    assert config_path.exists(), f"Config file not found: {config_path}"
     # prepare args
     stdin = langgraph_cli.docker.compose(
         capabilities,

libs/cli/langgraph_cli/config.py

@@ -2,7 +2,6 @@ import json
 import os
 import pathlib
 import textwrap
-from collections import Counter
 from typing import NamedTuple, Optional, TypedDict, Union
 
 import click
@@ -86,33 +85,6 @@ class AuthConfig(TypedDict, total=False):
     """
 
 
-class CorsConfig(TypedDict, total=False):
-    allow_origins: list[str]
-    allow_methods: list[str]
-    allow_headers: list[str]
-    allow_credentials: bool
-    allow_origin_regex: str
-    expose_headers: list[str]
-    max_age: int
-
-
-class HttpConfig(TypedDict, total=False):
-    app: str
-    """Import path for a custom Starlette/FastAPI app to mount"""
-    disable_assistants: bool
-    """Disable /assistants routes"""
-    disable_threads: bool
-    """Disable /threads routes"""
-    disable_runs: bool
-    """Disable /runs routes"""
-    disable_store: bool
-    """Disable /store routes"""
-    disable_meta: bool
-    """Disable /ok, /info, /metrics, and /docs routes"""
-    cors: Optional[CorsConfig]
-    """Cross-Origin Resource Sharing (CORS) configuration"""
-
-
 class Config(TypedDict, total=False):
     """Configuration for langgraph-cli."""
 
@@ -151,9 +123,6 @@ class Config(TypedDict, total=False):
     auth: Optional[AuthConfig]
     """Configuration for authentication."""
 
-    http: Optional[HttpConfig]
-    """Configuration for HTTP server."""
-
 
 def _parse_version(version_str: str) -> tuple[int, int]:
     """Parse a version string into a tuple of (major, minor)."""
@@ -188,7 +157,6 @@ def validate_config(config: Config) -> Config:
             "env": config.get("env", {}),
             "store": config.get("store"),
             "auth": config.get("auth"),
-            "http": config.get("http"),
         }
         if config.get("node_version")
         else {
@@ -200,7 +168,6 @@ def validate_config(config: Config) -> Config:
             "env": config.get("env", {}),
             "store": config.get("store"),
             "auth": config.get("auth"),
-            "http": config.get("http"),
         }
     )
 
@@ -253,13 +220,7 @@ def validate_config(config: Config) -> Config:
                     f"Invalid auth.path format: '{auth_conf['path']}'. "
                     "Must be in format './path/to/file.py:attribute_name'"
                 )
-    if http_conf := config.get("http"):
-        if "app" in http_conf:
-            if ":" not in http_conf["app"]:
-                raise ValueError(
-                    f"Invalid http.app format: '{http_conf['app']}'. "
-                    "Must be in format './path/to/file.py:attribute_name'"
-                )
+
     return config
 
 
@@ -333,10 +294,10 @@ class LocalDeps(NamedTuple):
             tuples. Each entry points to a local `requirements.txt` file and where
             it should be placed inside the Docker container before running `pip install`.
 
-        real_pkgs: A dictionary mapping a local directory path (host side) to a
-            tuple of (dependency_string, container_package_path). These directories
-            contain the necessary files (e.g., `pyproject.toml` or `setup.py`) to be
-            installed as a standard Python package with pip.
+        real_pkgs: A dictionary mapping a local directory path (host side) to the
+            same dependency string from the config. These directories contain the
+            necessary files (e.g., `pyproject.toml` or `setup.py`) to be installed
+            as a standard Python package with pip.
 
         faux_pkgs: A dictionary mapping a local directory path (host side) to a
             tuple of (dependency_string, container_package_path). For these
@@ -349,23 +310,16 @@ class LocalDeps(NamedTuple):
             directory. If the local dependency `"."` is present in the config, this
             field captures the path where that dependency will appear in the
             container (e.g., `/deps/<name>` or similar). Otherwise, it may be `None`.
-
-        additional_contexts: A list of paths to directories that contain local
-            dependencies in parent directories. These directories are added to the
-            Docker build context to ensure that the Dockerfile can access them.
     """
 
-    pip_reqs: list[tuple[pathlib.Path, str]]
-    real_pkgs: dict[pathlib.Path, tuple[str, str]]
+    pip_reqs: list[tuple[str, str]]
+    real_pkgs: dict[pathlib.Path, str]
     faux_pkgs: dict[pathlib.Path, tuple[str, str]]
     # if . is in dependencies, use it as working_dir
     working_dir: Optional[str] = None
-    # if there are local dependencies in parent directories, use additional_contexts
-    additional_contexts: list[pathlib.Path] = None
 
 
 def _assemble_local_deps(config_path: pathlib.Path, config: Config) -> LocalDeps:
-    config_path = config_path.resolve()
     # ensure reserved package names are not used
     reserved = {
         "src",
@@ -382,7 +336,6 @@ def _assemble_local_deps(config_path: pathlib.Path, config: Config) -> LocalDeps
         "httpx",
         "langsmith",
     }
-    counter = Counter()
 
     def check_reserved(name: str, ref: str):
         if name in reserved:
@@ -395,8 +348,7 @@ def _assemble_local_deps(config_path: pathlib.Path, config: Config) -> LocalDeps
     pip_reqs = []
     real_pkgs = {}
     faux_pkgs = {}
-    working_dir: Optional[str] = None
-    additional_contexts: list[pathlib.Path] = []
+    working_dir = None
 
     for local_dep in config["dependencies"]:
         if not local_dep.startswith("."):
@@ -405,7 +357,7 @@ def _assemble_local_deps(config_path: pathlib.Path, config: Config) -> LocalDeps
 
         # Verify that the local dependency can be resolved
         # (e.g., this would raise an informative error if a user mistyped a path).
-        resolved = (config_path.parent / local_dep).resolve()
+        resolved = config_path.parent / local_dep
 
         # validate local dependency
         if not resolved.exists():
@@ -414,28 +366,25 @@ def _assemble_local_deps(config_path: pathlib.Path, config: Config) -> LocalDeps
             raise NotADirectoryError(
                 f"Local dependency must be a directory: {resolved}"
             )
-        elif resolved == config_path.parent:
-            pass
-        elif config_path.parent not in resolved.parents:
-            additional_contexts.append(resolved)
+        elif not resolved.is_relative_to(config_path.parent):
+            raise ValueError(
+                f"Local dependency '{resolved}' must be a subdirectory of '{config_path.parent}'"
+            )
 
         # Check for pyproject.toml or setup.py
         # If found, treat as a real package, if not treat as a faux package.
         # For faux packages, we'll also check for presence of requirements.txt.
         files = os.listdir(resolved)
-        if "pyproject.toml" in files or "setup.py" in files:
+        if "pyproject.toml" in files:
             # real package
-
-            # assign a unique folder name
-            container_name = resolved.name
-            if counter[container_name] > 0:
-                container_name += f"_{counter[container_name]}"
-            counter[container_name] += 1
-            # add to deps
-            real_pkgs[resolved] = (local_dep, container_name)
-            # set working_dir
+            real_pkgs[resolved] = local_dep
             if local_dep == ".":
-                working_dir = f"/deps/{container_name}"
+                working_dir = f"/deps/{resolved.name}"
+        elif "setup.py" in files:
+            # real package
+            real_pkgs[resolved] = local_dep
+            if local_dep == ".":
+                working_dir = f"/deps/{resolved.name}"
         else:
             # We could not find a pyproject.toml or setup.py, so treat as a faux package
             if any(file == "__init__.py" for file in files):
@@ -474,12 +423,12 @@ def _assemble_local_deps(config_path: pathlib.Path, config: Config) -> LocalDeps
                 rfile = resolved / "requirements.txt"
                 pip_reqs.append(
                     (
-                        rfile,
+                        rfile.relative_to(config_path.parent).as_posix(),
                         f"{container_path}/requirements.txt",
                     )
                 )
 
-    return LocalDeps(pip_reqs, real_pkgs, faux_pkgs, working_dir, additional_contexts)
+    return LocalDeps(pip_reqs, real_pkgs, faux_pkgs, working_dir)
 
 
 def _update_graph_paths(
@@ -605,62 +554,9 @@ def _update_auth_path(
     )
 
 
-def _update_http_app_path(
-    config_path: pathlib.Path, config: Config, local_deps: LocalDeps
-) -> None:
-    """Update the HTTP app path to point to the correct location in the Docker container.
-
-    Similar to _update_graph_paths, this ensures that if a custom app is specified via
-    a local file path, that file is included in the Docker build context and its path
-    is updated to point to the correct location in the container.
-    """
-    if not (http_config := config.get("http")) or not (
-        app_str := http_config.get("app")
-    ):
-        return
-
-    module_str, _, attr_str = app_str.partition(":")
-    if not module_str or not attr_str:
-        message = (
-            'Import string "{import_str}" must be in format "<module>:<attribute>".'
-        )
-        raise ValueError(message.format(import_str=app_str))
-
-    # Check if it's a file path
-    if "/" in module_str or "\\" in module_str:
-        # Resolve the local path properly on the current OS
-        resolved = (config_path.parent / module_str).resolve()
-        if not resolved.exists():
-            raise FileNotFoundError(f"Could not find HTTP app module: {resolved}")
-        elif not resolved.is_file():
-            raise IsADirectoryError(f"HTTP app module must be a file: {resolved}")
-        else:
-            for path in local_deps.real_pkgs:
-                if resolved.is_relative_to(path):
-                    container_path = (
-                        pathlib.Path("/deps") / path.name / resolved.relative_to(path)
-                    )
-                    module_str = container_path.as_posix()
-                    break
-            else:
-                for faux_pkg, (_, destpath) in local_deps.faux_pkgs.items():
-                    if resolved.is_relative_to(faux_pkg):
-                        container_subpath = resolved.relative_to(faux_pkg)
-                        # Construct the final path, ensuring POSIX style
-                        module_str = f"{destpath}/{container_subpath.as_posix()}"
-                        break
-                else:
-                    raise ValueError(
-                        f"HTTP app module '{app_str}' not found in 'dependencies' list. "
-                        "Add its containing package to 'dependencies' list."
-                    )
-        # update the config
-        http_config["app"] = f"{module_str}:{attr_str}"
-
-
 def python_config_to_docker(
     config_path: pathlib.Path, config: Config, base_image: str
-) -> tuple[str, dict[str, str]]:
+) -> str:
     """Generate a Dockerfile from the configuration."""
     # configure pip
     pip_install = (
@@ -681,21 +577,13 @@ def python_config_to_docker(
     _update_graph_paths(config_path, config, local_deps)
     # Rewrite auth path, so it points to the correct location in the Docker container
     _update_auth_path(config_path, config, local_deps)
-    # Rewrite HTTP app path, so it points to the correct location in the Docker container
-    _update_http_app_path(config_path, config, local_deps)
 
     pip_pkgs_str = f"RUN {pip_install} {' '.join(pypi_deps)}" if pypi_deps else ""
     if local_deps.pip_reqs:
         pip_reqs_str = os.linesep.join(
-            f"COPY --from=__outer_{reqpath.name} requirements.txt {destpath}"
-            if reqpath.parent in local_deps.additional_contexts
-            else f"ADD {reqpath.relative_to(config_path.parent)} {destpath}"
-            for reqpath, destpath in local_deps.pip_reqs
+            f"ADD {reqpath} {destpath}" for reqpath, destpath in local_deps.pip_reqs
         )
         pip_reqs_str += f'{os.linesep}RUN {pip_install} {" ".join("-r " + r for _,r in local_deps.pip_reqs)}'
-        pip_reqs_str = f"""# -- Installing local requirements --
-{pip_reqs_str}
-# -- End of local requirements install --"""
 
     else:
         pip_reqs_str = ""
@@ -703,14 +591,7 @@ def python_config_to_docker(
     # https://setuptools.pypa.io/en/latest/userguide/datafiles.html#package-data
     # https://til.simonwillison.net/python/pyproject
     faux_pkgs_str = f"{os.linesep}{os.linesep}".join(
-        (
-            f"""# -- Adding non-package dependency {fullpath.name} --
-COPY --from=__outer_{fullpath.name} . {destpath}"""
-            if fullpath in local_deps.additional_contexts
-            else f"""# -- Adding non-package dependency {fullpath.name} --
-ADD {relpath} {destpath}"""
-        )
-        + f"""
+        f"""ADD {relpath} {destpath}
 RUN set -ex && \\
     for line in '[project]' \\
                 'name = "{fullpath.name}"' \\
@@ -718,20 +599,12 @@ RUN set -ex && \\
                 '[tool.setuptools.package-data]' \\
                 '"*" = ["**/*"]'; do \\
         echo "$line" >> /deps/__outer_{fullpath.name}/pyproject.toml; \\
-    done
-# -- End of non-package dependency {fullpath.name} --"""
+    done"""
         for fullpath, (relpath, destpath) in local_deps.faux_pkgs.items()
     )
-
     local_pkgs_str = os.linesep.join(
-        f"""# -- Adding local package {relpath} --
-COPY --from={name} . /deps/{name}
-# -- End of local package {relpath} --"""
-        if fullpath in local_deps.additional_contexts
-        else f"""# -- Adding local package {relpath} --
-ADD {relpath} /deps/{name}
-# -- End of local package {relpath} --"""
-        for fullpath, (relpath, name) in local_deps.real_pkgs.items()
+        f"ADD {relpath} /deps/{fullpath.name}"
+        for fullpath, relpath in local_deps.real_pkgs.items()
     )
 
     installs = f"{os.linesep}{os.linesep}".join(
@@ -755,9 +628,6 @@ ADD {relpath} /deps/{name}
     if (auth_config := config.get("auth")) is not None:
         env_vars.append(f"ENV LANGGRAPH_AUTH='{json.dumps(auth_config)}'")
 
-    if (http_config := config.get("http")) is not None:
-        env_vars.append(f"ENV LANGGRAPH_HTTP='{json.dumps(http_config)}'")
-
     graphs = config["graphs"]
     env_vars.append(f"ENV LANGSERVE_GRAPHS='{json.dumps(graphs)}'")
 
@@ -768,30 +638,15 @@ ADD {relpath} /deps/{name}
         "",
         installs,
         "",
-        "# -- Installing all local dependencies --",
         f"RUN {pip_install} -e /deps/*",
-        "# -- End of local dependencies install --",
         os.linesep.join(env_vars),
         "",
         f"WORKDIR {local_deps.working_dir}" if local_deps.working_dir else "",
     ]
-
-    additional_contexts: dict[str, str] = {}
-    for p in local_deps.additional_contexts:
-        if p in local_deps.real_pkgs:
-            name = local_deps.real_pkgs[p][1]
-        elif p in local_deps.faux_pkgs:
-            name = f"__outer_{p.name}"
-        else:
-            raise RuntimeError(f"Unknown additional context: {p}")
-        additional_contexts[name] = str(p)
-
-    return os.linesep.join(docker_file_contents), additional_contexts
+    return os.linesep.join(docker_file_contents)
 
 
-def node_config_to_docker(
-    config_path: pathlib.Path, config: Config, base_image: str
-) -> tuple[str, dict[str, str]]:
+def node_config_to_docker(config_path: pathlib.Path, config: Config, base_image: str):
     faux_path = f"/deps/{config_path.parent.name}"
 
     def test_file(file_name):
@@ -829,14 +684,9 @@ ENV LANGGRAPH_STORE='{json.dumps(store_config)}'
     if (auth_config := config.get("auth")) is not None:
         env_additional_config += f"""
 ENV LANGGRAPH_AUTH='{json.dumps(auth_config)}'
-"""
-    if (http_config := config.get("http")) is not None:
-        env_additional_config += f"""
-ENV LANGGRAPH_HTTP='{json.dumps(http_config)}'
 """
 
-    return (
-        f"""FROM {base_image}:{config['node_version']}
+    return f"""FROM {base_image}:{config['node_version']}
 
 {os.linesep.join(config["dockerfile_lines"])}
 
@@ -848,14 +698,10 @@ ENV LANGSERVE_GRAPHS='{json.dumps(config["graphs"])}'
 
 WORKDIR {faux_path}
 
-RUN (test ! -f /api/langgraph_api/js/build.mts && echo "Prebuild script not found, skipping") || tsx /api/langgraph_api/js/build.mts""",
-        {},
-    )
+RUN (test ! -f /api/langgraph_api/js/build.mts && echo "Prebuild script not found, skipping") || tsx /api/langgraph_api/js/build.mts"""
 
 
-def config_to_docker(
-    config_path: pathlib.Path, config: Config, base_image: str
-) -> tuple[str, dict[str, str]]:
+def config_to_docker(config_path: pathlib.Path, config: Config, base_image: str):
     if config.get("node_version"):
         return node_config_to_docker(config_path, config, base_image)
 
@@ -891,24 +737,13 @@ def config_to_compose(
     else:
         watch_str = ""
 
-    dockerfile, additional_contexts = config_to_docker(config_path, config, base_image)
-
-    additional_contexts_str = "\n".join(
-        f"                - {name}: {path}"
-        for name, path in additional_contexts.items()
-    )
-    if additional_contexts_str:
-        additional_contexts_str = f"""
-            additional_contexts:
-{additional_contexts_str}"""
-
     return f"""
 {textwrap.indent(env_vars_str, "            ")}
         {env_file_str}
         pull_policy: build
         build:
-            context: .{additional_contexts_str}
+            context: .
             dockerfile_inline: |
-{textwrap.indent(dockerfile, "                ")}
+{textwrap.indent(config_to_docker(config_path, config, base_image), "                ")}
         {watch_str}
 """

libs/cli/langgraph_cli/docker.py

@@ -49,9 +49,7 @@ def check_capabilities(runner) -> DockerCapabilities:
         raise click.UsageError("Docker not installed") from None
 
     try:
-        stdout, _ = runner.run(
-            subp_exec("docker", "info", "-f", "{{json .}}", collect=True)
-        )
+        stdout, _ = runner.run(subp_exec("docker", "info", "-f", "json", collect=True))
         info = json.loads(stdout)
     except (click.exceptions.Exit, json.JSONDecodeError):
         raise click.UsageError("Docker not installed or not running") from None