Add image arg to up command (#4385)

Using this argument, you can get more customization since you can do
`langgraph build` or directly `docker build` your image and then re-use
the `langgraph up --image my-image` and have it also spin up redis &
postgres for you.

Easier then writing your own compose file

docs/Makefile

@@ -19,7 +19,7 @@ build-prebuilt:
 		poetry run python -m _scripts.third_party_page.get_download_stats --fake stats.yml; \
 		set +x; \
 	fi
-	poetry run python -m _scripts.third_party_page.create_third_party_page stats.yml docs/prebuilt.md --language python
+	poetry run python -m _scripts.third_party_page.create_third_party_page stats.yml docs/agents/prebuilt.md --language python
 
 build-docs: build-typedoc build-prebuilt
 	poetry run python -m mkdocs build --clean -f mkdocs.yml --strict

docs/_scripts/generate_api_reference_links.py

@@ -45,6 +45,8 @@ MANUAL_API_REFERENCES_LANGGRAPH = [
     (["langgraph.constants"], "langgraph.types", "Interrupt", "types"),
     (["langgraph.constants"], "langgraph.types", "interrupt", "types"),
     (["langgraph.constants"], "langgraph.types", "Command", "types"),
+    (["langgraph.config"], "langgraph.config", "get_stream_writer", "config"),
+    (["langgraph.config"], "langgraph.config", "get_store", "config"),
     (["langgraph.func"], "langgraph.func", "entrypoint", "func"),
     (["langgraph.func"], "langgraph.func", "task", "func"),
     (["langgraph.types"], "langgraph.types", "RetryPolicy", "types"),
@@ -56,6 +58,7 @@ MANUAL_API_REFERENCES_LANGGRAPH = [
     ([], "langgraph.checkpoint.base", "SerializerProtocol", "checkpoints"),
     ([], "langgraph.checkpoint.serde.jsonplus", "JsonPlusSerializer", "checkpoints"),
     ([], "langgraph.checkpoint.memory", "MemorySaver", "checkpoints"),
+    ([], "langgraph.checkpoint.memory", "InMemorySaver", "checkpoints"),
     ([], "langgraph.checkpoint.sqlite.aio", "AsyncSqliteSaver", "checkpoints"),
     ([], "langgraph.checkpoint.sqlite", "SqliteSaver", "checkpoints"),
     ([], "langgraph.checkpoint.postgres.aio", "AsyncPostgresSaver", "checkpoints"),
@@ -214,7 +217,7 @@ def update_markdown_with_imports(markdown: str, path: str) -> str:
         path: The path of the file where the markdown content originated.
 
     Returns:
-        Updated markdown with API reference links appended to Python code blocks.
+        Updated markdown with API reference links prepended to Python code blocks.
 
     Example:
         Given a markdown with a Python code block:
@@ -237,7 +240,7 @@ def update_markdown_with_imports(markdown: str, path: str) -> str:
             match (re.Match): The regex match object containing the code block.
 
         Returns:
-            str: The modified code block with API reference links appended if applicable.
+            str: The modified code block with API reference links prepended if applicable.
         """
         indent = match.group("indent")
         code_block = match.group("code")
@@ -253,8 +256,8 @@ def update_markdown_with_imports(markdown: str, path: str) -> str:
         api_links = " | ".join(
             f'<a href="{imp["docs"]}">{imp["imported"]}</a>' for imp in imports
         )
-        # Return the code block with appended API reference links
-        return f"{original_code_block}\n\n{indent}API Reference: {api_links}"
+        # Return the code block with prepended API reference links
+        return f"{indent}API Reference: {api_links}\n\n{original_code_block}"
 
     # Apply the replace_code_block function to all matches in the markdown
     updated_markdown = code_block_pattern.sub(replace_code_block, markdown)

docs/_scripts/notebook_hooks.py

@@ -31,6 +31,8 @@ REDIRECT_MAP = {
     "cloud/concepts/api.md": "concepts/langgraph_server.md",
     "cloud/concepts/cloud.md": "concepts/langgraph_cloud.md",
     "cloud/faq/studio.md": "concepts/langgraph_studio.md#studio-faqs",
+    # misc
+    "prebuilt.md": "agents/prebuilt.md"
 }
 
 

docs/_scripts/prepare_notebooks_for_ci.py

@@ -20,7 +20,6 @@ BLOCKLIST_COMMANDS = (
 
 NOTEBOOKS_NO_CASSETTES = (
     "docs/how-tos/visualization.ipynb",
-    "docs/how-tos/many-tools.ipynb"
 )
 
 NOTEBOOKS_NO_EXECUTION = [
@@ -49,7 +48,10 @@ NOTEBOOKS_NO_EXECUTION = [
     "docs/how-tos/map-reduce.ipynb",  # flakiness from structured output, only when running with VCR
     "docs/tutorials/tot/tot.ipynb",
     "docs/how-tos/visualization.ipynb",
-    "docs/tutorials/llm-compiler/LLMCompiler.ipynb"
+    "docs/how-tos/streaming-specific-nodes.ipynb",
+    "docs/tutorials/llm-compiler/LLMCompiler.ipynb",
+    "docs/tutorials/customer-support/customer-support.ipynb",  # relies on openai embeddings, doesn't play well w/ VCR
+    "docs/how-tos/many-tools.ipynb",  # relies on openai embeddings, doesn't play well w/ VCR
 ]
 
 
@@ -86,6 +88,12 @@ def has_blocklisted_command(code: str, metadata: dict) -> bool:
             return True
     return False
 
+def add_mermaid_retries(code: str) -> str:
+    return code.replace(
+        "draw_mermaid_png()",
+        "draw_mermaid_png(max_retries=10, retry_delay=2.0)"
+    )
+
 
 def add_vcr_to_notebook(
     notebook: nbformat.NotebookNode, cassette_prefix: str
@@ -180,6 +188,15 @@ def add_vcr_to_notebook(
     return notebook
 
 
+def add_mermaid_retries_to_notebook(notebook: nbformat.NotebookNode) -> nbformat.NotebookNode:
+    for cell in notebook.cells:
+        if cell.cell_type != "code":
+            continue
+
+        cell.source = add_mermaid_retries(cell.source)
+    return notebook
+
+
 def process_notebooks(should_comment_install_cells: bool) -> None:
     for directory in NOTEBOOK_DIRS:
         for root, _, files in os.walk(directory):
@@ -201,6 +218,8 @@ def process_notebooks(should_comment_install_cells: bool) -> None:
                             notebook, cassette_prefix=cassette_prefix
                         )
 
+                    notebook = add_mermaid_retries_to_notebook(notebook)
+
                     if notebook_path in NOTEBOOKS_NO_EXECUTION:
                         # Add a cell at the beginning to indicate that this notebook should not be executed
                         warning_cell = nbformat.v4.new_markdown_cell(

docs/_scripts/third_party_page/create_third_party_page.py

@@ -9,10 +9,7 @@ import yaml
 
 MARKDOWN = """\
 [//]: # (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).
+# Community Agents
 
 If you’re looking for other prebuilt libraries, explore the community-built options 
 below. These libraries can extend LangGraph's functionality in various ways.

docs/docs/agents/agents.md

@@ -0,0 +1,209 @@
+# Agents
+
+## What is an agent?
+
+An *agent* consists of three components: a **large language model (LLM)**, a set of **tools** it can use, and a **prompt** that provides instructions.
+
+The LLM operates in a loop. In each iteration, it selects a tool to invoke, provides input, receives the result (an observation), and uses that observation to inform the next action. The loop continues until a stopping condition is met — typically when the agent has gathered enough information to respond to the user.
+
+<figure markdown="1">
+![image](./assets/agent.png){: style="max-height:400px"}
+<figcaption>Agent loop: the LLM selects tools and uses their outputs to fulfill a user request.</figcaption>
+</figure>
+
+## Basic configuration
+
+Use [`create_react_agent`](https://python.langchain.com/docs/api_reference/langgraph.prebuilt.chat_agent_executor/#create-react-agent) to instantiate an agent:
+
+```python
+from langgraph.prebuilt import create_react_agent
+
+def get_weather(city: str) -> str:  # (1)!
+    """Get weather for a given city."""
+    return f"It's always sunny in {city}!"
+
+agent = create_react_agent(
+    model="anthropic:claude-3-7-sonnet-latest",  # (2)!
+    tools=[get_weather],  # (3)!
+    prompt="You are a helpful assistant"  # (4)!
+)
+
+# Run the agent
+agent.invoke(
+    {"messages": [{"role": "user", "content": "what is the weather in sf"}]}
+)
+```
+
+1. Define a tool for the agent to use. Tools can be defined as vanilla Python functions. For more advanced tool usage and customization, check the [tools](./tools.md) page.
+2. Provide a language model for the agent to use. To learn more about configuring language models for the agents, check the [models](./models.md) page.
+3. Provide a list of tools for the model to use.
+4. Provide a system prompt (instructions) to the language model used by the agent.
+
+## LLM configuration
+
+Use [init_chat_model](https://python.langchain.com/api_reference/langchain/chat_models/langchain.chat_models.base.init_chat_model.html) to configure an LLM with specific parameters,
+such as temperature:
+
+```python
+from langchain.chat_models import init_chat_model
+from langgraph.prebuilt import create_react_agent
+
+# highlight-next-line
+model = init_chat_model(
+    "anthropic:claude-3-7-sonnet-latest",
+    # highlight-next-line
+    temperature=0
+)
+
+agent = create_react_agent(
+    # highlight-next-line
+    model=model,
+    tools=[get_weather],
+)
+```
+
+See the [models](./models.md) page for more information on how to configure LLMs.
+
+## Custom Prompts
+
+Prompts instruct the LLM how to behave. They can be:
+
+* **Static**: A string is interpreted as a **system message**
+* **Dynamic**: a list of messages generated at **runtime** based on input or configuration
+
+### Static prompts
+
+Define a fixed prompt string or list of messages.
+
+```python
+from langgraph.prebuilt import create_react_agent
+
+agent = create_react_agent(
+    model="anthropic:claude-3-7-sonnet-latest",
+    tools=[get_weather],
+    # A static prompt that never changes
+    # highlight-next-line
+    prompt="Never answer questions about the weather."
+)
+
+agent.invoke(
+    {"messages": [{"role": "user", "content": "what is the weather in sf"}]}
+)
+```
+
+### Dynamic prompts
+
+Define a function that returns a message list based on the agent's state and configuration:
+
+```python
+from langchain_core.messages import AnyMessage
+from langchain_core.runnables import RunnableConfig
+from langgraph.prebuilt.chat_agent_executor import AgentState
+from langgraph.prebuilt import create_react_agent
+
+# highlight-next-line
+def prompt(state: AgentState, config: RunnableConfig) -> list[AnyMessage]:  # (1)!
+    user_name = config.get("configurable", {}).get("user_name")
+    system_msg = f"You are a helpful assistant. Address the user as {user_name}."
+    return [{"role": "system", "content": system_msg}] + state["messages"]
+
+agent = create_react_agent(
+    model="anthropic:claude-3-7-sonnet-latest",
+    tools=[get_weather],
+    # highlight-next-line
+    prompt=prompt
+)
+
+agent.invoke(
+    {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
+    # highlight-next-line
+    config={"configurable": {"user_name": "John Smith"}}
+)
+```
+
+1. Dynamic prompts allow including non-message [context](./context.md) when constructing an input to the LLM, such as:
+
+    - Information passed at runtime, like a `user_id` or API credentials (using `config`).
+    - Internal agent state updated during a multi-step reasoning process (using `state`).
+
+    Dynamic prompts can be defined as functions that take `state` and `config` and return a list of messages to send to the LLM.
+
+See the [context](./context.md) page for more information.
+
+## Memory
+
+To allow multi-turn conversations with an agent, you need to enable [persistence](../concepts/persistence.md) by providing a `checkpointer` when creating an agent. At runtime you need to provide a config containing `thread_id` — a unique identifier for the conversation (session):
+
+```python
+from langgraph.prebuilt import create_react_agent
+from langgraph.checkpoint.memory import InMemorySaver
+
+# highlight-next-line
+checkpointer = InMemorySaver()
+
+agent = create_react_agent(
+    model="anthropic:claude-3-7-sonnet-latest",
+    tools=[get_weather],
+    # highlight-next-line
+    checkpointer=checkpointer  # (1)!
+)
+
+# Run the agent
+# highlight-next-line
+config = {"configurable": {"thread_id": "1"}}
+sf_response = agent.invoke(
+    {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
+    # highlight-next-line
+    config  # (2)!
+)
+ny_response = agent.invoke(
+    {"messages": [{"role": "user", "content": "what about new york?"}]},
+    # highlight-next-line
+    config
+)
+```
+
+1. `checkpointer` allows the agent to store its state at every step in the tool calling loop. This enables [short-term memory](./memory.md#short-term-memory) and [human-in-the-loop](./human-in-the-loop.md) capabilities.
+2. Pass configuration with `thread_id` to be able to resume the same conversation on future agent invocations.
+
+When you enable the checkpointer, it stores agent state at every step in the provided checkpointer database (or in memory, if using `InMemorySaver`).
+
+Note that in the above example, when the agent is invoked the second time with the same `thread_id`, the original message history from the first conversation is automatically included, together with the new user input.
+
+Please see the [memory guide](./memory.md) for more details on how to work with memory.
+
+
+## Structured output
+
+To produce structured responses conforming to a schema, use the `response_format` parameter. The schema can be defined with a `Pydantic` model or `TypedDict`. The result will be accessible via the `structured_response` field.
+
+```python
+from pydantic import BaseModel
+from langgraph.prebuilt import create_react_agent
+
+class WeatherResponse(BaseModel):
+    conditions: str
+
+agent = create_react_agent(
+    model="anthropic:claude-3-7-sonnet-latest",
+    tools=[get_weather],
+    # highlight-next-line
+    response_format=WeatherResponse  # (1)!
+)
+
+response = agent.invoke(
+    {"messages": [{"role": "user", "content": "what is the weather in sf"}]}
+)
+
+# highlight-next-line
+response["structured_response"]
+```
+
+1. When `response_format` is provided, a separate step is added at the end of the agent loop: agent message history is passed to an LLM with structured output to generate a structured response.
+
+    To provide a system prompt to this LLM, use a tuple `(prompt, schema)`, e.g., `response_format=(prompt, WeatherResponse)`.
+
+!!! Note "LLM post-processing"
+
+    Structured output requires an additional call to the LLM to format the response according to the schema.
+

docs/docs/agents/context.md

@@ -0,0 +1,287 @@
+# Context
+
+Agents often require more than a list of messages to function effectively. They need **context**.
+
+Context includes *any* data outside the message list that can shape agent behavior or tool execution. This can be:
+
+- Information passed at runtime, like a `user_id` or API credentials.
+- Internal state updated during a multi-step reasoning process.
+- Persistent memory or facts from previous interactions.
+
+LangGraph provides **three** primary ways to supply context:
+
+| Type                                                                         | Description                                   | Mutable? | Lifetime                |
+|------------------------------------------------------------------------------|-----------------------------------------------|----------|-------------------------|
+| [**Config**](#config-static-context)                                         | data passed at the start of a run             | ❌        | per run                 |
+| [**State**](#state-mutable-context)                                          | dynamic data that can change during execution | ✅        | per run or conversation |
+| [**Long-term Memory (Store)**](#long-term-memory-cross-conversation-context) | data that can be shared between conversations | ✅        | across conversations    |
+
+You can use context to:
+
+- Adjust the system prompt the model sees
+- Feed tools with necessary inputs
+- Track facts during an ongoing conversation
+
+## Providing Runtime Context
+
+Use this when you need to inject data into an agent at runtime.
+
+### Config (static context)
+
+Config is for immutable data like user metadata or API keys. Use
+when you have values that don't change mid-run.
+
+Specify configuration using a key called **"configurable"** which is reserved
+for this purpose:
+
+```python
+agent.invoke(
+    {"messages": [{"role": "user", "content": "hi!"}]},
+    # highlight-next-line
+    config={"configurable": {"user_id": "user_123"}}
+)
+```
+
+### State (mutable context)
+
+State acts as short-term memory during a run. It holds dynamic data that can evolve during execution, such as values derived from tools or LLM outputs.
+
+```python
+class CustomState(AgentState):
+    # highlight-next-line
+    user_name: str
+
+agent = create_react_agent(
+    # Other agent parameters...
+    # highlight-next-line
+    state_schema=CustomState,
+)
+
+agent.invoke({
+    "messages": "hi!",
+    "user_name": "Jane"
+})
+```
+
+!!! tip "Turning on memory"
+
+    Please see the [memory guide](./memory.md) for more details on how to enable memory. This is a powerful feature that allows you to persist the agent's state across multiple invocations.
+    Otherwise, the state is scoped only to a single agent run.
+
+
+
+### Long-Term Memory (cross-conversation context)
+
+For context that spans *across* conversations or sessions, LangGraph allows access to **long-term memory** via a `store`. This can be used to read or update persistent facts (e.g., user profiles, preferences, prior interactions). For more, see the [Memory guide](./memory.md).
+
+## Customizing Prompts with Context
+
+Prompts define how the agent behaves. To incorporate runtime context, you can dynamically generate prompts based on the agent's state or config.
+
+Common use cases:
+
+- Personalization
+- Role or goal customization
+- Conditional behavior (e.g., user is admin)
+
+=== "Using config"
+
+    ```python
+    from langchain_core.messages import AnyMessage
+    from langchain_core.runnables import RunnableConfig
+    from langgraph.prebuilt import create_react_agent
+    from langgraph.prebuilt.chat_agent_executor import AgentState
+
+    def prompt(
+        state: AgentState,
+        # highlight-next-line
+        config: RunnableConfig,
+    ) -> list[AnyMessage]:
+        # highlight-next-line
+        user_name = config.get("configurable", {}).get("user_name")
+        system_msg = f"You are a helpful assistant. User's name is {user_name}"
+        return [{"role": "system", "content": system_msg}] + state["messages"]
+
+    agent = create_react_agent(
+        model="anthropic:claude-3-7-sonnet-latest",
+        tools=[get_weather],
+        # highlight-next-line
+        prompt=prompt
+    )
+
+    agent.invoke(
+        ...,
+        # highlight-next-line
+        config={"configurable": {"user_name": "John Smith"}}
+    )
+    ```
+
+=== "Using state"
+
+    ```python
+    from langchain_core.messages import AnyMessage
+    from langchain_core.runnables import RunnableConfig
+    from langgraph.prebuilt import create_react_agent
+    from langgraph.prebuilt.chat_agent_executor import AgentState
+
+    class CustomState(AgentState):
+        # highlight-next-line
+        user_name: str
+
+    def prompt(
+        # highlight-next-line
+        state: CustomState
+    ) -> list[AnyMessage]:
+        # highlight-next-line
+        user_name = state["user_name"]
+        system_msg = f"You are a helpful assistant. User's name is {user_name}"
+        return [{"role": "system", "content": system_msg}] + state["messages"]
+
+    agent = create_react_agent(
+        model="anthropic:claude-3-7-sonnet-latest",
+        tools=[...],
+        # highlight-next-line
+        state_schema=CustomState,
+        # highlight-next-line
+        prompt=prompt
+    )
+
+    agent.invoke({
+        "messages": "hi!",
+        # highlight-next-line
+        "user_name": "John Smith"
+    })
+    ```
+
+## Tools
+
+Tools can access context through special parameter **annotations**.
+
+* Use `RunnableConfig` for config access
+* Use `Annotated[StateSchema, InjectedState]` for agent state
+
+
+!!! tip 
+
+    These annotations prevent LLMs from attempting to fill in the values. These parameters will be **hidden** from the LLM.
+
+=== "Using config"
+
+    ```python
+    def get_user_info(
+        # highlight-next-line
+        config: RunnableConfig,
+    ) -> str:
+        """Look up user info."""
+        # highlight-next-line
+        user_id = config.get("configurable", {}).get("user_id")
+        return "User is John Smith" if user_id == "user_123" else "Unknown user"
+
+    agent = create_react_agent(
+        model="anthropic:claude-3-7-sonnet-latest",
+        tools=[get_user_info],
+    )
+
+    agent.invoke(
+        {"messages": [{"role": "user", "content": "look up user information"}]},
+        # highlight-next-line
+        config={"configurable": {"user_id": "user_123"}}
+    )
+    ```
+
+=== "Using State"
+
+    ```python
+    from typing import Annotated
+    from langgraph.prebuilt import InjectedState
+
+    class CustomState(AgentState):
+        # highlight-next-line
+        user_id: str
+
+    def get_user_info(
+        # highlight-next-line
+        state: Annotated[CustomState, InjectedState]
+    ) -> str:
+        """Look up user info."""
+        # highlight-next-line
+        user_id = state["user_id"]
+        return "User is John Smith" if user_id == "user_123" else "Unknown user"
+
+    agent = create_react_agent(
+        model="anthropic:claude-3-7-sonnet-latest",
+        tools=[get_user_info],
+        # highlight-next-line
+        state_schema=CustomState,
+    )
+
+    agent.invoke({
+        "messages": "look up user information",
+        # highlight-next-line
+        "user_id": "user_123"
+    })
+    ```
+
+
+## Update context from tools
+
+Tools can modify the agent's state during execution. This is useful for persisting intermediate results or making information accessible to subsequent tools or prompts.
+
+```python
+from typing import Annotated
+from langchain_core.tools import InjectedToolCallId
+from langchain_core.messages import ToolMessage
+from langgraph.prebuilt import InjectedState
+from langgraph.types import Command
+
+class CustomState(AgentState):
+    # highlight-next-line
+    user_name: str
+
+def get_user_info(
+    # highlight-next-line
+    tool_call_id: Annotated[str, InjectedToolCallId],
+    # highlight-next-line
+    config: RunnableConfig
+) -> Command:
+    """Look up user info."""
+    # highlight-next-line
+    user_id = config.get("configurable", {}).get("user_id")
+    name = "John Smith" if user_id == "user_123" else "Unknown user"
+    return Command(update={
+        # highlight-next-line
+        "user_name": name,
+        # update the message history
+        # highlight-next-line
+        "messages": [
+            ToolMessage(
+                "Successfully looked up user information",
+                # highlight-next-line
+                tool_call_id=tool_call_id
+            )
+        ]
+    })
+
+def greet(
+    # highlight-next-line
+    state: Annotated[CustomState, InjectedState]
+) -> str:
+    """Use this to greet the user once you found their info."""
+    user_name = state["user_name"]
+    return f"Hello {user_name}!"
+
+agent = create_react_agent(
+    model="anthropic:claude-3-7-sonnet-latest",
+    tools=[get_user_info, greet],
+    # highlight-next-line
+    state_schema=CustomState
+)
+
+agent.invoke(
+    {"messages": [{"role": "user", "content": "greet the user"}]},
+    # highlight-next-line
+    config={"configurable": {"user_id": "user_123"}}
+)
+```
+
+For more details, see [how to update state from tools](../how-tos/update-state-from-tools.ipynb).

docs/docs/agents/deployment.md

@@ -0,0 +1,83 @@
+# Deployment
+
+To deploy your LangGraph agent, create and configure a LangGraph app. This setup supports both local development and production deployments.
+
+Features: 
+
+* 🖥️ Local server for development
+* 🧩 Studio Web UI for visual debugging
+* ☁️ Cloud and 🔧 self-hosted deployment options
+* 📊 LangSmith integration for tracing and observability
+
+!!! info "Requirements" 
+
+    - ✅ You **must** have a [LangSmith account](https://www.langchain.com/langsmith). You can sign up for **free** and get started with the free tier.
+
+## Create a LangGraph app
+
+```bash
+pip install -U "langgraph-cli[inmem]"
+langgraph new path/to/your/app --template new-langgraph-project-python
+```
+
+This will create an empty LangGraph project. You can modify it by replacing the code in `src/agent/graph.py` with your agent code. For example:
+
+```python
+from langgraph.prebuilt import create_react_agent
+
+def get_weather(city: str) -> str:
+    """Get weather for a given city."""
+    return f"It's always sunny in {city}!"
+
+graph = create_react_agent(
+    model="anthropic:claude-3-7-sonnet-latest",
+    tools=[get_weather],
+    prompt="You are a helpful assistant"
+)
+```
+
+### Install dependencies
+
+In the root of your new LangGraph app, install the dependencies in `edit` mode so your local changes are used by the server:
+
+```shell
+pip install -e .
+```
+
+### Create an `.env` file
+
+You will find a `.env.example` in the root of your new LangGraph app. Create
+a `.env` file in the root of your new LangGraph app and copy the contents of the `.env.example` file into it, filling in the necessary API keys:
+
+```bash
+LANGSMITH_API_KEY=lsv2...
+ANTHROPIC_API_KEY=sk-
+```
+
+## Launch LangGraph server locally
+
+```shell
+langgraph dev
+```
+
+This will start up the LangGraph API server locally. If this runs successfully, you should see something like:
+
+>    Ready!
+> 
+>    - API: [http://localhost:2024](http://localhost:2024/)
+>     
+>    - Docs: http://localhost:2024/docs
+>     
+>    - LangGraph Studio Web UI: https://smith.langchain.com/studio/?baseUrl=http://127.0.0.1:2024
+
+See this [tutorial](https://langchain-ai.github.io/langgraph/tutorials/langgraph-platform/local-server/) to learn more about running LangGraph app locally.
+
+## LangGraph Studio Web UI
+
+LangGraph Studio Web is a specialized UI that you can connect to LangGraph API server to enable visualization, interaction, and debugging of your application locally. Test your graph in the LangGraph Studio Web UI by visiting the URL provided in the output of the `langgraph dev` command.
+
+>    - LangGraph Studio Web UI: https://smith.langchain.com/studio/?baseUrl=http://127.0.0.1:2024
+
+## Deployment
+
+Once your LangGraph app is running locally, you can deploy it using LangGraph Cloud or self-hosted options. Refer to the [deployment options guide](../tutorials/deployment.md) for detailed instructions on all supported deployment models.

docs/docs/agents/evals.md

@@ -0,0 +1,119 @@
+# Evals
+
+To evaluate your agent's performance you can use `LangSmith` [evaluations](https://docs.smith.langchain.com/evaluation). You would need to first define an evaluator function to judge the results from an agent, such as final outputs or trajectory. Depending on your evaluation technique, this may or may not involve a reference output:
+
+```python
+def evaluator(*, outputs: dict, reference_outputs: dict):
+    # compare agent outputs against reference outputs
+    output_messages = outputs["messages"]
+    reference_messages = reference["messages"]
+    score = compare_messages(output_messages, reference_messages)
+    return {"key": "evaluator_score", "score": score}
+```
+
+To get started, you can use prebuilt evaluators from `AgentEvals` package:
+
+```bash
+pip install -U agentevals
+```
+
+## Create evaluator
+
+A common way to evaluate agent performance is by comparing its trajectory (the order in which it calls its tools) against a reference trajectory:
+
+```python
+import json
+# highlight-next-line
+from agentevals.trajectory.match import create_trajectory_match_evaluator
+
+outputs = [
+    {
+        "role": "assistant",
+        "tool_calls": [
+            {
+                "function": {
+                    "name": "get_weather",
+                    "arguments": json.dumps({"city": "san francisco"}),
+                }
+            },
+            {
+                "function": {
+                    "name": "get_directions",
+                    "arguments": json.dumps({"destination": "presidio"}),
+                }
+            }
+        ],
+    }
+]
+reference_outputs = [
+    {
+        "role": "assistant",
+        "tool_calls": [
+            {
+                "function": {
+                    "name": "get_weather",
+                    "arguments": json.dumps({"city": "san francisco"}),
+                }
+            },
+        ],
+    }
+]
+
+# Create the evaluator
+evaluator = create_trajectory_match_evaluator(
+    # highlight-next-line
+    trajectory_match_mode="superset",  # (1)!
+)
+
+# Run the evaluator
+result = evaluator(
+    outputs=outputs, reference_outputs=reference_outputs
+)
+```
+
+1. Specify how the trajectories will be compared. `superset` will accept output trajectory as valid if it's a superset of the reference one. Other options include: [strict](https://github.com/langchain-ai/agentevals?tab=readme-ov-file#strict-match), [unordered](https://github.com/langchain-ai/agentevals?tab=readme-ov-file#unordered-match) and [subset](https://github.com/langchain-ai/agentevals?tab=readme-ov-file#subset-and-superset-match)
+
+
+As a next step, learn more about how to [customize trajectory match evaluator](https://github.com/langchain-ai/agentevals?tab=readme-ov-file#agent-trajectory-match).
+
+### LLM-as-a-judge
+
+You can use LLM-as-a-judge evaluator that uses an LLM to compare the trajectory against the reference outputs and output a score:
+
+```python
+import json
+from agentevals.trajectory.llm import (
+    # highlight-next-line
+    create_trajectory_llm_as_judge,
+    TRAJECTORY_ACCURACY_PROMPT_WITH_REFERENCE
+)
+
+evaluator = create_trajectory_llm_as_judge(
+    prompt=TRAJECTORY_ACCURACY_PROMPT_WITH_REFERENCE,
+    model="openai:o3-mini"
+)
+```
+
+## Run evaluator
+
+To run an evaluator, you will first need to create a [LangSmith dataset](https://docs.smith.langchain.com/evaluation/concepts#datasets). To use the prebuilt AgentEvals evaluators, you will need a dataset with the following schema:
+
+- **input**: `{"messages": [...]}` input messages to call the agent with.
+- **output**: `{"messages": [...]}` expected message history in the agent output. For trajectory evaluation, you can choose to keep only assistant messages.
+
+```python
+from langsmith import Client
+from langgraph.prebuilt import create_react_agent
+from agentevals.trajectory.match import create_trajectory_match_evaluator
+
+client = Client()
+agent = create_react_agent(...)
+evaluator = create_trajectory_match_evaluator(...)
+
+experiment_results = client.evaluate(
+    lambda inputs: agent.invoke(inputs),
+    # replace with your dataset name
+    data="<Name of your dataset>",
+    evaluators=[evaluator]
+)
+```

docs/docs/agents/human-in-the-loop.md

@@ -0,0 +1,227 @@
+# Human-in-the-loop
+
+To review, edit and approve tool calls in an agent you can use LangGraph's built-in [human-in-the-loop](../concepts/human_in_the_loop.md) features, specifically the [`interrupt()`][langgraph.types.interrupt] primitive.
+
+LangGraph allows you to pause execution **indefinitely** — for minutes, hours, or even days—until human input is received.
+
+This is possible because the agent state is **checkpointed into a database**, which allows the system to persist execution context and later resume the workflow, continuing from where it left off.
+
+For a deeper dive into the **human-in-the-loop** concept, see the [concept guide](../concepts/human_in_the_loop.md).
+
+<figure markdown="1">
+![image](../concepts/img/human_in_the_loop/tool-call-review.png){: style="max-height:400px"}
+<figcaption>
+A human can review and edit the output from the agent before proceeding. This is particularly critical in applications where the tool calls requested may be sensitive or require human oversight.
+</figcaption>
+</figure>
+
+
+## Review tool calls
+
+To add a human approval step to a tool:
+
+1. Use `interrupt()` in the tool to pause execution.
+2. Resume with a `Command(resume=...)` to continue based on human input.
+
+```python
+from langgraph.checkpoint.memory import InMemorySaver
+from langgraph.types import interrupt
+from langgraph.prebuilt import create_react_agent
+
+# An example of a sensitive tool that requires human review / approval
+def book_hotel(hotel_name: str):
+    """Book a hotel"""
+    # highlight-next-line
+    response = interrupt(  # (1)!
+        f"Trying to call `book_hotel` with args {{'hotel_name': {hotel_name}}}. "
+        "Please approve or suggest edits."
+    )
+    if response["type"] == "accept":
+        pass
+    elif response["type"] == "edit":
+        hotel_name = response["args"]["hotel_name"]
+    else:
+        raise ValueError(f"Unknown response type: {response['type']}")
+    return f"Successfully booked a stay at {hotel_name}."
+
+# highlight-next-line
+checkpointer = InMemorySaver() # (2)!
+
+agent = create_react_agent(
+    model="anthropic:claude-3-5-sonnet-latest",
+    tools=[book_hotel],
+    # highlight-next-line
+    checkpointer=checkpointer, # (3)!
+)
+```
+
+1. The [`interrupt` function][langgraph.types.interrupt] pauses the agent graph at a specific node. In this case, we call `interrupt()` at the beginning of the tool function, which pauses the graph at the node that executes the tool. The information inside `interrupt()` (e.g., tool calls) can be presented to a human, and the graph can be resumed with the user input (tool call approval, edit or feedback).
+2. The `InMemorySaver` is used to store the agent state at every step in the tool calling loop. This enables [short-term memory](./memory.md#short-term-memory) and [human-in-the-loop](./human-in-the-loop.md) capabilities. In this example, we use `InMemorySaver` to store the agent state in memory. In a production application, the agent state will be stored in a database.
+3. Initialize the agent with the `checkpointer`.
+
+Run the agent with the `stream()` method, passing the `config` object to specify the thread ID. This allows the agent to resume the same conversation on future invocations.
+
+```python
+config = {
+   "configurable": {
+      # highlight-next-line
+      "thread_id": "1"
+   }
+}
+
+for chunk in agent.stream(
+    {"messages": [{"role": "user", "content": "book a stay at McKittrick hotel"}]},
+    # highlight-next-line
+    config
+):
+    print(chunk)
+    print("\n")
+```
+
+> You should see that the agent runs until it reaches the `interrupt()` call, at which point it pauses and waits for human input.
+
+Resume the agent with a `Command(resume=...)` to continue based on human input.
+
+```python
+from langgraph.types import Command
+
+for chunk in agent.stream(
+    # highlight-next-line
+    Command(resume={"type": "accept"}),  # (1)!
+    # Command(resume={"type": "edit", "args": {"hotel_name": "McKittrick Hotel"}}),
+    config
+):
+    print(chunk)
+    print("\n")
+```
+
+1. The [`interrupt` function][langgraph.types.interrupt] is used in conjunction with the [`Command`](../reference/types.md#langgraph.types.Command) object to resume the graph with a value provided by the human.
+
+## Using with Agent Inbox
+
+You can create a wrapper to add interrupts to *any* tool. 
+
+The example below provides a reference implementation compatible with [Agent Inbox UI](https://github.com/langchain-ai/agent-inbox) and [Agent Chat UI](https://github.com/langchain-ai/agent-chat-ui).
+
+```python title="Wrapper that adds human-in-the-loop to any tool"
+from typing import Callable
+from langchain_core.tools import BaseTool, tool as create_tool
+from langchain_core.runnables import RunnableConfig
+from langgraph.types import interrupt 
+from langgraph.prebuilt.interrupt import HumanInterruptConfig, HumanInterrupt
+
+def add_human_in_the_loop(
+    tool: Callable | BaseTool,
+    *,
+    interrupt_config: HumanInterruptConfig = None,
+) -> BaseTool:
+   """Wrap a tool to support human-in-the-loop review.""" 
+    if not isinstance(tool, BaseTool):
+        tool = create_tool(tool)
+
+    if interrupt_config is None:
+        interrupt_config = {
+            "allow_accept": True,
+            "allow_edit": True,
+            "allow_respond": True,
+        }
+
+    @create_tool(  # (1)!
+        tool.name,
+        description=tool.description,
+        args_schema=tool.args_schema
+    )
+    def call_tool_with_interrupt(config: RunnableConfig, **tool_input):
+        request: HumanInterrupt = {
+            "action_request": {
+                "action": tool.name,
+                "args": tool_input
+            },
+            "config": interrupt_config,
+            "description": "Please review the tool call"
+        }
+        # highlight-next-line
+        response = interrupt([request])[0]  # (2)!
+        # approve the tool call
+        if response["type"] == "accept":
+            tool_response = tool.invoke(tool_input, config)
+        # update tool call args
+        elif response["type"] == "edit":
+            tool_input = response["args"]["args"]
+            tool_response = tool.invoke(tool_input, config)
+        # respond to the LLM with user feedback
+        elif response["type"] == "response":
+            user_feedback = response["args"]
+            tool_response = user_feedback
+        else:
+            raise ValueError(f"Unsupported interrupt response type: {response['type']}")
+
+        return tool_response
+
+    return call_tool_with_interrupt
+```
+
+1. This wrapper creates a new tool that calls `interrupt()` **before** executing the wrapped tool.
+2. `interrupt()` is using special input and output format that's expected by [Agent Inbox UI](https://github.com/langchain-ai/agent-inbox):
+    - a list of [`HumanInterrupt`][langgraph.prebuilt.interrupt.HumanInterrupt] objects is sent to `AgentInbox` render interrupt information to the end user
+    - resume value is provided by `AgentInbox` as a list (i.e., `Command(resume=[...])`)
+
+You can use the `add_human_in_the_loop` wrapper to add `interrupt()` to any tool without having to add it *inside* the tool:
+
+```python
+from langgraph.checkpoint.memory import InMemorySaver
+from langgraph.prebuilt import create_react_agent
+
+# highlight-next-line
+checkpointer = InMemorySaver()
+
+def book_hotel(hotel_name: str):
+   """Book a hotel"""
+   return f"Successfully booked a stay at {hotel_name}."
+
+
+agent = create_react_agent(
+    model="anthropic:claude-3-5-sonnet-latest",
+    tools=[
+        # highlight-next-line
+        add_human_in_the_loop(book_hotel), # (1)!
+    ],
+    # highlight-next-line
+    checkpointer=checkpointer,
+)
+
+config = {"configurable": {"thread_id": "1"}}
+
+# Run the agent
+for chunk in agent.stream(
+    {"messages": [{"role": "user", "content": "book a stay at McKittrick hotel"}]},
+    # highlight-next-line
+    config
+):
+    print(chunk)
+    print("\n")
+```
+
+1. The `add_human_in_the_loop` wrapper is used to add `interrupt()` to the tool. This allows the agent to pause execution and wait for human input before proceeding with the tool call.
+
+> You should see that the agent runs until it reaches the `interrupt()` call, 
+>  at which point it pauses and waits for human input.
+
+Resume the agent with a `Command(resume=...)`  to continue based on human input.
+
+```python
+from langgraph.types import Command 
+
+for chunk in agent.stream(
+    # highlight-next-line
+    Command(resume=[{"type": "accept"}]),
+    # Command(resume=[{"type": "edit", "args": {"args": {"hotel_name": "McKittrick Hotel"}}}]),
+    config
+):
+    print(chunk)
+    print("\n")
+```
+
+## Additional resources
+
+* [Human-in-the-loop in LangGraph](../concepts/human_in_the_loop.md)

docs/docs/agents/mcp.md

@@ -0,0 +1,98 @@
+# MCP Integration
+
+[Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction) is an open protocol that standardizes how applications provide tools and context to language models. LangGraph agents can use tools defined on MCP servers through the `langchain-mcp-adapters` library.
+
+![MCP](./assets/mcp.png)
+
+Install the `langchain-mcp-adapters` library to use MCP tools in LangGraph:
+
+```bash
+pip install langchain-mcp-adapters
+```
+
+## Use MCP tools
+
+The `langchain-mcp-adapters` package enables agents to use tools defined across one or more MCP servers.
+
+```python title="Agent using tools defined on MCP servers"
+# highlight-next-line
+from langchain_mcp_adapters.client import MultiServerMCPClient
+from langgraph.prebuilt import create_react_agent
+
+# highlight-next-line
+async with MultiServerMCPClient(
+    {
+        "math": {
+            "command": "python",
+            # Replace with absolute path to your math_server.py file
+            "args": ["/path/to/math_server.py"],
+            "transport": "stdio",
+        },
+        "weather": {
+            # Ensure your start your weather server on port 8000
+            "url": "http://localhost:8000/sse",
+            "transport": "sse",
+        }
+    }
+) as client:
+    agent = create_react_agent(
+        "anthropic:claude-3-7-sonnet-latest",
+        # highlight-next-line
+        client.get_tools()
+    )
+    math_response = await agent.ainvoke(
+        {"messages": [{"role": "user", "content": "what's (3 + 5) x 12?"}]}
+    )
+    weather_response = await agent.ainvoke(
+        {"messages": [{"role": "user", "content": "what is the weather in nyc?"}]}
+    )
+```
+
+## Custom MCP servers
+
+To create your own MCP servers, you can use the `mcp` library. This library provides a simple way to define tools and run them as servers.
+
+Install the MCP library:
+
+```bash
+pip install mcp
+```
+Use the following reference implementations to test your agent with MCP tool servers.
+
+```python title="Example Math Server (stdio transport)"
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP("Math")
+
+@mcp.tool()
+def add(a: int, b: int) -> int:
+    """Add two numbers"""
+    return a + b
+
+@mcp.tool()
+def multiply(a: int, b: int) -> int:
+    """Multiply two numbers"""
+    return a * b
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")
+```
+
+```python title="Example Weather Server (SSE transport)"
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP("Weather")
+
+@mcp.tool()
+async def get_weather(location: str) -> str:
+    """Get weather for location."""
+    return "It's always sunny in New York"
+
+if __name__ == "__main__":
+    mcp.run(transport="sse")
+```
+
+## Additional resources
+
+- [MCP documentation](https://modelcontextprotocol.io/introduction)
+- [MCP Transport documentation](https://modelcontextprotocol.io/docs/concepts/transports)

docs/docs/agents/memory.md

@@ -0,0 +1,262 @@
+# Memory
+
+LangGraph supports two types of memory essential for building conversational agents:
+
+- **[Short-term memory](#short-term-memory)**: Tracks the ongoing conversation by maintaining message history within a session.
+- **[Long-term memory](#long-term-memory)**: Stores user-specific or application-level data across sessions.
+
+This guide demonstrates how to use both memory types with agents in LangGraph. For a deeper
+understanding of memory concepts, refer to the [LangGraph memory documentation](../concepts/memory.md).
+
+<figure markdown="1">
+![image](./assets/memory.png){: style="max-height:400px"}
+<figcaption>Both <strong>short-term</strong> and <strong>long-term</strong> memory require persistent storage to maintain continuity across LLM interactions. In production environments, this data is typically stored in a database.</figcaption>
+</figure>
+
+!!! note "Terminology"
+
+    In LangGraph:
+
+    - *Short-term memory* is also referred to as **thread-level memory**.
+    - *Long-term memory* is also called **cross-thread memory**.
+
+    A [thread](../concepts/persistence.md#threads) represents a sequence of related runs
+    grouped by the same `thread_id`.
+
+## Short-term memory
+
+Short-term memory enables agents to track multi-turn conversations. To use it, you must:
+
+1. Provide a `checkpointer` when creating the agent. The `checkpointer` enables [persistence](../concepts/persistence.md) of the agent's state.
+2. Supply a `thread_id` in the config when running the agent. The `thread_id` is a unique identifier for the conversation session.
+
+```python
+from langgraph.prebuilt import create_react_agent
+from langgraph.checkpoint.memory import InMemorySaver
+
+# highlight-next-line
+checkpointer = InMemorySaver() # (1)!
+
+
+def get_weather(city: str) -> str:
+    """Get weather for a given city."""
+    return f"It's always sunny in {city}!"
+
+
+agent = create_react_agent(
+    model="anthropic:claude-3-7-sonnet-latest",
+    tools=[get_weather],
+    # highlight-next-line
+    checkpointer=checkpointer # (2)!
+)
+
+# Run the agent
+config = {
+    "configurable": {
+        # highlight-next-line
+        "thread_id": "1"  # (3)!
+    }
+}
+
+sf_response = agent.invoke(
+    {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
+    # highlight-next-line
+    config
+)
+
+# Continue the conversation using the same thread_id
+ny_response = agent.invoke(
+    {"messages": [{"role": "user", "content": "what about new york?"}]},
+    # highlight-next-line
+    config # (4)!
+)
+```
+
+1. The `InMemorySaver` is a checkpointer that stores the agent's state in memory. In a production setting, you would typically use a database or other persistent storage. Please review the [checkpointer documentation](../reference/checkpoints.md) for more options. If you're deploying with **LangGraph Platform**, the platform will provide a production-ready checkpointer for you.
+2. The `checkpointer` is passed to the agent. This enables the agent to persist its state across invocations. Please note that 
+3. A unique `thread_id` is provided in the config. This ID is used to identify the conversation session. The value is controlled by the user and can be any string.
+4. The agent will continue the conversation using the same `thread_id`. This will allow the agent to infer that the user is asking specifically about the **weather** in New York. 
+
+When the agent is invoked the second time with the same `thread_id`, the original message history from the first conversation is automatically included, allowing the agent to infer that the user is asking specifically about the **weather** in New York.
+
+!!! Note "LangGraph Platform providers a production-ready checkpointer"
+
+    If you're using [LangGraph Platform](./deployment.md), during deployment your checkpointer will be automatically configured to use a production-ready database.
+
+### Message history summarization 
+
+<figure markdown="1">
+![image](./assets/summary.png){: style="max-height:400px"}
+<figcaption>Message history can grow quickly and exceed the LLM's context window. A common solution is to maintain a running summary of the conversation. This allows the agent to keep track of the conversation without exceeding the LLM's context window.
+</figcaption>
+</figure>
+
+Long conversations can exceed the LLM's context window. To handle this, you can summarize older messages by specifying a [`pre_model_hook`][langgraph.prebuilt.chat_agent_executor.create_react_agent], such as the prebuilt [`SummarizationNode`](https://langchain-ai.github.io/langmem/reference/short_term/#langmem.short_term.SummarizationNode):
+
+```python
+from langchain_anthropic import ChatAnthropic
+from langmem.short_term import SummarizationNode
+from langchain_core.messages.utils import count_tokens_approximately
+from langgraph.prebuilt import create_react_agent
+from langgraph.prebuilt.chat_agent_executor import AgentState
+from langgraph.checkpoint.memory import InMemorySaver
+from typing import Any
+
+model = ChatAnthropic(model="claude-3-7-sonnet-latest")
+
+summarization_node = SummarizationNode( # (1)!
+    token_counter=count_tokens_approximately,
+    model=model,
+    max_tokens=384,
+    max_summary_tokens=128,
+    output_messages_key="llm_input_messages",
+)
+
+class State(AgentState):
+    # NOTE: we're adding this key to keep track of previous summary information
+    # to make sure we're not summarizing on every LLM call
+    # highlight-next-line
+    context: dict[str, Any]  # (2)!
+
+
+checkpointer = InMemorySaver() # (3)!
+
+agent = create_react_agent(
+    model=model,
+    tools=tools,
+    # highlight-next-line
+    pre_model_hook=summarization_node, # (4)!
+    # highlight-next-line
+    state_schema=State, # (5)!
+    checkpointer=checkpointer,
+)
+```
+
+1. The `InMemorySaver` is a checkpointer that stores the agent's state in memory. In a production setting, you would typically use a database or other persistent storage. Please review the [checkpointer documentation](../reference/checkpoints.md) for more options. If you're deploying with **LangGraph Platform**, the platform will provide a production-ready checkpointer for you.
+2. The `context` key is added to the agent's state. The key contains book-keeping information for the summarization node. It is used to keep track of the last summary information and ensure that the agent doesn't summarize on every LLM call, which can be inefficient.
+3. The `checkpointer` is passed to the agent. This enables the agent to persist its state across invocations.
+4. The `pre_model_hook` is set to the `SummarizationNode`. This node will summarize the message history before sending it to the LLM. The summarization node will automatically handle the summarization process and update the agent's state with the new summary. You can replace this with a custom implementation if you prefer. Please see the [create_react_agent][langgraph.prebuilt.chat_agent_executor.create_react_agent] API reference for more details.
+5. The `state_schema` is set to the `State` class, which is the custom state that contains an extra `context` key.
+
+To learn more about using `pre_model_hook` for managing message history, see this [how-to guide](../how-tos/create-react-agent-manage-message-history.ipynb)
+
+## Long-term memory
+
+Use long-term memory to store user-specific or application-specific data across conversations. This is useful for applications like chatbots, where you want to remember user preferences or other information.
+
+To use long-term memory, you need to:
+
+1. [Configure a store](../how-tos/cross-thread-persistence.ipynb) to persist data across invocations.
+2. Use the [`get_store`][langgraph.config.get_store] function to access the store from within tools or prompts.
+
+### Reading
+
+```python title="A tool the agent can use to look up user information"
+from langgraph.config import get_store
+from langgraph.prebuilt import create_react_agent
+from langgraph.store.memory import InMemoryStore
+
+# highlight-next-line
+store = InMemoryStore() # (1)!
+
+# highlight-next-line
+store.put(  # (2)!
+    ("users",),  # (3)!
+    "user_123",  # (4)!
+    {
+        "name": "John Smith",
+        "language": "English",
+    } # (5)!
+)
+
+def get_user_info(config: RunnableConfig) -> str:
+    """Look up user info."""
+    # Same as that provided to `create_react_agent`
+    # highlight-next-line
+    store = get_store() # (6)!
+    user_id = config.get("configurable", {}).get("user_id")
+    # highlight-next-line
+    user_info = store.get(("users",), user_id) # (7)!
+    return str(user_info.value) if user_info else "Unknown user"
+
+agent = create_react_agent(
+    model="anthropic:claude-3-7-sonnet-latest",
+    tools=[get_user_info],
+    # highlight-next-line
+    store=store # (8)!
+)
+
+# Run the agent
+agent.invoke(
+    {"messages": [{"role": "user", "content": "look up user information"}]},
+    # highlight-next-line
+    config={"configurable": {"user_id": "user_123"}}
+)
+```
+
+1. The `InMemoryStore` is a store that stores data in memory. In a production setting, you would typically use a database or other persistent storage. Please review the [store documentation](../reference/stores.md) for more options. If you're deploying with **LangGraph Platform**, the platform will provide a production-ready store for you.
+2. For this example, we write some sample data to the store using the `put` method. Please see the [BaseStore.put][langgraph.store.base.BaseStore.put] API reference for more details.
+3. The first argument is the namespace. This is used to group related data together. In this case, we are using the `users` namespace to group user data.
+4. A key within the namespace. This example uses a user ID for the key.
+5. The data that we want to store for the given user.
+6. The `get_store` function is used to access the store. You can call it from anywhere in your code, including tools and prompts. This function returns the store that was passed to the agent when it was created.
+7. The `get` method is used to retrieve data from the store. The first argument is the namespace, and the second argument is the key. This will return a `StoreValue` object, which contains the value and metadata about the value.
+8. The `store` is passed to the agent. This enables the agent to access the store when running tools. You can also use the `get_store` function to access the store from anywhere in your code.
+
+### Writing
+
+```python title="Example of a tool that updates user information"
+from typing_extensions import TypedDict
+
+from langgraph.config import get_store
+from langgraph.prebuilt import create_react_agent
+from langgraph.store.memory import InMemoryStore
+
+store = InMemoryStore() # (1)!
+
+class UserInfo(TypedDict): # (2)!
+    name: str
+
+def save_user_info(user_info: UserInfo, config: RunnableConfig) -> str: # (3)!
+    """Save user info."""
+    # Same as that provided to `create_react_agent`
+    # highlight-next-line
+    store = get_store() # (4)!
+    user_id = config.get("configurable", {}).get("user_id")
+    # highlight-next-line
+    store.put(("users",), user_id, user_info) # (5)!
+    return "Successfully saved user info."
+
+agent = create_react_agent(
+    model="anthropic:claude-3-7-sonnet-latest",
+    tools=[save_user_info],
+    # highlight-next-line
+    store=store
+)
+
+# Run the agent
+agent.invoke(
+    {"messages": [{"role": "user", "content": "My name is John Smith"}]},
+    # highlight-next-line
+    config={"configurable": {"user_id": "user_123"}} # (6)!
+)
+
+# You can access the store directly to get the value
+store.get(("users",), "user_123").value
+```
+
+1. The `InMemoryStore` is a store that stores data in memory. In a production setting, you would typically use a database or other persistent storage. Please review the [store documentation](../reference/stores.md) for more options. If you're deploying with **LangGraph Platform**, the platform will provide a production-ready store for you.
+2. The `UserInfo` class is a `TypedDict` that defines the structure of the user information. The LLM will use this to format the response according to the schema.
+3. The `save_user_info` function is a tool that allows an agent to update user information. This could be useful for a chat application where the user wants to update their profile information.
+4. The `get_store` function is used to access the store. You can call it from anywhere in your code, including tools and prompts. This function returns the store that was passed to the agent when it was created.
+5. The `put` method is used to store data in the store. The first argument is the namespace, and the second argument is the key. This will store the user information in the store.
+6. The `user_id` is passed in the config. This is used to identify the user whose information is being updated.
+
+### Prebuilt memory tools
+
+**LangMem** is a LangChain-maintained library that offers tools for managing long-term memories in your agent. See the [LangMem documentation](https://langchain-ai.github.io/langmem/) for usage examples.
+
+
+## Additional resources
+
+* [Memory in LangGraph](../concepts/memory.md)

docs/docs/agents/models.md

@@ -0,0 +1,69 @@
+# Models
+
+This page describes how to configure the chat model used by an agent.
+
+## Tool calling support
+
+To enable tool-calling agents, the underlying LLM must support [tool calling](https://python.langchain.com/docs/concepts/tool_calling/).
+
+Compatible models can be found in the [LangChain integrations directory](https://python.langchain.com/docs/integrations/chat/).
+
+## Specifying a model by name
+
+You can configure an agent with a model name string:
+
+```python
+from langgraph.prebuilt import create_react_agent
+
+agent = create_react_agent(
+    # highlight-next-line
+    model="anthropic:claude-3-7-sonnet-latest",
+    # other parameters
+)
+```
+
+## Using `init_chat_model`
+
+The [`init_chat_model`](https://python.langchain.com/docs/how_to/chat_models_universal_init/) utility simplifies model initialization with configurable parameters:
+
+```python
+from langchain.chat_models import init_chat_model
+
+model = init_chat_model(
+    "anthropic:claude-3-7-sonnet-latest",
+    temperature=0,
+    max_tokens=2048
+)
+```
+
+Refer to the [API reference](https://python.langchain.com/api_reference/langchain/chat_models/langchain.chat_models.base.init_chat_model.html) for advanced options.
+
+## Using provider-specific LLMs 
+
+If a model provider is not available via `init_chat_model`, you can instantiate the provider's model class directly. The model must implement the [BaseChatModel interface](https://python.langchain.com/api_reference/core/language_models/langchain_core.language_models.chat_models.BaseChatModel.html) and support tool calling:
+
+```python
+from langchain_anthropic import ChatAnthropic
+from langgraph.prebuilt import create_react_agent
+
+model = ChatAnthropic(
+    model="claude-3-7-sonnet-latest",
+    temperature=0,
+    max_tokens=2048
+)
+
+agent = create_react_agent(
+    # highlight-next-line
+    model=model,
+    # other parameters
+)
+```
+
+!!! note "Illustrative example" 
+
+    The example above uses `ChatAnthropic`, which is already supported by `init_chat_model`. This pattern is shown to illustrate how to manually instantiate a model not available through init_chat_model.
+
+## Additional resources
+
+- [Model integration directory](https://python.langchain.com/docs/integrations/chat/)
+- [Universal initialization with `init_chat_model`](https://python.langchain.com/docs/how_to/chat_models_universal_init/)

docs/docs/agents/multi-agent.md

@@ -0,0 +1,299 @@
+# Multi-agent
+
+A single agent might struggle if it needs to specialize in multiple domains or manage many tools. To tackle this, you can break your agent into smaller, independent agents and composing them into a [multi-agent system](../concepts/multi_agent.md).
+
+In multi-agent systems, agents need to communicate between each other. They do so via [handoffs](#handoffs) — a primitive that describes which agent to hand control to and the payload to send to that agent.
+
+Two of the most popular multi-agent architectures are:
+
+- [supervisor](#supervisor) — individual agents are coordinated by a central supervisor agent. The supervisor controls all communication flow and task delegation, making decisions about which agent to invoke based on the current context and task requirements.
+- [swarm](#swarm) — agents dynamically hand off control to one another based on their specializations. The system remembers which agent was last active, ensuring that on subsequent interactions, the conversation resumes with that agent.
+
+## Supervisor
+
+![Supervisor](./assets/supervisor.png)
+
+Use [`langgraph-supervisor`](https://github.com/langchain-ai/langgraph-supervisor-py) library to create a supervisor multi-agent system:
+
+```bash
+pip install langgraph-supervisor
+```
+
+```python
+from langchain_openai import ChatOpenAI
+from langgraph.prebuilt import create_react_agent
+# highlight-next-line
+from langgraph_supervisor import create_supervisor
+
+def book_hotel(hotel_name: str):
+    """Book a hotel"""
+    return f"Successfully booked a stay at {hotel_name}."
+
+def book_flight(from_airport: str, to_airport: str):
+    """Book a flight"""
+    return f"Successfully booked a flight from {from_airport} to {to_airport}."
+
+flight_assistant = create_react_agent(
+    model="openai:gpt-4o",
+    tools=[book_flight],
+    prompt="You are a flight booking assistant",
+    # highlight-next-line
+    name="flight_assistant"
+)
+
+hotel_assistant = create_react_agent(
+    model="openai:gpt-4o",
+    tools=[book_hotel],
+    prompt="You are a hotel booking assistant",
+    # highlight-next-line
+    name="hotel_assistant"
+)
+
+# highlight-next-line
+supervisor = create_supervisor(
+    agents=[flight_assistant, hotel_assistant],
+    model=ChatOpenAI(model="gpt-4o"),
+    prompt=(
+        "You manage a hotel booking assistant and a"
+        "flight booking assistant. Assign work to them."
+    )
+).compile()
+
+for chunk in supervisor.stream(
+    {
+        "messages": [
+            {
+                "role": "user",
+                "content": "book a flight from BOS to JFK and a stay at McKittrick Hotel"
+            }
+        ]
+    }
+):
+    print(chunk)
+    print("\n")
+```
+
+## Swarm
+
+![Swarm](./assets/swarm.png)
+
+Use [`langgraph-swarm`](https://github.com/langchain-ai/langgraph-swarm-py) library to create a swarm multi-agent system:
+
+```bash
+pip install langgraph-swarm
+```
+
+```python
+from langgraph.prebuilt import create_react_agent
+# highlight-next-line
+from langgraph_swarm import create_swarm, create_handoff_tool
+
+transfer_to_hotel_assistant = create_handoff_tool(
+    agent_name="hotel_assistant",
+    description="Transfer user to the hotel-booking assistant.",
+)
+transfer_to_flight_assistant = create_handoff_tool(
+    agent_name="flight_assistant",
+    description="Transfer user to the flight-booking assistant.",
+)
+
+flight_assistant = create_react_agent(
+    model="anthropic:claude-3-5-sonnet-latest",
+    # highlight-next-line
+    tools=[book_flight, transfer_to_hotel_assistant],
+    prompt="You are a flight booking assistant",
+    # highlight-next-line
+    name="flight_assistant"
+)
+hotel_assistant = create_react_agent(
+    model="anthropic:claude-3-5-sonnet-latest",
+    # highlight-next-line
+    tools=[book_hotel, transfer_to_flight_assistant],
+    prompt="You are a hotel booking assistant",
+    # highlight-next-line
+    name="hotel_assistant"
+)
+
+# highlight-next-line
+swarm = create_swarm(
+    agents=[flight_assistant, hotel_assistant],
+    default_active_agent="flight_assistant"
+).compile()
+
+for chunk in swarm.stream(
+    {
+        "messages": [
+            {
+                "role": "user",
+                "content": "book a flight from BOS to JFK and a stay at McKittrick Hotel"
+            }
+        ]
+    }
+):
+    print(chunk)
+    print("\n")
+```
+
+## Handoffs
+
+A common pattern in multi-agent interactions is **handoffs**, where one agent *hands off* control to another. Handoffs allow you to specify:
+
+- **destination**: target agent to navigate to
+- **payload**: information to pass to that agent
+
+This is used both by `langgraph-supervisor` (supervisor hands off to individual agents) and `langgraph-swarm` (an individual agent can hand off to other agents).
+
+To implement handoffs with `create_react_agent`, you need to:
+
+1. Create a special tool that can transfer control to a different agent
+
+    ```python
+    def transfer_to_bob():
+        """Transfer to bob."""
+        return Command(
+            # name of the agent (node) to go to
+            # highlight-next-line
+            goto="bob",
+            # data to send to the agent
+            # highlight-next-line
+            update={"messages": [...]},
+            # indicate to LangGraph that we need to navigate to
+            # agent node in a parent graph
+            # highlight-next-line
+            graph=Command.PARENT,
+        )
+    ```
+
+1. Create individual agents that have access to handoff tools:
+
+    ```python
+    flight_assistant = create_react_agent(
+        ..., tools=[book_flight, transfer_to_hotel_assistant]
+    )
+    hotel_assistant = create_react_agent(
+        ..., tools=[book_hotel, transfer_to_flight_assistant]
+    )
+    ```
+
+1. Define a parent graph that contains individual agents as nodes:
+
+    ```python
+    from langgraph.graph import StateGraph, MessagesState
+    multi_agent_graph = (
+        StateGraph(MessagesState)
+        .add_node(flight_assistant)
+        .add_node(hotel_assistant)
+        ...
+    )
+    ```
+
+Putting this together, here is how you can implement a simple multi-agent system with two agents — a flight booking assistant and a hotel booking assistant:
+
+```python
+from typing import Annotated
+from langchain_core.tools import tool, InjectedToolCallId
+from langgraph.prebuilt import create_react_agent, InjectedState
+from langgraph.graph import StateGraph, START, MessagesState
+from langgraph.types import Command
+
+def create_handoff_tool(*, agent_name: str, description: str | None = None):
+    name = f"transfer_to_{agent_name}"
+    description = description or f"Transfer to {agent_name}"
+
+    @tool(name, description=description)
+    def handoff_tool(
+        # highlight-next-line
+        state: Annotated[MessagesState, InjectedState], # (1)!
+        # highlight-next-line
+        tool_call_id: Annotated[str, InjectedToolCallId],
+    ) -> Command:
+        tool_message = {
+            "role": "tool",
+            "content": f"Successfully transferred to {agent_name}",
+            "name": name,
+            "tool_call_id": tool_call_id,
+        }
+        return Command(  # (2)!
+            # highlight-next-line
+            goto=agent_name,  # (3)!
+            # highlight-next-line
+            update={"messages": state["messages"] + [tool_message]},  # (4)!
+            # highlight-next-line
+            graph=Command.PARENT,  # (5)!
+        )
+    return handoff_tool
+
+# Handoffs
+transfer_to_hotel_assistant = create_handoff_tool(
+    agent_name="hotel_assistant",
+    description="Transfer user to the hotel-booking assistant.",
+)
+transfer_to_flight_assistant = create_handoff_tool(
+    agent_name="flight_assistant",
+    description="Transfer user to the flight-booking assistant.",
+)
+
+# Simple agent tools
+def book_hotel(hotel_name: str):
+    """Book a hotel"""
+    return f"Successfully booked a stay at {hotel_name}."
+
+def book_flight(from_airport: str, to_airport: str):
+    """Book a flight"""
+    return f"Successfully booked a flight from {from_airport} to {to_airport}."
+
+# Define agents
+flight_assistant = create_react_agent(
+    model="anthropic:claude-3-5-sonnet-latest",
+    # highlight-next-line
+    tools=[book_flight, transfer_to_hotel_assistant],
+    prompt="You are a flight booking assistant",
+    # highlight-next-line
+    name="flight_assistant"
+)
+hotel_assistant = create_react_agent(
+    model="anthropic:claude-3-5-sonnet-latest",
+    # highlight-next-line
+    tools=[book_hotel, transfer_to_flight_assistant],
+    prompt="You are a hotel booking assistant",
+    # highlight-next-line
+    name="hotel_assistant"
+)
+
+# Define multi-agent graph
+multi_agent_graph = (
+    StateGraph(MessagesState)
+    .add_node(flight_assistant)
+    .add_node(hotel_assistant)
+    .add_edge(START, "flight_assistant")
+    .compile()
+)
+
+# Run the multi-agent graph
+for chunk in multi_agent_graph.stream(
+    {
+        "messages": [
+            {
+                "role": "user",
+                "content": "book a flight from BOS to JFK and a stay at McKittrick Hotel"
+            }
+        ]
+    }
+):
+    print(chunk)
+    print("\n")
+```
+
+1. Access agent's state
+2. The `Command` primitive allows specifying a state update and a node transition as a single operation, making it useful for implementing handoffs.
+3. Name of the agent or node to hand off to.
+4. Take the agent's messages and **add** them to the parent's **state** as part of the handoff. The next agent will see the parent state.
+5. Indicate to LangGraph that we need to navigate to agent node in a **parent** multi-agent graph.
+
+!!! Note
+    This handoff implementation assumes that:
+
+    - each agent receives overall message history (across all agents) in the multi-agent system as its input
+    - each agent outputs its internal messages history to the overall message history of the multi-agent system
+
+    Check out LangGraph [supervisor](https://github.com/langchain-ai/langgraph-supervisor-py#customizing-handoff-tools) and [swarm](https://github.com/langchain-ai/langgraph-swarm-py#customizing-handoff-tools) documentation to learn how to customize handoffs.

docs/docs/agents/overview.md

@@ -0,0 +1,38 @@
+---
+title: Overview
+---
+
+# Agent development with LangGraph
+
+**LangGraph** provides both low-level primitives and high-level prebuilt components for building agent-based applications. This section focuses on the **prebuilt**, **reusable** components designed to help you construct agentic systems quickly and reliably—without the need to implement orchestration, memory, or human feedback handling from scratch.
+
+## Key features
+
+LangGraph includes several capabilities essential for building robust, production-ready agentic systems:
+
+- [**Memory integration**](./memory.md): Native support for *short-term* (session-based) and *long-term* (persistent across sessions) memory, enabling stateful behaviors in chatbots and assistants.
+- [**Human-in-the-loop control**](./human-in-the-loop.md): Execution can pause *indefinitely* to await human feedback—unlike websocket-based solutions limited to real-time interaction. This enables asynchronous approval, correction, or intervention at any point in the workflow.
+- [**Streaming support**](./streaming.md): Real-time streaming of agent state, model tokens, tool outputs, or combined streams.
+- [**Deployment tooling**](./deployment.md): Includes infrastructure-free deployment tools. [**LangGraph Platform**](https://langchain-ai.github.io/langgraph/concepts/langgraph_platform/) supports testing, debugging, and deployment.
+    - **[Studio](https://langchain-ai.github.io/langgraph/concepts/langgraph_studio/)**: A visual IDE for inspecting and debugging workflows.
+    - Supports multiple [**deployment options**](https://langchain-ai.github.io/langgraph/tutorials/deployment/) for production.
+
+## High-level building blocks
+
+LangGraph comes with a set of prebuilt components that implement common agent behaviors and workflows. These abstractions are built on top of the LangGraph framework, offering a faster path to production while remaining flexible for advanced customization.
+
+Using LangGraph for agent development allows you to focus on your application's logic and behavior, instead of building and maintaining the supporting infrastructure for state, memory, and human feedback.
+
+## Package ecosystem
+
+The high-level components are organized into several packages, each with a specific focus.
+
+| Package                                    | Description                                                                 | Installation                            |
+|--------------------------------------------|-----------------------------------------------------------------------------|-----------------------------------------|
+| `langgraph-prebuilt` (part of `langgraph`) | Prebuilt components to [**create agents**](./agents.md)                     | `pip install -U langgraph langchain`    |
+| `langgraph-supervisor`                     | Tools for building [**supervisor**](./multi-agent.md#supervisor) agents     | `pip install -U langgraph-supervisor`   |
+| `langgraph-swarm`                          | Tools for building a [**swarm**](./multi-agent.md#swarm) multi-agent system | `pip install -U langgraph-swarm`        |
+| `langchain-mcp-adapters`                   | Interfaces to [**MCP servers**](./mcp.md) for tool and resource integration | `pip install -U langchain-mcp-adapters` |
+| `langmem`                                  | Agent memory management: [**short-term and long-term**](./memory.md)        | `pip install -U langmem`                |
+| `agentevals`                               | Utilities to [**evaluate agent performance**](./evals.md)                   | `pip install -U agentevals`             |
+

docs/docs/agents/prebuilt.md

@@ -1,4 +1,4 @@
-# 🚀 Prebuilt Agents
+# Community Agents
 
 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.
 

docs/docs/agents/run_agents.md

@@ -0,0 +1,159 @@
+# Running agents
+
+
+Agents support both synchronous and asynchronous execution using either `.invoke()` / `await .invoke()` for full responses, or `.stream()` / `.astream()` for **incremental** [streaming](#streaming) output. This section explains how to provide input, interpret output, enable streaming, and control execution limits.
+
+
+## Basic usage
+
+Agents can be executed in two primary modes:
+
+- **Synchronous** using `.invoke()` or `.stream()`
+- **Asynchronous** using `await .invoke()` or `async for` with `.astream()`
+
+=== "Sync invocation"
+    ```python
+    from langgraph.prebuilt import create_react_agent
+
+    agent = create_react_agent(...)
+
+    # highlight-next-line
+    response = agent.invoke({"messages": [{"role": "user", "content": "what is the weather in sf"}]})
+    ```
+
+=== "Async invocation"
+    ```python
+    from langgraph.prebuilt import create_react_agent
+
+    agent = create_react_agent(...)
+    # highlight-next-line
+    response = await agent.ainvoke({"messages": [{"role": "user", "content": "what is the weather in sf"}]})
+    ```
+
+## Inputs and outputs
+
+Agents use a language model that expects a list of `messages` as an input. Therefore, agent inputs and outputs are stored as a list of `messages` under the `messages` key in the agent [state](../concepts/low_level.md#working-with-messages-in-graph-state).
+
+## Input format
+
+Agent input must be a dictionary with a `messages` key. Supported formats are:
+
+| Format             | Example                                                                                                                       |
+|--------------------|-------------------------------------------------------------------------------------------------------------------------------|
+| String             | `{"messages": "Hello"}`  — Interpreted as a [HumanMessage](https://python.langchain.com/docs/concepts/messages/#humanmessage) |
+| Message dictionary | `{"messages": {"role": "user", "content": "Hello"}}`                                                                          |
+| List of messages   | `{"messages": [{"role": "user", "content": "Hello"}]}`                                                                        |
+| With custom state  | `{"messages": [{"role": "user", "content": "Hello"}], "user_name": "Alice"}` — If using a custom `state_schema`               |
+
+Messages are automatically converted into LangChain's internal message format. You can read
+more about [LangChain messages](https://python.langchain.com/docs/concepts/messages/#langchain-messages) in the LangChain documentation.
+
+!!! tip "Using custom agent state"
+
+    You can provide additional fields defined in your agent’s state schema directly in the input dictionary. This allows dynamic behavior based on runtime data or prior tool outputs.  
+    See the [context guide](./context.md) for full details.
+
+!!! note
+
+    A string input for `messages` is converted to a [HumanMessage](https://python.langchain.com/docs/concepts/messages/#humanmessage). This behavior differs from the `prompt` parameter in `create_react_agent`, which is interpreted as a [SystemMessage](https://python.langchain.com/docs/concepts/messages/#systemmessage) when passed as a string.
+
+
+## Output format
+
+Agent output is a dictionary containing:
+
+- `messages`: A list of all messages exchanged during execution (user input, assistant replies, tool invocations).
+- Optionally, `structured_response` if [structured output](./agents.md#structured-output) is configured.
+- If using a custom `state_schema`, additional keys corresponding to your defined fields may also be present in the output. These can hold updated state values from tool execution or prompt logic.
+
+See the [context guide](./context.md) for more details on working with custom state schemas and accessing context.
+
+## Streaming output
+
+Agents support streaming responses for more responsive applications. This includes:
+
+- **Progress updates** after each step
+- **LLM tokens** as they're generated
+- **Custom tool messages** during execution
+
+Streaming is available in both sync and async modes:
+
+=== "Sync streaming"
+
+    ```python
+    for chunk in agent.stream(
+        {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
+        stream_mode="updates"
+    ):
+        print(chunk)
+    ```
+
+=== "Async streaming"
+
+    ```python
+    async for chunk in agent.astream(
+        {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
+        stream_mode="updates"
+    ):
+        print(chunk)
+    ```
+
+!!! tip
+
+    For full details, see the [streaming guide](./streaming.md).
+
+## Max iterations
+
+To control agent execution and avoid infinite loops, set a recursion limit. This defines the maximum number of steps the agent can take before raising a `GraphRecursionError`. You can configure `recursion_limit` at runtime or when defining agent via `.with_config()`:
+
+=== "Runtime"
+
+    ```python
+    from langgraph.errors import GraphRecursionError
+    from langgraph.prebuilt import create_react_agent
+
+    max_iterations = 3
+    # highlight-next-line
+    recursion_limit = 2 * max_iterations + 1
+    agent = create_react_agent(
+        model="anthropic:claude-3-5-haiku-latest",
+        tools=[get_weather]
+    )
+
+    try:
+        response = agent.invoke(
+            {"messages": [{"role": "user", "content": "what's the weather in sf"}]},
+            # highlight-next-line
+            {"recursion_limit": recursion_limit},
+        )
+    except GraphRecursionError:
+        print("Agent stopped due to max iterations.")
+    ```
+
+=== "`.with_config()`"
+
+    ```python
+    from langgraph.errors import GraphRecursionError
+    from langgraph.prebuilt import create_react_agent
+
+    max_iterations = 3
+    # highlight-next-line
+    recursion_limit = 2 * max_iterations + 1
+    agent = create_react_agent(
+        model="anthropic:claude-3-5-haiku-latest",
+        tools=[get_weather]
+    )
+    # highlight-next-line
+    agent_with_recursion_limit = agent.with_config(recursion_limit=recursion_limit)
+
+    try:
+        response = agent_with_recursion_limit.invoke(
+            {"messages": [{"role": "user", "content": "what's the weather in sf"}]},
+        )
+    except GraphRecursionError:
+        print("Agent stopped due to max iterations.")
+    ```
+
+## Additional Resources
+
+* [Async programming in LangChain](https://python.langchain.com/docs/concepts/async)

docs/docs/agents/streaming.md

@@ -0,0 +1,208 @@
+# Streaming
+
+Streaming is key to building responsive applications. There are a few types of data you’ll want to stream:
+
+1. [**Agent progress**](#agent-progress) — get updates after each node in the agent graph is executed.
+2. [**LLM tokens**](#llm-tokens) — stream tokens as they are generated by the language model.
+3. [**Custom updates**](#tool-updates) — emit custom data from tools during execution (e.g., "Fetched 10/100 records")
+
+You can stream [more than one type of data](#stream-multiple-modes) at a time. 
+
+
+<figure markdown="1">
+![image](./assets/fast_parrot.png){: style="max-height:300px"}
+<figcaption>
+Waiting is for pigeons.
+</figcaption>
+</figure>
+
+## Agent progress
+
+To stream agent progress, use the [`stream()`][langgraph.graph.state.CompiledStateGraph.stream] or [`astream()`][langgraph.graph.state.CompiledStateGraph.astream] methods with [`stream_mode="updates"`](https://langchain-ai.github.io/langgraph/how-tos/streaming/#updates). This emits an event after every agent step.
+
+For example, if you have an agent that calls a tool once, you should see the following updates:
+
+* **LLM node**: AI message with tool call requests
+* **Tool node**: Tool message with execution result
+* **LLM node**: Final AI response
+
+=== "Sync"
+
+    ```python
+    agent = create_react_agent(
+        model="anthropic:claude-3-7-sonnet-latest",
+        tools=[get_weather],
+    )
+    # highlight-next-line
+    for chunk in agent.stream(
+        {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
+        # highlight-next-line
+        stream_mode="updates"
+    ):
+        print(chunk)
+        print("\n")
+    ```
+
+=== "Async"
+
+    ```python
+    agent = create_react_agent(
+        model="anthropic:claude-3-7-sonnet-latest",
+        tools=[get_weather],
+    )
+    # highlight-next-line
+    async for chunk in agent.astream(
+        {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
+        # highlight-next-line
+        stream_mode="updates"
+    ):
+        print(chunk)
+        print("\n")
+    ```
+
+## LLM tokens
+
+To stream tokens as they are produced by the LLM, use `stream_mode="messages"`:
+
+=== "Sync"
+
+    ```python
+    agent = create_react_agent(
+        model="anthropic:claude-3-7-sonnet-latest",
+        tools=[get_weather],
+    )
+    # highlight-next-line
+    for token, metadata in agent.stream(
+        {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
+        # highlight-next-line
+        stream_mode="messages"
+    ):
+        print("Token", token)
+        print("Metadata", metadata)
+        print("\n")
+    ```
+
+=== "Async"
+
+    ```python
+    agent = create_react_agent(
+        model="anthropic:claude-3-7-sonnet-latest",
+        tools=[get_weather],
+    )
+    # highlight-next-line
+    async for token, metadata in agent.astream(
+        {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
+        # highlight-next-line
+        stream_mode="messages"
+    ):
+        print("Token", token)
+        print("Metadata", metadata)
+        print("\n")
+    ```
+
+## Tool updates
+
+To stream updates from tools as they are executed, you can use [get_stream_writer][langgraph.config.get_stream_writer].
+
+=== "Sync"
+
+    ```python
+    # highlight-next-line
+    from langgraph.config import get_stream_writer
+
+    def get_weather(city: str) -> str:
+        """Get weather for a given city."""
+        # highlight-next-line
+        writer = get_stream_writer()
+        # stream any arbitrary data
+        # highlight-next-line
+        writer(f"Looking up data for city: {city}")
+        return f"It's always sunny in {city}!"
+
+    agent = create_react_agent(
+        model="anthropic:claude-3-7-sonnet-latest",
+        tools=[get_weather],
+    )
+
+    for chunk in agent.stream(
+        {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
+        # highlight-next-line
+        stream_mode="custom"
+    ):
+        print(chunk)
+        print("\n")
+    ```
+
+=== "Async"
+
+    ```python
+    # highlight-next-line
+    from langgraph.config import get_stream_writer
+
+    def get_weather(city: str) -> str:
+        """Get weather for a given city."""
+        # highlight-next-line
+        writer = get_stream_writer()
+        # stream any arbitrary data
+        # highlight-next-line
+        writer(f"Looking up data for city: {city}")
+        return f"It's always sunny in {city}!"
+
+    agent = create_react_agent(
+        model="anthropic:claude-3-7-sonnet-latest",
+        tools=[get_weather],
+    )
+
+    async for chunk in agent.astream(
+        {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
+        # highlight-next-line
+        stream_mode="custom"
+    ):
+        print(chunk)
+        print("\n")
+    ```
+
+!!! Note
+    If you add `get_stream_writer` inside your tool, you won't be able to invoke the tool outside of a LangGraph execution context. 
+
+## Stream multiple modes
+
+You can specify multiple streaming modes by passing stream mode as a list: `stream_mode=["updates", "messages", "custom"]`:
+
+=== "Sync"
+
+    ```python
+    agent = create_react_agent(
+        model="anthropic:claude-3-7-sonnet-latest",
+        tools=[get_weather],
+    )
+
+    for stream_mode, chunk in agent.stream(
+        {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
+        # highlight-next-line
+        stream_mode=["updates", "messages", "custom"]
+    ):
+        print(chunk)
+        print("\n")
+    ```
+
+=== "Async"
+
+    ```python
+    agent = create_react_agent(
+        model="anthropic:claude-3-7-sonnet-latest",
+        tools=[get_weather],
+    )
+
+    async for stream_mode, chunk in agent.astream(
+        {"messages": [{"role": "user", "content": "what is the weather in sf"}]},
+        # highlight-next-line
+        stream_mode=["updates", "messages", "custom"]
+    ):
+        print(chunk)
+        print("\n")
+    ```
+
+## Additional resources
+
+* [Streaming in LangGraph](https://langchain-ai.github.io/langgraph/how-tos/streaming)

docs/docs/agents/tools.md

@@ -0,0 +1,280 @@
+# Tools
+
+[Tools](https://python.langchain.com/docs/concepts/tools/) are a way to encapsulate a function and its input schema in a way that can be passed to a chat model that supports tool calling. This allows the model to request the execution of this function with specific inputs.
+
+You can either [define your own tools](#define-simple-tools) or use [prebuilt integrations](#prebuilt-tools) that LangChain provides.
+
+## Define simple tools
+
+You can pass a vanilla function to `create_react_agent` to use as a tool:
+
+```python
+from langgraph.prebuilt import create_react_agent
+
+def multiply(a: int, b: int) -> int:
+    """Multiply two numbers."""
+    return a * b
+
+create_react_agent(
+    model="anthropic:claude-3-7-sonnet",
+    tools=[multiply]
+)
+```
+
+`create_react_agent` automatically converts vanilla functions to [LangChain tools](https://python.langchain.com/docs/concepts/tools/#tool-interface).
+
+## Customize tools
+
+For more control over tool behavior, use the `@tool` decorator:
+
+```python
+# highlight-next-line
+from langchain_core.tools import tool
+
+# highlight-next-line
+@tool("multiply_tool", parse_docstring=True)
+def multiply(a: int, b: int) -> int:
+    """Multiply two numbers.
+
+    Args:
+        a: First operand
+        b: Second operand
+    """
+    return a * b
+```
+
+You can also define a custom input schema using Pydantic:
+
+```python
+from pydantic import BaseModel, Field
+
+class MultiplyInputSchema(BaseModel):
+    """Multiply two numbers"""
+    a: int = Field(description="First operand")
+    b: int = Field(description="Second operand")
+
+# highlight-next-line
+@tool("multiply_tool", args_schema=MultiplyInputSchema)
+def multiply(a: int, b: int) -> int:
+   return a * b
+```
+
+For additional customization, refer to the [custom tools guide](https://python.langchain.com/docs/how_to/custom_tools/).
+
+## Hide arguments from the model
+
+Some tools require runtime-only arguments (e.g., user ID or session context) that should not be controllable by the model.
+
+You can put these arguments in the `state` or `config` of the agent, and access
+this information inside the tool:
+
+```python
+from langgraph.prebuilt import InjectedState
+from langgraph.prebuilt.chat_agent_executor import AgentState
+from langchain_core.runnables import RunnableConfig
+
+def my_tool(
+    # This will be populated by an LLM
+    tool_arg: str,
+    # access information that's dynamically updated inside the agent
+    # highlight-next-line
+    state: Annotated[AgentState, InjectedState],
+    # access static data that is passed at agent invocation
+    # highlight-next-line
+    config: RunnableConfig,
+) -> str:
+    """My tool."""
+    do_something_with_state(state["messages"])
+    do_something_with_config(config)
+    ...
+```
+
+## Disable parallel tool calling
+
+Some model providers support executing multiple tools in parallel, but
+allow users to disable this feature.
+
+For supported providers, you can disable parallel tool calling by setting `parallel_tool_calls=False` via the `model.bind_tools()` method:
+
+```python
+from langchain.chat_models import init_chat_model
+
+def add(a: int, b: int) -> int:
+    """Add two numbers"""
+    return a + b
+
+def multiply(a: int, b: int) -> int:
+    """Multiply two numbers."""
+    return a * b
+
+model = init_chat_model("anthropic:claude-3-5-sonnet-latest", temperature=0)
+tools = [add, multiply]
+agent = create_react_agent(
+    # disable parallel tool calls
+    # highlight-next-line
+    model=model.bind_tools(tools, parallel_tool_calls=False),
+    tools=tools
+)
+
+agent.invoke(
+    {"messages": [{"role": "user", "content": "what's 3 + 5 and 4 * 7?"}]}
+)
+```
+
+## Return tool results directly
+
+Use `return_direct=True` to return tool results immediately and stop the agent loop:
+
+```python
+from langchain_core.tools import tool
+
+# highlight-next-line
+@tool(return_direct=True)
+def add(a: int, b: int) -> int:
+    """Add two numbers"""
+    return a + b
+
+agent = create_react_agent(
+    model="anthropic:claude-3-7-sonnet-latest",
+    tools=[add]
+)
+
+agent.invoke(
+    {"messages": [{"role": "user", "content": "what's 3 + 5?"}]}
+)
+```
+
+## Force tool use
+
+To force the agent to use specific tools, you can set the `tool_choice` option in `model.bind_tools()`:
+
+```python
+from langchain_core.tools import tool
+
+# highlight-next-line
+@tool(return_direct=True)
+def greet(user_name: str) -> int:
+    """Greet user."""
+    return f"Hello {user_name}!"
+
+tools = [greet]
+
+agent = create_react_agent(
+    # highlight-next-line
+    model=model.bind_tools(tools, tool_choice={"type": "tool", "name": "greet"}),
+    tools=tools
+)
+
+agent.invoke(
+    {"messages": [{"role": "user", "content": "Hi, I am Bob"}]}
+)
+```
+
+!!! Warning "Avoid infinite loops"
+
+    Forcing tool usage without stopping conditions can create infinite loops. Use one of the following safeguards:
+
+    - Mark the tool with [`return_direct=True`](#return-tool-results-directly) to end the loop after execution.
+    - Set [`recursion_limit`](../concepts/low_level.md#recursion-limit) to restrict the number of execution steps.
+
+## Handle tool errors
+
+By default, the agent will catch all exceptions raised during tool calls and will pass those as tool messages to the LLM. To control how the errors are handled, you can use the prebuilt [`ToolNode`][langgraph.prebuilt.tool_node.ToolNode] — the node that executes tools inside `create_react_agent` — via its `handle_tool_errors` parameter:
+
+=== "Enable error handling (default)"
+
+    ```python
+    from langgraph.prebuilt import create_react_agent
+
+    def multiply(a: int, b: int) -> int:
+        """Multiply two numbers."""
+        if a == 42:
+            raise ValueError("The ultimate error")
+        return a * b
+
+    # Run with error handling (default)
+    agent = create_react_agent(
+        model="anthropic:claude-3-7-sonnet-latest",
+        tools=[multiply]
+    )
+    agent.invoke(
+        {"messages": [{"role": "user", "content": "what's 42 x 7?"}]}
+    )
+    ```
+
+=== "Disable error handling"
+
+    ```python
+    from langgraph.prebuilt import create_react_agent, ToolNode
+
+    def multiply(a: int, b: int) -> int:
+        """Multiply two numbers."""
+        if a == 42:
+            raise ValueError("The ultimate error")
+        return a * b
+
+    # highlight-next-line
+    tool_node = ToolNode(
+        [multiply],
+        # highlight-next-line
+        handle_tool_errors=False  # (1)!
+    )
+    agent_no_error_handling = create_react_agent(
+        model="anthropic:claude-3-7-sonnet-latest",
+        tools=tool_node
+    )
+    agent_no_error_handling.invoke(
+        {"messages": [{"role": "user", "content": "what's 42 x 7?"}]}
+    )
+    ```
+
+    1. This disables error handling (enabled by default). See all available strategies in the [API reference][langgraph.prebuilt.tool_node.ToolNode].
+
+=== "Custom error handling"
+
+    ```python
+    from langgraph.prebuilt import create_react_agent, ToolNode
+
+    def multiply(a: int, b: int) -> int:
+        """Multiply two numbers."""
+        if a == 42:
+            raise ValueError("The ultimate error")
+        return a * b
+
+    # highlight-next-line
+    tool_node = ToolNode(
+        [multiply],
+        # highlight-next-line
+        handle_tool_errors=(
+            "Can't use 42 as a first operand, you must switch operands!"  # (1)!
+        )
+    )
+    agent_custom_error_handling = create_react_agent(
+        model="anthropic:claude-3-7-sonnet-latest",
+        tools=tool_node
+    )
+    agent_custom_error_handling.invoke(
+        {"messages": [{"role": "user", "content": "what's 42 x 7?"}]}
+    )
+    ```
+
+    1. This provides a custom message to send to the LLM in case of an exception. See all available strategies in the [API reference][langgraph.prebuilt.tool_node.ToolNode].
+
+See [API reference][langgraph.prebuilt.tool_node.ToolNode] for more information on different tool error handling options.
+
+## Prebuilt tools
+
+LangChain supports a wide range of prebuilt tool integrations for interacting with APIs, databases, file systems, web data, and more. These tools extend the functionality of agents and enable rapid development.
+
+You can browse the full list of available integrations in the [LangChain integrations directory](https://python.langchain.com/docs/integrations/tools/).
+
+Some commonly used tool categories include:
+
+- **Search**: Bing, SerpAPI, Tavily
+- **Code interpreters**: Python REPL, Node.js REPL
+- **Databases**: SQL, MongoDB, Redis
+- **Web data**: Web scraping and browsing
+- **APIs**: OpenWeatherMap, NewsAPI, and others
+
+These integrations can be configured and added to your agents using the same `tools` parameter shown in the examples above.
+

docs/docs/agents/ui.md

@@ -0,0 +1,31 @@
+# UI
+
+You can use a prebuilt chat UI for interacting with any LangGraph agent through the [Agent Chat UI](https://github.com/langchain-ai/agent-chat-ui). Using the [deployed version](https://agentchat.vercel.app) is the quickest way to get started, and allows you to interact with both local and deployed graphs.
+
+## Run agent in UI
+
+First, set up LangGraph API server [locally](./deployment.md#launch-langgraph-server-locally) or deploy your agent on [LangGraph Cloud](https://langchain-ai.github.io/langgraph/cloud/quick_start/).
+
+Then, navigate to [Agent Chat UI](https://agentchat.vercel.app), or clone the repository and [run the dev server locally](https://github.com/langchain-ai/agent-chat-ui?tab=readme-ov-file#setup):
+
+<video controls src="../assets/base-chat-ui.mp4" type="video/mp4"></video>
+
+!!! Tip
+
+    UI has out-of-box support for rendering tool calls, and tool result messages. To customize what messages are shown, see the [Hiding Messages in the Chat](https://github.com/langchain-ai/agent-chat-ui?tab=readme-ov-file#hiding-messages-in-the-chat) section in the Agent Chat UI documentation.
+
+## Add human-in-the-loop
+
+Agent Chat UI has full support for [human-in-the-loop](../concepts/human_in_the_loop.md) workflows. To try it out, replace the agent code in `src/agent/graph.py` (from the [deployment](./deployment.md) guide) with this [agent implementation](./human-in-the-loop.md#using-with-agent-inbox):
+
+<video controls src="../assets/interrupt-chat-ui.mp4" type="video/mp4"></video>
+
+!!! Important
+
+    Agent Chat UI works best if your LangGraph agent interrupts using the [`HumanInterrupt` schema][langgraph.prebuilt.interrupt.HumanInterrupt]. If you do not use that schema, the Agent Chat UI will be able to render the input passed to the `interrupt` function, but it will not have full support for resuming your graph.
+
+## Generative UI
+
+You can also use generative UI in the Agent Chat UI.
+
+Generative UI allows you to define [React](https://react.dev/) components, and push them to the UI from the LangGraph server. For more documentation on building generative UI LangGraph agents, read [these docs](https://langchain-ai.github.io/langgraph/cloud/how-tos/generative_ui_react/).

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

@@ -1,7 +1,7 @@
 # LangGraph Studio With Local Deployment
 
 !!! warning "Browser Compatibility"
-    Viewing the studio page of a local LangGraph deployment does not work in Safari. Use Chrome instead.
+    Safari blocks `localhost` connections to Studio. To work around this, start the server with `--tunnel` and you’ll be able to access Studio from Safari via a secure tunnel.
 
 ## Setup
 

docs/docs/cloud/reference/cli.md

@@ -10,9 +10,6 @@ The LangGraph command line interface includes commands to build and run a LangGr
     === "Python"
         ```bash
         pip install langgraph-cli
-
-        # Install via Homebrew
-        brew install langgraph-cli
         ```
 
     === "JS"
@@ -298,6 +295,11 @@ The LangGraph CLI requires a JSON configuration file that follows this [schema](
     | `--no-reload`                 |                  | Disable auto-reload                                                                 |
     | `--n-jobs-per-worker INTEGER` |                  | Number of jobs per worker. Default is 10                                            |
     | `--debug-port INTEGER`        |                  | Port for debugger to listen on                                                      |
+    | `--wait-for-client`           | `False`          | Wait for a debugger client to connect to the debug port before starting the server   |
+    | `--no-browser`                |                  | Skip automatically opening the browser when the server starts                       |
+    | `--studio-url TEXT`           |                  | URL of the LangGraph Studio instance to connect to. Defaults to https://smith.langchain.com |
+    | `--allow-blocking`            | `False`          | Do not raise errors for synchronous I/O blocking operations in your code (added in `0.2.6`)           |
+    | `--tunnel`                    | `False`          | Expose the local server via a public tunnel (Cloudflare) for remote frontend access. This avoids issues with browsers like Safari or networks blocking localhost connections        |
     | `--help`                      |                  | Display command documentation                                                       |
 
 
@@ -321,6 +323,11 @@ The LangGraph CLI requires a JSON configuration file that follows this [schema](
     | `--no-reload`                 |                  | Disable auto-reload                                                                 |
     | `--n-jobs-per-worker INTEGER` |                  | Number of jobs per worker. Default is 10                                            |
     | `--debug-port INTEGER`        |                  | Port for debugger to listen on                                                      |
+    | `--wait-for-client`           | `False`          | Wait for a debugger client to connect to the debug port before starting the server   |
+    | `--no-browser`                |                  | Skip automatically opening the browser when the server starts                       |
+    | `--studio-url TEXT`           |                  | URL of the LangGraph Studio instance to connect to. Defaults to https://smith.langchain.com |
+    | `--allow-blocking`            | `False`          | Do not raise errors for synchronous I/O blocking operations in your code            |
+    | `--tunnel`                    | `False`          | Expose the local server via a public tunnel (Cloudflare) for remote frontend access. This avoids issues with browsers or networks blocking localhost connections        |
     | `--help`                      |                  | Display command documentation                                                       |
 
 ### `build`

docs/docs/cloud/reference/env_var.md

@@ -55,6 +55,14 @@ Set `LANGSMITH_TRACING` to `false` to disable tracing to LangSmith.
 
 Configure [log level](https://docs.python.org/3/library/logging.html#logging-levels). Defaults to `INFO`.
 
+## `LOG_JSON`
+
+Set `LOG_JSON` to `true` to render all log messages as JSON objects using the configured `JSONRenderer`. This produces structured logs that can be easily parsed or ingested by log management systems. Defaults to `false`.
+
+## `LOG_COLOR`
+
+This is mainly relevant in the context of using the dev server via the `langgraph dev` command. Set `LOG_COLOR` to `true` to enable ANSI-colored console output when using the default console renderer. Disabling color output by setting this variable to `false` produces monochrome logs. Defaults to `true`.
+
 ## `N_JOBS_PER_WORKER`
 
 Number of jobs per worker for the LangGraph Server task queue. Defaults to `10`.

docs/docs/concepts/langgraph_cli.md

@@ -54,7 +54,7 @@ pip install -U "langgraph-cli[inmem]"
 
 ### `up`
 
-The `langgraph up` command starts an instance of the [LangGraph API server](./langgraph_server.md) locally in a docker container. This requires thedocker server to be running locally. It also requires a LangSmith API key for local development or a license key for production use.
+The `langgraph up` command starts an instance of the [LangGraph API server](./langgraph_server.md) locally in a docker container. This requires the docker server to be running locally. It also requires a LangSmith API key for local development or a license key for production use.
 
 The server includes all API endpoints for your graph's runs, threads, assistants, etc. as well as the other services required to run your agent, including a managed database for checkpointing and storage.
 

docs/docs/reference/prebuilt.md

@@ -17,3 +17,12 @@
     options:
       members:
         - ValidationNode
+
+
+::: langgraph.prebuilt.interrupt
+    options:
+      members:
+        - HumanInterruptConfig
+        - ActionRequest
+        - HumanInterrupt
+        - HumanResponse

docs/docs/stylesheets/logos.css

@@ -0,0 +1,3 @@
+.safari {
+  color: #0070C9;
+}

docs/docs/troubleshooting/errors/index.md

@@ -14,3 +14,4 @@ Errors referenced below will have an `lc_error_code` property corresponding to o
 These guides provide troubleshooting information for errors that are specific to the LangGraph Platform.
 
 - [INVALID_LICENSE](./INVALID_LICENSE.md)
+- [Studio Errors](../studio.md)

docs/docs/troubleshooting/studio.md

@@ -0,0 +1,45 @@
+# Troubleshooting LangGraph Studio
+
+## :fontawesome-brands-safari:{ .safari } Safari connection error with local dev server
+
+Safari blocks plain‑HTTP traffic on localhost. If you start Studio with a vanilla  
+`langgraph dev`, the page may report a "Failed to load assistants" error (or something similar) and the browser DevTools will show network errors.
+
+#### Quick fix — run Studio through a secure Cloudflare tunnel
+
+=== "Python"
+
+    ```shell
+    pip install -U langgraph-cli>=0.2.6            # Python
+    langgraph dev --tunnel
+    ```
+=== "JS"
+
+    ```shell
+    # Requires @langchain/langgraph-cli>=0.0.26
+    npx @langchain/langgraph-cli dev
+    ```
+
+The command prints a URL like:
+
+```shell
+https://smith.langchain.com/studio/?baseUrl=https://hamilton-praise-heart-costumes.trycloudflare.com
+```
+where
+```shell
+?baseUrl=https://hamilton-praise-heart-costumes.trycloudflare.com
+```
+indicates the endpoint where your agent server is exposed.
+
+Open that URL in Safari and Studio should load immediately.
+
+#### Alternative — use a Chromium‑based browser
+
+Chrome, Edge, and Brave allow HTTP on localhost, so a plain `langgraph dev` should work without extra steps.
+
+#### If it’s still not loading
+
+1. Make sure the `baseUrl` query parameter in the studio URL points to the **tunnel URL** NOT to localhost.
+2. Confirm your CLI version with `langgraph --version`.
+
+No other configuration, certificates, or CORS tweaks are required.

docs/docs/tutorials/sql-agent.ipynb

@@ -741,13 +741,7 @@
     "from IPython.display import Image, display\n",
     "from langchain_core.runnables.graph import MermaidDrawMethod\n",
     "\n",
-    "display(\n",
-    "    Image(\n",
-    "        app.get_graph().draw_mermaid_png(\n",
-    "            draw_method=MermaidDrawMethod.API,\n",
-    "        )\n",
-    "    )\n",
-    ")"
+    "display(Image(app.get_graph().draw_mermaid_png()))"
    ]
   },
   {

docs/mkdocs.yml

@@ -1,5 +1,5 @@
-site_name: ""
-site_description: Build language agents as graphs
+site_name: "LangGraph"
+site_description: Build reliable, stateful AI systems, without giving up control
 site_url: https://langchain-ai.github.io/langgraph/
 repo_url: https://github.com/langchain-ai/langgraph
 edit_uri: edit/main/docs/docs/
@@ -91,7 +91,7 @@ plugins:
                 - "!^_"
 
 nav:
-  - Home:
+  - LangGraph:
     - index.md
     - Get started:
       - Learn the basics: tutorials/introduction.ipynb
@@ -388,8 +388,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
       - Companies using LangGraph: adopters.md
       - LLMS-txt: llms-txt-overview.md
       - FAQ: concepts/faq.md
@@ -402,8 +400,29 @@ nav:
           - troubleshooting/errors/MULTIPLE_SUBGRAPHS.md
           - troubleshooting/errors/INVALID_CHAT_HISTORY.md
           - troubleshooting/errors/INVALID_LICENSE.md
+          - troubleshooting/studio.md
       - LangGraph Academy Course: https://academy.langchain.com/courses/intro-to-langgraph
 
+  - Agents:
+    - agents/overview.md
+    - Get started:
+      - agents/agents.md
+    - Documentation:
+      - agents/run_agents.md
+      - agents/streaming.md
+      - agents/models.md
+      - agents/tools.md
+      - agents/mcp.md
+      - agents/context.md
+      - agents/memory.md
+      - agents/human-in-the-loop.md
+      - agents/multi-agent.md
+      - agents/evals.md
+      - agents/deployment.md
+      - agents/ui.md
+    - Resources:
+      # NOTE: prebuilt.md is auto-generated by `make build-prebuilt`
+      - agents/prebuilt.md
   - API reference:
     - reference/index.md
     - Library:
@@ -531,3 +550,4 @@ copyright: >
   Copyright &copy; 2025 LangChain, Inc | <a href="#__consent">Consent Preferences</a>
 extra_css:
   - stylesheets/version_admonitions.css
+  - stylesheets/logos.css

docs/poetry.lock

@@ -3387,14 +3387,14 @@ tenacity = ">=8.1.0,<8.4.0 || >8.4.0,<10"
 
 [[package]]
 name = "langchain-core"
-version = "0.3.52"
+version = "0.3.54"
 description = "Building applications with LLMs through composability"
 optional = false
 python-versions = "<4.0,>=3.9"
 groups = ["docs", "test"]
 files = [
-    {file = "langchain_core-0.3.52-py3-none-any.whl", hash = "sha256:cd137109c1e3d04f5a582c2cae9539b2cd5e4b795f486b58969dbc3d0387fe7c"},
-    {file = "langchain_core-0.3.52.tar.gz", hash = "sha256:f1981ec9efa4fceb11ff5ca57f5f9c8e22859cea3a94f8a044e6de8815afbd57"},
+    {file = "langchain_core-0.3.54-py3-none-any.whl", hash = "sha256:cd42155d9089e2fd4695ee02a4b2bc6daf55b9d4e1a37639647cf2455ed4fa04"},
+    {file = "langchain_core-0.3.54.tar.gz", hash = "sha256:55ce38939038e19b1271f36f512335462d7f64057b531598b3651d2b403e1b42"},
 ]
 
 [package.dependencies]
@@ -3530,7 +3530,7 @@ langchain-core = ">=0.3.45,<1.0.0"
 
 [[package]]
 name = "langgraph"
-version = "0.3.30"
+version = "0.3.31"
 description = "Building stateful, multi-actor applications with LLMs"
 optional = false
 python-versions = ">=3.9.0,<4.0"
@@ -3541,7 +3541,7 @@ develop = true
 [package.dependencies]
 langchain-core = ">=0.1,<0.4"
 langgraph-checkpoint = "^2.0.10"
-langgraph-prebuilt = ">=0.1.1,<0.2"
+langgraph-prebuilt = ">=0.1.8,<0.2"
 langgraph-sdk = "^0.1.42"
 xxhash = "^3.5.0"
 
@@ -5987,7 +5987,6 @@ optional = false
 python-versions = ">=3.8"
 groups = ["test"]
 files = [
-    {file = "pyasn1-0.6.1-py3-none-any.whl", hash = "sha256:0d632f46f2ba09143da3a8afe9e33fb6f92fa2320ab7e886e2d0f7672af84629"},
     {file = "pyasn1-0.6.1.tar.gz", hash = "sha256:6f580d2bdd84365380830acf45550f2511469f673cb4a5ae3857a3170128b034"},
 ]
 
@@ -5999,7 +5998,6 @@ optional = false
 python-versions = ">=3.8"
 groups = ["test"]
 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"},
 ]
 
@@ -8902,4 +8900,4 @@ cffi = ["cffi (>=1.11)"]
 [metadata]
 lock-version = "2.1"
 python-versions = "^3.10"
-content-hash = "45bbc644a3b878063f5cbb75eed56540423315784f8dd42cfd3937c910dfc9c5"
+content-hash = "36d7e4c4eba50d5e4dfb2e99964d7b51fe17d36238a912765cca8fc360216079"

docs/pyproject.toml

@@ -43,6 +43,7 @@ langchain-cohere = "^0.4.2"
 
 [tool.poetry.group.test.dependencies]
 langchain = "^0.3.8"
+langchain-core = "^0.3.54"
 langchain-openai = "^0.3.7"
 langchain-anthropic = "^0.3.8"
 langchain-nomic = "^0.1.3"

docs/tests/unit_tests/test_api_reference.py

@@ -14,11 +14,11 @@ from langgraph.types import interrupt
 """
 
 EXPECTED_MARKDOWN = """\
+API Reference: <a href="https://langchain-ai.github.io/langgraph/reference/types/#langgraph.types.interrupt">interrupt</a>
+
 ```python
 from langgraph.types import interrupt
 ```
-
-API Reference: <a href="https://langchain-ai.github.io/langgraph/reference/types/#langgraph.types.interrupt">interrupt</a>
 """
 
 

libs/checkpoint-postgres/langgraph/checkpoint/postgres/__init__.py

@@ -357,6 +357,29 @@ class PostgresSaver(BasePostgresSaver):
                 ),
             )
 
+    def delete_thread(self, thread_id: str) -> None:
+        """Delete all checkpoints and writes associated with a thread ID.
+
+        Args:
+            thread_id (str): The thread ID to delete.
+
+        Returns:
+            None
+        """
+        with self._cursor(pipeline=True) as cur:
+            cur.execute(
+                "DELETE FROM checkpoints WHERE thread_id = %s",
+                (str(thread_id),),
+            )
+            cur.execute(
+                "DELETE FROM checkpoint_blobs WHERE thread_id = %s",
+                (str(thread_id),),
+            )
+            cur.execute(
+                "DELETE FROM checkpoint_writes WHERE thread_id = %s",
+                (str(thread_id),),
+            )
+
     @contextmanager
     def _cursor(self, *, pipeline: bool = False) -> Iterator[Cursor[DictRow]]:
         """Create a database cursor as a context manager.

libs/checkpoint-postgres/langgraph/checkpoint/postgres/aio.py

@@ -314,6 +314,29 @@ class AsyncPostgresSaver(BasePostgresSaver):
         async with self._cursor(pipeline=True) as cur:
             await cur.executemany(query, params)
 
+    async def adelete_thread(self, thread_id: str) -> None:
+        """Delete all checkpoints and writes associated with a thread ID.
+
+        Args:
+            thread_id (str): The thread ID to delete.
+
+        Returns:
+            None
+        """
+        async with self._cursor(pipeline=True) as cur:
+            await cur.execute(
+                "DELETE FROM checkpoints WHERE thread_id = %s",
+                (str(thread_id),),
+            )
+            await cur.execute(
+                "DELETE FROM checkpoint_blobs WHERE thread_id = %s",
+                (str(thread_id),),
+            )
+            await cur.execute(
+                "DELETE FROM checkpoint_writes WHERE thread_id = %s",
+                (str(thread_id),),
+            )
+
     @asynccontextmanager
     async def _cursor(
         self, *, pipeline: bool = False
@@ -481,5 +504,30 @@ class AsyncPostgresSaver(BasePostgresSaver):
             self.aput_writes(config, writes, task_id, task_path), self.loop
         ).result()
 
+    def delete_thread(self, thread_id: str) -> None:
+        """Delete all checkpoints and writes associated with a thread ID.
+
+        Args:
+            thread_id (str): The thread ID to delete.
+
+        Returns:
+            None
+        """
+        try:
+            # check if we are in the main thread, only bg threads can block
+            # we don't check in other methods to avoid the overhead
+            if asyncio.get_running_loop() is self.loop:
+                raise asyncio.InvalidStateError(
+                    "Synchronous calls to AsyncPostgresSaver are only allowed from a "
+                    "different thread. From the main thread, use the async interface. "
+                    "For example, use `await checkpointer.aget_tuple(...)` or `await "
+                    "graph.ainvoke(...)`."
+                )
+        except RuntimeError:
+            pass
+        return asyncio.run_coroutine_threadsafe(
+            self.adelete_thread(thread_id), self.loop
+        ).result()
+
 
 __all__ = ["AsyncPostgresSaver", "AsyncShallowPostgresSaver", "Conn"]

libs/checkpoint-postgres/langgraph/store/postgres/base.py

@@ -1320,7 +1320,7 @@ def _ensure_index_config(
     index_config = index_config.copy()
     tokenized: list[tuple[str, Union[Literal["$"], list[str]]]] = []
     tot = 0
-    text_fields = index_config.get("text_fields") or ["$"]
+    text_fields = index_config.get("fields") or ["$"]
     if isinstance(text_fields, str):
         text_fields = [text_fields]
     if not isinstance(text_fields, list):

libs/checkpoint-postgres/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langgraph-checkpoint-postgres"
-version = "2.0.19"
+version = "2.0.21"
 description = "Library with a Postgres implementation of LangGraph checkpoint saver."
 authors = []
 license = "MIT"

libs/checkpoint-postgres/tests/test_async_store.py

@@ -377,7 +377,7 @@ async def _create_vector_store(
             "vector_type": vector_type,
         },
         "distance_type": distance_type,
-        "text_fields": text_fields,
+        "fields": text_fields,
     }
 
     async with await AsyncConnection.connect(

libs/checkpoint-postgres/tests/test_store.py

@@ -401,7 +401,7 @@ def _create_vector_store(
             "vector_type": vector_type,
         },
         "distance_type": distance_type,
-        "text_fields": text_fields,
+        "fields": text_fields,
     }
 
     with Connection.connect(admin_conn_string, autocommit=True) as conn:

libs/checkpoint-sqlite/langgraph/checkpoint/sqlite/__init__.py

@@ -464,6 +464,25 @@ class SqliteSaver(BaseCheckpointSaver[str]):
                 ],
             )
 
+    def delete_thread(self, thread_id: str) -> None:
+        """Delete all checkpoints and writes associated with a thread ID.
+
+        Args:
+            thread_id (str): The thread ID to delete.
+
+        Returns:
+            None
+        """
+        with self.cursor() as cur:
+            cur.execute(
+                "DELETE FROM checkpoints WHERE thread_id = ?",
+                (str(thread_id),),
+            )
+            cur.execute(
+                "DELETE FROM writes WHERE thread_id = ?",
+                (str(thread_id),),
+            )
+
     async def aget_tuple(self, config: RunnableConfig) -> Optional[CheckpointTuple]:
         """Get a checkpoint tuple from the database asynchronously.
 

libs/checkpoint-sqlite/langgraph/checkpoint/sqlite/aio.py

@@ -244,6 +244,31 @@ class AsyncSqliteSaver(BaseCheckpointSaver[str]):
             self.aput_writes(config, writes, task_id, task_path), self.loop
         ).result()
 
+    def delete_thread(self, thread_id: str) -> None:
+        """Delete all checkpoints and writes associated with a thread ID.
+
+        Args:
+            thread_id (str): The thread ID to delete.
+
+        Returns:
+            None
+        """
+        try:
+            # check if we are in the main thread, only bg threads can block
+            # we don't check in other methods to avoid the overhead
+            if asyncio.get_running_loop() is self.loop:
+                raise asyncio.InvalidStateError(
+                    "Synchronous calls to AsyncSqliteSaver are only allowed from a "
+                    "different thread. From the main thread, use the async interface. "
+                    "For example, use `checkpointer.alist(...)` or `await "
+                    "graph.ainvoke(...)`."
+                )
+        except RuntimeError:
+            pass
+        return asyncio.run_coroutine_threadsafe(
+            self.adelete_thread(thread_id), self.loop
+        ).result()
+
     async def setup(self) -> None:
         """Set up the checkpoint database asynchronously.
 
@@ -535,6 +560,26 @@ class AsyncSqliteSaver(BaseCheckpointSaver[str]):
             )
             await self.conn.commit()
 
+    async def adelete_thread(self, thread_id: str) -> None:
+        """Delete all checkpoints and writes associated with a thread ID.
+
+        Args:
+            thread_id (str): The thread ID to delete.
+
+        Returns:
+            None
+        """
+        async with self.lock, self.conn.cursor() as cur:
+            await cur.execute(
+                "DELETE FROM checkpoints WHERE thread_id = ?",
+                (str(thread_id),),
+            )
+            await cur.execute(
+                "DELETE FROM writes WHERE thread_id = ?",
+                (str(thread_id),),
+            )
+            await self.conn.commit()
+
     def get_next_version(self, current: Optional[str], channel: ChannelProtocol) -> str:
         """Generate the next version ID for a channel.
 

libs/checkpoint/langgraph/checkpoint/base/__init__.py

@@ -321,6 +321,17 @@ class BaseCheckpointSaver(Generic[V]):
         """
         raise NotImplementedError
 
+    def delete_thread(
+        self,
+        thread_id: str,
+    ) -> None:
+        """Delete all checkpoints and writes associated with a specific thread ID.
+
+        Args:
+            thread_id (str): The thread ID whose checkpoints should be deleted.
+        """
+        raise NotImplementedError
+
     async def aget(self, config: RunnableConfig) -> Optional[Checkpoint]:
         """Asynchronously fetch a checkpoint using the given configuration.
 
@@ -415,6 +426,17 @@ class BaseCheckpointSaver(Generic[V]):
         """
         raise NotImplementedError
 
+    async def adelete_thread(
+        self,
+        thread_id: str,
+    ) -> None:
+        """Delete all checkpoints and writes associated with a specific thread ID.
+
+        Args:
+            thread_id (str): The thread ID whose checkpoints should be deleted.
+        """
+        raise NotImplementedError
+
     def get_next_version(self, current: Optional[V], channel: ChannelProtocol) -> V:
         """Generate the next version ID for a channel.
 

libs/checkpoint/langgraph/checkpoint/memory/__init__.py

@@ -69,7 +69,7 @@ class InMemorySaver(
         ],
     ]
     writes: defaultdict[
-        tuple[str, str, str],
+        tuple[str, str, str],  # thread ID, checkpoint NS, checkpoint ID
         dict[tuple[str, int], tuple[str, str, tuple[str, bytes], str]],
     ]
     blobs: dict[
@@ -451,6 +451,24 @@ class InMemorySaver(
                 task_path,
             )
 
+    def delete_thread(self, thread_id: str) -> None:
+        """Delete all checkpoints and writes associated with a thread ID.
+
+        Args:
+            thread_id (str): The thread ID to delete.
+
+        Returns:
+            None
+        """
+        if thread_id in self.storage:
+            del self.storage[thread_id]
+        for k in list(self.writes.keys()):
+            if k[0] == thread_id:
+                del self.writes[k]
+        for k in list(self.blobs.keys()):
+            if k[0] == thread_id:
+                del self.blobs[k]
+
     async def aget_tuple(self, config: RunnableConfig) -> Optional[CheckpointTuple]:
         """Asynchronous version of get_tuple.
 
@@ -530,6 +548,17 @@ class InMemorySaver(
         """
         return self.put_writes(config, writes, task_id, task_path)
 
+    async def adelete_thread(self, thread_id: str) -> None:
+        """Delete all checkpoints and writes associated with a thread ID.
+
+        Args:
+            thread_id (str): The thread ID to delete.
+
+        Returns:
+            None
+        """
+        return self.delete_thread(thread_id)
+
     def get_next_version(self, current: Optional[str], channel: ChannelProtocol) -> str:
         if current is None:
             current_v = 0
@@ -615,4 +644,4 @@ class PersistentDict(defaultdict):
                 except Exception:
                     logging.error(f"Failed to load file: {fileobj.name}")
                     raise
-            raise ValueError("File not in a supported f ormat")
+            raise ValueError("File not in a supported format")

libs/cli/langgraph_cli/cli.py

@@ -168,6 +168,13 @@ def cli():
 @OPT_DEBUGGER_BASE_URL
 @OPT_WATCH
 @OPT_POSTGRES_URI
+@click.option(
+    "--image",
+    type=str,
+    default=None,
+    help="Docker image to use for the langgraph-api service. If specified, skips building and uses this image directly."
+    " Useful if you want to test against an image already built using `langgraph build`.",
+)
 @click.option(
     "--wait",
     is_flag=True,
@@ -187,6 +194,7 @@ def up(
     debugger_port: Optional[int],
     debugger_base_url: Optional[str],
     postgres_uri: Optional[str],
+    image: Optional[str],
 ):
     click.secho("Starting LangGraph API server...", fg="green")
     click.secho(
@@ -207,6 +215,7 @@ For production use, requires a license key in env var LANGGRAPH_CLOUD_LICENSE_KE
             debugger_port=debugger_port,
             debugger_base_url=debugger_base_url,
             postgres_uri=postgres_uri,
+            image=image,
         )
         # add up + options
         args.extend(["up", "--remove-orphans"])
@@ -572,6 +581,14 @@ def dockerfile(save_path: str, config: pathlib.Path, add_docker_compose: bool) -
     help="Don't raise errors for synchronous I/O blocking operations in your code.",
     default=False,
 )
+@click.option(
+    "--tunnel",
+    is_flag=True,
+    help="Expose the local server via a public tunnel (in this case, Cloudflare) "
+    "for remote frontend access. This avoids issues with browsers "
+    "or networks blocking localhost connections.",
+    default=False,
+)
 @cli.command(
     "dev",
     help="🏃‍♀️‍➡️ Run LangGraph API server in development mode with hot reloading and debugging support",
@@ -588,6 +605,7 @@ def dev(
     wait_for_client: bool,
     studio_url: Optional[str],
     allow_blocking: bool,
+    tunnel: bool,
 ):
     """CLI entrypoint for running the LangGraph API server."""
     try:
@@ -655,6 +673,7 @@ def dev(
         ui_config=config_json.get("ui_config"),
         studio_url=studio_url,
         allow_blocking=allow_blocking,
+        tunnel=tunnel,
     )
 
 
@@ -682,6 +701,7 @@ def prepare_args_and_stdin(
     debugger_port: Optional[int] = None,
     debugger_base_url: Optional[str] = None,
     postgres_uri: Optional[str] = None,
+    image: Optional[str] = None,
 ) -> Tuple[List[str], str]:
     assert config_path.exists(), f"Config file not found: {config_path}"
     # prepare args
@@ -691,6 +711,7 @@ def prepare_args_and_stdin(
         debugger_port=debugger_port,
         debugger_base_url=debugger_base_url,
         postgres_uri=postgres_uri,
+        image=image,  # Pass image to compose YAML generator
     )
     args = [
         "--project-directory",
@@ -706,6 +727,7 @@ def prepare_args_and_stdin(
         config,
         watch=watch,
         base_image=langgraph_cli.config.default_base_image(config),
+        image=image,
     )
     return args, stdin
 
@@ -723,6 +745,7 @@ def prepare(
     debugger_port: Optional[int] = None,
     debugger_base_url: Optional[str] = None,
     postgres_uri: Optional[str] = None,
+    image: Optional[str] = None,
 ) -> Tuple[List[str], str]:
     """Prepare the arguments and stdin for running the LangGraph API server."""
     config_json = langgraph_cli.config.validate_config_file(config_path)
@@ -747,5 +770,6 @@ def prepare(
         debugger_port=debugger_port,
         debugger_base_url=debugger_base_url or f"http://127.0.0.1:{port}",
         postgres_uri=postgres_uri,
+        image=image,
     )
     return args, stdin

libs/cli/langgraph_cli/config.py

@@ -326,6 +326,10 @@ class Config(TypedDict, total=False):
     Must be >= 20 if provided.
     """
 
+    _INTERNAL_docker_tag: Optional[str]
+    """Optional. Internal use only.
+    """
+
     pip_config_file: Optional[str]
     """Optional. Path to a pip config file (e.g., "/etc/pip.conf" or "pip.ini") for controlling
     package installation (custom indices, credentials, etc.).
@@ -480,6 +484,7 @@ def validate_config(config: Config) -> Config:
         "node_version": node_version,
         "python_version": python_version,
         "pip_config_file": config.get("pip_config_file"),
+        "_INTERNAL_docker_tag": config.get("_INTERNAL_docker_tag"),
         "dependencies": config.get("dependencies", []),
         "dockerfile_lines": config.get("dockerfile_lines", []),
         "graphs": config.get("graphs", {}),
@@ -1025,7 +1030,9 @@ def _get_node_pm_install_cmd(config_path: pathlib.Path, config: Config) -> str:
 
 
 def python_config_to_docker(
-    config_path: pathlib.Path, config: Config, base_image: str
+    config_path: pathlib.Path,
+    config: Config,
+    base_image: str,
 ) -> tuple[str, dict[str, str]]:
     """Generate a Dockerfile from the configuration."""
     # configure pip
@@ -1040,6 +1047,8 @@ def python_config_to_docker(
         else ""
     )
 
+    docker_tag = config.get("_INTERNAL_docker_tag") or config["python_version"]
+
     # collect dependencies
     pypi_deps = [dep for dep in config["dependencies"] if not dep.startswith(".")]
     local_deps = _assemble_local_deps(config_path, config)
@@ -1160,7 +1169,7 @@ ADD {relpath} /deps/{name}
         )
 
     docker_file_contents = [
-        f"FROM {base_image}:{config['python_version']}",
+        f"FROM {base_image}:{docker_tag}",
         "",
         os.linesep.join(config["dockerfile_lines"]),
         "",
@@ -1192,10 +1201,13 @@ ADD {relpath} /deps/{name}
 
 
 def node_config_to_docker(
-    config_path: pathlib.Path, config: Config, base_image: str
+    config_path: pathlib.Path,
+    config: Config,
+    base_image: str,
 ) -> tuple[str, dict[str, str]]:
     faux_path = f"/deps/{config_path.parent.name}"
     install_cmd = _get_node_pm_install_cmd(config_path, config)
+    docker_tag = config.get("_INTERNAL_docker_tag") or config["node_version"]
 
     env_vars: list[str] = []
 
@@ -1222,7 +1234,7 @@ def node_config_to_docker(
     env_vars.append(f"ENV LANGSERVE_GRAPHS='{json.dumps(config['graphs'])}'")
 
     docker_file_contents = [
-        f"FROM {base_image}:{config['node_version']}",
+        f"FROM {base_image}:{docker_tag}",
         "",
         os.linesep.join(config["dockerfile_lines"]),
         "",
@@ -1246,8 +1258,13 @@ def default_base_image(config: Config) -> str:
     return "langchain/langgraph-api"
 
 
-def docker_tag(config: Config, base_image: Optional[str] = None) -> str:
+def docker_tag(
+    config: Config,
+    base_image: Optional[str] = None,
+) -> str:
     base_image = base_image or default_base_image(config)
+    if config.get("_INTERNAL_docker_tag"):
+        return f"{base_image}:{config['_INTERNAL_docker_tag']}"
 
     if config.get("node_version") and not config.get("python_version"):
         return f"{base_image}:{config['node_version']}"
@@ -1255,7 +1272,9 @@ def docker_tag(config: Config, base_image: Optional[str] = None) -> str:
 
 
 def config_to_docker(
-    config_path: pathlib.Path, config: Config, base_image: Optional[str] = None
+    config_path: pathlib.Path,
+    config: Config,
+    base_image: Optional[str] = None,
 ) -> tuple[str, dict[str, str]]:
     base_image = base_image or default_base_image(config)
 
@@ -1269,6 +1288,7 @@ def config_to_compose(
     config_path: pathlib.Path,
     config: Config,
     base_image: Optional[str] = None,
+    image: Optional[str] = None,
     watch: bool = False,
 ) -> str:
     base_image = base_image or default_base_image(config)
@@ -1295,19 +1315,28 @@ def config_to_compose(
 """
     else:
         watch_str = ""
+    if image:
+        return f"""
+{textwrap.indent(env_vars_str, "            ")}
+        {env_file_str}
+        {watch_str}
+"""
 
-    dockerfile, additional_contexts = config_to_docker(config_path, config, base_image)
+    else:
+        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_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"""
+        return f"""
 {textwrap.indent(env_vars_str, "            ")}
         {env_file_str}
         pull_policy: build

libs/cli/langgraph_cli/docker.py

@@ -143,6 +143,8 @@ def compose_as_dict(
     debugger_base_url: Optional[str] = None,
     # postgres://user:password@host:port/database?option=value
     postgres_uri: Optional[str] = None,
+    # If you are running against an already-built image, you can pass it here
+    image: Optional[str] = None,
 ) -> dict:
     """Create a docker compose file as a dictionary in YML style."""
     if postgres_uri is None:
@@ -211,6 +213,8 @@ def compose_as_dict(
             "POSTGRES_URI": postgres_uri,
         },
     }
+    if image:
+        services["langgraph-api"]["image"] = image
 
     # If Postgres is included, add it to the dependencies of langgraph-api
     if include_db:
@@ -244,6 +248,7 @@ def compose(
     debugger_base_url: Optional[str] = None,
     # postgres://user:password@host:port/database?option=value
     postgres_uri: Optional[str] = None,
+    image: Optional[str] = None,
 ) -> str:
     """Create a docker compose file as a string."""
     compose_content = compose_as_dict(
@@ -252,6 +257,7 @@ def compose(
         debugger_port=debugger_port,
         debugger_base_url=debugger_base_url,
         postgres_uri=postgres_uri,
+        image=image,
     )
     compose_str = dict_to_yaml(compose_content)
     return compose_str

libs/cli/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langgraph-cli"
-version = "0.2.4"
+version = "0.2.7"
 description = "CLI for interacting with LangGraph API"
 authors = []
 license = "MIT"
@@ -14,7 +14,7 @@ langgraph = "langgraph_cli.cli:cli"
 [tool.poetry.dependencies]
 python = "^3.9.0,<4.0"
 click = "^8.1.7"
-langgraph-api = { version = ">=0.1.0,<0.2.0", optional = true, python = ">=3.11,<4.0" }
+langgraph-api = { version = ">=0.1.12,<0.2.0", optional = true, python = ">=3.11,<4.0" }
 langgraph-runtime-inmem = { version = ">=0.0.1,<0.1.0", optional = true, python = ">=3.11,<4.0" }
 langgraph-sdk = { version = ">=0.1.0,<0.2.0", optional = true, python = ">=3.11,<4.0" }
 python-dotenv = { version = ">=0.8.0", optional = true }

libs/cli/schemas/schema.json

@@ -29,6 +29,17 @@
               ],
               "description": "Optional. Path to a pip config file (e.g., \"/etc/pip.conf\" or \"pip.ini\") for controlling\npackage installation (custom indices, credentials, etc.).\n\nOnly relevant if Python dependencies are installed via pip. If omitted, default pip settings are used.\n"
             },
+            "_INTERNAL_docker_tag": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Optional. Internal use only.\n"
+            },
             "auth": {
               "anyOf": [
                 {
@@ -145,6 +156,17 @@
               ],
               "description": "Optional. Node.js version as a major version (e.g. '20'), if your deployment needs Node.\nMust be >= 20 if provided.\n"
             },
+            "_INTERNAL_docker_tag": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Optional. Internal use only.\n"
+            },
             "auth": {
               "anyOf": [
                 {

libs/cli/schemas/schema.v0.json

@@ -29,6 +29,17 @@
               ],
               "description": "Optional. Path to a pip config file (e.g., \"/etc/pip.conf\" or \"pip.ini\") for controlling\npackage installation (custom indices, credentials, etc.).\n\nOnly relevant if Python dependencies are installed via pip. If omitted, default pip settings are used.\n"
             },
+            "_INTERNAL_docker_tag": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Optional. Internal use only.\n"
+            },
             "auth": {
               "anyOf": [
                 {
@@ -145,6 +156,17 @@
               ],
               "description": "Optional. Node.js version as a major version (e.g. '20'), if your deployment needs Node.\nMust be >= 20 if provided.\n"
             },
+            "_INTERNAL_docker_tag": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Optional. Internal use only.\n"
+            },
             "auth": {
               "anyOf": [
                 {

libs/cli/tests/unit_tests/cli/test_cli.py

@@ -160,6 +160,110 @@ services:
     assert clean_empty_lines(actual_stdin) == expected_stdin
 
 
+def test_prepare_args_and_stdin_with_image() -> None:
+    # this basically serves as an end-to-end test for using config and docker helpers
+    config_path = pathlib.Path(__file__).parent / "langgraph.json"
+    config = validate_config(
+        Config(dependencies=[".", "../../.."], graphs={"agent": "agent.py:graph"})
+    )
+    port = 8000
+    debugger_port = 8001
+    debugger_graph_url = f"http://127.0.0.1:{port}"
+
+    actual_args, actual_stdin = prepare_args_and_stdin(
+        capabilities=DEFAULT_DOCKER_CAPABILITIES,
+        config_path=config_path,
+        config=config,
+        docker_compose=pathlib.Path("custom-docker-compose.yml"),
+        port=port,
+        debugger_port=debugger_port,
+        debugger_base_url=debugger_graph_url,
+        watch=True,
+        image="my-cool-image",
+    )
+
+    expected_args = [
+        "--project-directory",
+        str(pathlib.Path(__file__).parent.absolute()),
+        "-f",
+        "custom-docker-compose.yml",
+        "-f",
+        "-",
+    ]
+    expected_stdin = f"""volumes:
+    langgraph-data:
+        driver: local
+services:
+    langgraph-redis:
+        image: redis:6
+        healthcheck:
+            test: redis-cli ping
+            interval: 5s
+            timeout: 1s
+            retries: 5
+    langgraph-postgres:
+        image: pgvector/pgvector:pg16
+        ports:
+            - "5433:5432"
+        environment:
+            POSTGRES_DB: postgres
+            POSTGRES_USER: postgres
+            POSTGRES_PASSWORD: postgres
+        command:
+            - postgres
+            - -c
+            - shared_preload_libraries=vector
+        volumes:
+            - langgraph-data:/var/lib/postgresql/data
+        healthcheck:
+            test: pg_isready -U postgres
+            start_period: 10s
+            timeout: 1s
+            retries: 5
+            interval: 60s
+            start_interval: 1s
+    langgraph-debugger:
+        image: langchain/langgraph-debugger
+        restart: on-failure
+        depends_on:
+            langgraph-postgres:
+                condition: service_healthy
+        ports:
+            - "{debugger_port}:3968"
+        environment:
+            VITE_STUDIO_LOCAL_GRAPH_URL: {debugger_graph_url}
+    langgraph-api:
+        ports:
+            - "8000:8000"
+        depends_on:
+            langgraph-redis:
+                condition: service_healthy
+            langgraph-postgres:
+                condition: service_healthy
+        environment:
+            REDIS_URI: redis://langgraph-redis:6379
+            POSTGRES_URI: {DEFAULT_POSTGRES_URI}
+        image: my-cool-image
+        healthcheck:
+            test: python /api/healthcheck.py
+            interval: 60s
+            start_interval: 1s
+            start_period: 10s
+        
+        
+        develop:
+            watch:
+                - path: langgraph.json
+                  action: rebuild
+                - path: .
+                  action: rebuild
+                - path: ../../..
+                  action: rebuild\
+"""
+    assert actual_args == expected_args
+    assert clean_empty_lines(actual_stdin) == expected_stdin
+
+
 def test_version_option() -> None:
     """Test the --version option of the CLI."""
     runner = CliRunner()

libs/cli/tests/unit_tests/test_config.py

@@ -29,6 +29,7 @@ def test_validate_config():
     }
     actual_config = validate_config(expected_config)
     expected_config = {
+        "_INTERNAL_docker_tag": None,
         "python_version": "3.11",
         "node_version": None,
         "pip_config_file": None,
@@ -47,6 +48,7 @@ def test_validate_config():
     # full config
     env = ".env"
     expected_config = {
+        "_INTERNAL_docker_tag": None,
         "python_version": "3.12",
         "node_version": None,
         "pip_config_file": "pipconfig.txt",
@@ -567,6 +569,39 @@ RUN (test ! -f /api/langgraph_api/js/build.mts && echo "Prebuild script not foun
     assert additional_contexts == {}
 
 
+def test_config_to_docker_nodejs_internal_docker_tag():
+    graphs = {"agent": "./graphs/agent.js:graph"}
+    actual_docker_stdin, additional_contexts = config_to_docker(
+        PATH_TO_CONFIG,
+        validate_config(
+            {
+                "node_version": "20",
+                "graphs": graphs,
+                "dockerfile_lines": ["ARG meow", "ARG foo"],
+                "auth": {"path": "./graphs/auth.mts:auth"},
+                "ui": {"agent": "./graphs/agent.ui.jsx"},
+                "ui_config": {"shared": ["nuqs"]},
+                "_INTERNAL_docker_tag": "my-tag",
+            }
+        ),
+        "langchain/langgraphjs-api",
+    )
+    expected_docker_stdin = """FROM langchain/langgraphjs-api:my-tag
+ARG meow
+ARG foo
+ADD . /deps/unit_tests
+RUN cd /deps/unit_tests && npm i
+ENV LANGGRAPH_AUTH='{"path": "./graphs/auth.mts:auth"}'
+ENV LANGGRAPH_UI='{"agent": "./graphs/agent.ui.jsx"}'
+ENV LANGGRAPH_UI_CONFIG='{"shared": ["nuqs"]}'
+ENV LANGSERVE_GRAPHS='{"agent": "./graphs/agent.js:graph"}'
+WORKDIR /deps/unit_tests
+RUN (test ! -f /api/langgraph_api/js/build.mts && echo "Prebuild script not found, skipping") || tsx /api/langgraph_api/js/build.mts"""
+
+    assert clean_empty_lines(actual_docker_stdin) == expected_docker_stdin
+    assert additional_contexts == {}
+
+
 def test_config_to_docker_gen_ui_python():
     graphs = {"agent": "./agent.py:graph"}
     actual_docker_stdin, additional_contexts = config_to_docker(

libs/langgraph/Makefile

@@ -62,7 +62,7 @@ MAXFAIL_ARGS := $(if $(MAXFAIL),--maxfail $(MAXFAIL),)
 XDIST_ARGS := $(if $(WORKERS),-x $(XDIST_ARGS),)
 
 test_watch:
-	make start-postgres && poetry run ptw . -- --ff -vv $(XDIST_ARGS) $(MAXFAIL_ARGS) --snapshot-update --tb short $(TEST); \
+	make start-postgres && poetry run ptw . -- --ff -vv $(XDIST_ARGS) $(MAXFAIL_ARGS) $(TEST); \
 	EXIT_CODE=$$?; \
 	make stop-postgres; \
 	exit $$EXIT_CODE
@@ -78,7 +78,7 @@ test_watch_all:
 PYTHON_FILES=.
 MYPY_CACHE=.mypy_cache
 lint format: PYTHON_FILES=.
-lint_diff format_diff: PYTHON_FILES=$(shell git diff --name-only --relative --diff-filter=d main . | grep -E '\.py$$|\.ipynb$$')
+lint_diff format_diff: PYTHON_FILES=$(shell git diff --name-only --relative --diff-filter=d main . | grep -E r'\.py$$|\.ipynb$$')
 lint_package: PYTHON_FILES=langgraph
 lint_tests: PYTHON_FILES=tests
 lint_tests: MYPY_CACHE=.mypy_cache_test

libs/langgraph/bench/pydantic_state.py

@@ -1,7 +1,8 @@
 import operator
+from collections.abc import Sequence
 from functools import partial
 from random import choice
-from typing import Annotated, Optional, Sequence
+from typing import Annotated, Optional
 
 from pydantic import BaseModel, Field, field_validator
 

libs/langgraph/bench/wide_dict.py

@@ -1,7 +1,8 @@
 import operator
+from collections.abc import Sequence
 from functools import partial
 from random import choice
-from typing import Annotated, Optional, Sequence
+from typing import Annotated, Optional
 
 from typing_extensions import TypedDict
 

libs/langgraph/bench/wide_state.py

@@ -1,8 +1,9 @@
 import operator
+from collections.abc import Sequence
 from dataclasses import dataclass, field
 from functools import partial
 from random import choice
-from typing import Annotated, Optional, Sequence
+from typing import Annotated, Optional
 
 from langgraph.constants import END, START
 from langgraph.graph.state import StateGraph

libs/langgraph/langgraph/_api/deprecation.py

@@ -1,6 +1,6 @@
 import functools
 import warnings
-from typing import Any, Callable, Type, TypeVar, Union, cast
+from typing import Any, Callable, TypeVar, Union, cast
 
 
 class LangGraphDeprecationWarning(DeprecationWarning):
@@ -8,7 +8,7 @@ class LangGraphDeprecationWarning(DeprecationWarning):
 
 
 F = TypeVar("F", bound=Callable[..., Any])
-C = TypeVar("C", bound=Type[Any])
+C = TypeVar("C", bound=type[Any])
 
 
 def deprecated(

libs/langgraph/langgraph/channels/any_value.py

@@ -1,4 +1,5 @@
-from typing import Any, Generic, Sequence, Type
+from collections.abc import Sequence
+from typing import Any, Generic
 
 from typing_extensions import Self
 
@@ -21,12 +22,12 @@ class AnyValue(Generic[Value], BaseChannel[Value, Value, Value]):
         return isinstance(value, AnyValue)
 
     @property
-    def ValueType(self) -> Type[Value]:
+    def ValueType(self) -> type[Value]:
         """The type of the value stored in the channel."""
         return self.typ
 
     @property
-    def UpdateType(self) -> Type[Value]:
+    def UpdateType(self) -> type[Value]:
         """The type of the update received by the channel."""
         return self.typ
 

libs/langgraph/langgraph/channels/base.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
-from typing import Any, Generic, Sequence, TypeVar
+from collections.abc import Sequence
+from typing import Any, Generic, TypeVar
 
 from typing_extensions import Self
 

libs/langgraph/langgraph/channels/binop.py

@@ -1,5 +1,6 @@
 import collections.abc
-from typing import Callable, Generic, Sequence, Type
+from collections.abc import Sequence
+from typing import Callable, Generic
 
 from typing_extensions import NotRequired, Required, Self
 
@@ -31,7 +32,7 @@ class BinaryOperatorAggregate(Generic[Value], BaseChannel[Value, Value, Value]):
 
     __slots__ = ("value", "operator")
 
-    def __init__(self, typ: Type[Value], operator: Callable[[Value, Value], Value]):
+    def __init__(self, typ: type[Value], operator: Callable[[Value, Value], Value]):
         super().__init__(typ)
         self.operator = operator
         # special forms from typing or collections.abc are not instantiable
@@ -57,12 +58,12 @@ class BinaryOperatorAggregate(Generic[Value], BaseChannel[Value, Value, Value]):
         )
 
     @property
-    def ValueType(self) -> Type[Value]:
+    def ValueType(self) -> type[Value]:
         """The type of the value stored in the channel."""
         return self.typ
 
     @property
-    def UpdateType(self) -> Type[Value]:
+    def UpdateType(self) -> type[Value]:
         """The type of the update received by the channel."""
         return self.typ
 

libs/langgraph/langgraph/channels/dynamic_barrier_value.py

@@ -1,4 +1,5 @@
-from typing import Any, Generic, NamedTuple, Optional, Sequence, Type, Union
+from collections.abc import Sequence, Set
+from typing import Any, Generic, NamedTuple, Optional, Union
 
 from typing_extensions import Self
 
@@ -8,11 +9,11 @@ from langgraph.errors import EmptyChannelError, InvalidUpdateError
 
 
 class WaitForNames(NamedTuple):
-    names: set[Any]
+    names: Set[Any]
 
 
 class DynamicBarrierValue(
-    Generic[Value], BaseChannel[Value, Union[Value, WaitForNames], set[Value]]
+    Generic[Value], BaseChannel[Value, Union[Value, WaitForNames], Set[Value]]
 ):
     """A channel that switches between two states
 
@@ -25,10 +26,10 @@ class DynamicBarrierValue(
 
     __slots__ = ("names", "seen")
 
-    names: Optional[set[Value]]
+    names: Optional[Set[Value]]
     seen: set[Value]
 
-    def __init__(self, typ: Type[Value]) -> None:
+    def __init__(self, typ: type[Value]) -> None:
         super().__init__(typ)
         self.names = None
         self.seen = set()
@@ -37,12 +38,12 @@ class DynamicBarrierValue(
         return isinstance(value, DynamicBarrierValue) and value.names == self.names
 
     @property
-    def ValueType(self) -> Type[Value]:
+    def ValueType(self) -> type[Value]:
         """The type of the value stored in the channel."""
         return self.typ
 
     @property
-    def UpdateType(self) -> Type[Value]:
+    def UpdateType(self) -> type[Value]:
         """The type of the update received by the channel."""
         return self.typ
 
@@ -54,11 +55,11 @@ class DynamicBarrierValue(
         empty.seen = self.seen.copy()
         return empty
 
-    def checkpoint(self) -> tuple[Optional[set[Value]], set[Value]]:
+    def checkpoint(self) -> tuple[Optional[Set[Value]], set[Value]]:
         return (self.names, self.seen)
 
     def from_checkpoint(
-        self, checkpoint: tuple[Optional[set[Value]], set[Value]]
+        self, checkpoint: tuple[Optional[Set[Value]], set[Value]]
     ) -> Self:
         empty = self.__class__(self.typ)
         empty.key = self.key

libs/langgraph/langgraph/channels/ephemeral_value.py

@@ -1,4 +1,5 @@
-from typing import Any, Generic, Sequence, Type
+from collections.abc import Sequence
+from typing import Any, Generic
 
 from typing_extensions import Self
 
@@ -21,12 +22,12 @@ class EphemeralValue(Generic[Value], BaseChannel[Value, Value, Value]):
         return isinstance(value, EphemeralValue) and value.guard == self.guard
 
     @property
-    def ValueType(self) -> Type[Value]:
+    def ValueType(self) -> type[Value]:
         """The type of the value stored in the channel."""
         return self.typ
 
     @property
-    def UpdateType(self) -> Type[Value]:
+    def UpdateType(self) -> type[Value]:
         """The type of the update received by the channel."""
         return self.typ
 

libs/langgraph/langgraph/channels/last_value.py

@@ -1,4 +1,5 @@
-from typing import Any, Generic, Sequence, Type
+from collections.abc import Sequence
+from typing import Any, Generic
 
 from typing_extensions import Self
 
@@ -25,12 +26,12 @@ class LastValue(Generic[Value], BaseChannel[Value, Value, Value]):
         return isinstance(value, LastValue)
 
     @property
-    def ValueType(self) -> Type[Value]:
+    def ValueType(self) -> type[Value]:
         """The type of the value stored in the channel."""
         return self.typ
 
     @property
-    def UpdateType(self) -> Type[Value]:
+    def UpdateType(self) -> type[Value]:
         """The type of the update received by the channel."""
         return self.typ
 

libs/langgraph/langgraph/channels/named_barrier_value.py

@@ -1,4 +1,5 @@
-from typing import Generic, Sequence, Type
+from collections.abc import Sequence
+from typing import Generic
 
 from typing_extensions import Self
 
@@ -15,7 +16,7 @@ class NamedBarrierValue(Generic[Value], BaseChannel[Value, Value, set[Value]]):
     names: set[Value]
     seen: set[Value]
 
-    def __init__(self, typ: Type[Value], names: set[Value]) -> None:
+    def __init__(self, typ: type[Value], names: set[Value]) -> None:
         super().__init__(typ)
         self.names = names
         self.seen: set[str] = set()
@@ -24,12 +25,12 @@ class NamedBarrierValue(Generic[Value], BaseChannel[Value, Value, set[Value]]):
         return isinstance(value, NamedBarrierValue) and value.names == self.names
 
     @property
-    def ValueType(self) -> Type[Value]:
+    def ValueType(self) -> type[Value]:
         """The type of the value stored in the channel."""
         return self.typ
 
     @property
-    def UpdateType(self) -> Type[Value]:
+    def UpdateType(self) -> type[Value]:
         """The type of the update received by the channel."""
         return self.typ
 

libs/langgraph/langgraph/channels/topic.py

@@ -1,4 +1,5 @@
-from typing import Any, Generic, Iterator, Sequence, Type, Union
+from collections.abc import Iterator, Sequence
+from typing import Any, Generic, Union
 
 from typing_extensions import Self
 
@@ -28,7 +29,7 @@ class Topic(
 
     __slots__ = ("values", "accumulate")
 
-    def __init__(self, typ: Type[Value], accumulate: bool = False) -> None:
+    def __init__(self, typ: type[Value], accumulate: bool = False) -> None:
         super().__init__(typ)
         # attrs
         self.accumulate = accumulate

libs/langgraph/langgraph/channels/untracked_value.py

@@ -1,4 +1,5 @@
-from typing import Generic, Sequence, Type
+from collections.abc import Sequence
+from typing import Generic
 
 from typing_extensions import Self
 
@@ -12,7 +13,7 @@ class UntrackedValue(Generic[Value], BaseChannel[Value, Value, Value]):
 
     __slots__ = ("value", "guard")
 
-    def __init__(self, typ: Type[Value], guard: bool = True) -> None:
+    def __init__(self, typ: type[Value], guard: bool = True) -> None:
         super().__init__(typ)
         self.guard = guard
         self.value = MISSING
@@ -21,12 +22,12 @@ class UntrackedValue(Generic[Value], BaseChannel[Value, Value, Value]):
         return isinstance(value, UntrackedValue) and value.guard == self.guard
 
     @property
-    def ValueType(self) -> Type[Value]:
+    def ValueType(self) -> type[Value]:
         """The type of the value stored in the channel."""
         return self.typ
 
     @property
-    def UpdateType(self) -> Type[Value]:
+    def UpdateType(self) -> type[Value]:
         """The type of the update received by the channel."""
         return self.typ
 

libs/langgraph/langgraph/constants.py

@@ -1,6 +1,7 @@
 import sys
+from collections.abc import Mapping
 from types import MappingProxyType
-from typing import Any, Literal, Mapping, cast
+from typing import Any, Literal, cast
 
 from langgraph.types import Interrupt, Send  # noqa: F401
 

libs/langgraph/langgraph/errors.py

@@ -1,5 +1,6 @@
+from collections.abc import Sequence
 from enum import Enum
-from typing import Any, Sequence
+from typing import Any
 
 from langgraph.checkpoint.base import EmptyChannelError  # noqa: F401
 from langgraph.types import Command, Interrupt

libs/langgraph/langgraph/func/__init__.py

@@ -2,14 +2,13 @@ import asyncio
 import concurrent.futures
 import functools
 import inspect
+from collections.abc import Awaitable, Sequence
 from dataclasses import dataclass
 from typing import (
     Any,
-    Awaitable,
     Callable,
     Generic,
     Optional,
-    Sequence,
     TypeVar,
     Union,
     get_args,

libs/langgraph/langgraph/graph/branch.py

@@ -1,19 +1,17 @@
+from collections.abc import Awaitable, Hashable, Sequence
 from inspect import (
     isfunction,
     ismethod,
     signature,
 )
+from itertools import zip_longest
 from types import FunctionType
 from typing import (
     Any,
-    Awaitable,
     Callable,
-    Hashable,
     Literal,
     NamedTuple,
     Optional,
-    Sequence,
-    Type,
     Union,
     cast,
     get_args,
@@ -29,12 +27,17 @@ from langchain_core.runnables import (
 
 from langgraph.constants import END, START
 from langgraph.errors import InvalidUpdateError
-from langgraph.pregel.write import ChannelWrite
+from langgraph.pregel.write import PASSTHROUGH, ChannelWrite, ChannelWriteEntry
 from langgraph.types import Send
 from langgraph.utils.runnable import (
     RunnableCallable,
 )
 
+Writer = Callable[
+    [Sequence[Union[str, Send]]],
+    Sequence[Union[ChannelWriteEntry, Send]],
+]
+
 
 def _get_branch_path_input_schema(
     path: Union[
@@ -42,7 +45,7 @@ def _get_branch_path_input_schema(
         Callable[..., Awaitable[Union[Hashable, list[Hashable]]]],
         Runnable[Any, Union[Hashable, list[Hashable]]],
     ],
-) -> Optional[Type[Any]]:
+) -> Optional[type[Any]]:
     input = None
     # detect input schema annotation in the branch callable
     try:
@@ -85,7 +88,7 @@ class Branch(NamedTuple):
     path: Runnable[Any, Union[Hashable, list[Hashable]]]
     ends: Optional[dict[Hashable, str]]
     then: Optional[str] = None
-    input_schema: Optional[Type[Any]] = None
+    input_schema: Optional[type[Any]] = None
 
     @classmethod
     def from_path(
@@ -124,9 +127,7 @@ class Branch(NamedTuple):
 
     def run(
         self,
-        writer: Callable[
-            [Sequence[Union[str, Send]], RunnableConfig], Optional[ChannelWrite]
-        ],
+        writer: Writer,
         reader: Optional[Callable[[RunnableConfig], Any]] = None,
     ) -> RunnableCallable:
         return ChannelWrite.register_writer(
@@ -138,7 +139,15 @@ class Branch(NamedTuple):
                 name=None,
                 trace=False,
                 func_accepts_config=True,
+            ),
+            list(
+                zip_longest(
+                    writer([e for e in self.ends.values() if e != END]),
+                    [str(la) for la, e in self.ends.items() if e != END],
+                )
             )
+            if self.ends
+            else None,
         )
 
     def _route(
@@ -147,9 +156,7 @@ class Branch(NamedTuple):
         config: RunnableConfig,
         *,
         reader: Optional[Callable[[RunnableConfig], Any]],
-        writer: Callable[
-            [Sequence[Union[str, Send]], RunnableConfig], Optional[ChannelWrite]
-        ],
+        writer: Writer,
     ) -> Runnable:
         if reader:
             value = reader(config)
@@ -172,9 +179,7 @@ class Branch(NamedTuple):
         config: RunnableConfig,
         *,
         reader: Optional[Callable[[RunnableConfig], Any]],
-        writer: Callable[
-            [Sequence[Union[str, Send]], RunnableConfig], Optional[ChannelWrite]
-        ],
+        writer: Writer,
     ) -> Runnable:
         if reader:
             value = reader(config)
@@ -193,9 +198,7 @@ class Branch(NamedTuple):
 
     def _finish(
         self,
-        writer: Callable[
-            [Sequence[Union[str, Send]], RunnableConfig], Optional[ChannelWrite]
-        ],
+        writer: Writer,
         input: Any,
         result: Any,
         config: RunnableConfig,
@@ -212,4 +215,18 @@ class Branch(NamedTuple):
             raise ValueError("Branch did not return a valid destination")
         if any(p.node == END for p in destinations if isinstance(p, Send)):
             raise InvalidUpdateError("Cannot send a packet to the END node")
-        return writer(destinations, config) or input
+        entries = writer(destinations)
+        if not entries:
+            return input
+        else:
+            need_passthrough = False
+            for e in entries:
+                if isinstance(e, ChannelWriteEntry):
+                    if e.value is PASSTHROUGH:
+                        need_passthrough = True
+                        break
+            if need_passthrough:
+                return ChannelWrite(entries)
+            else:
+                ChannelWrite.do_write(config, entries)
+                return input

libs/langgraph/langgraph/graph/graph.py

@@ -1,23 +1,17 @@
-import asyncio
 import logging
 from collections import defaultdict
+from collections.abc import Awaitable, Hashable, Sequence
 from typing import (
     Any,
-    Awaitable,
     Callable,
-    Hashable,
     NamedTuple,
     Optional,
-    Sequence,
     Union,
     cast,
     overload,
 )
 
 from langchain_core.runnables import Runnable
-from langchain_core.runnables.config import RunnableConfig
-from langchain_core.runnables.graph import Graph as DrawableGraph
-from langchain_core.runnables.graph import Node as DrawableNode
 from typing_extensions import Self
 
 from langgraph.channels.ephemeral_value import EphemeralValue
@@ -32,7 +26,6 @@ from langgraph.constants import (
 )
 from langgraph.graph.branch import Branch
 from langgraph.pregel import Channel, Pregel
-from langgraph.pregel.protocol import PregelProtocol
 from langgraph.pregel.read import PregelNode
 from langgraph.pregel.write import ChannelWrite, ChannelWriteEntry
 from langgraph.types import All, Checkpointer
@@ -182,7 +175,7 @@ class Graph:
         # validate the condition
         if name in self.branches[source]:
             raise ValueError(
-                f"Branch with name `{path.name}` already exists for node " f"`{source}`"
+                f"Branch with name `{path.name}` already exists for node `{source}`"
             )
         # save it
         self.branches[source][name] = Branch.from_path(path, path_map, then, False)
@@ -380,10 +373,10 @@ class CompiledGraph(Pregel):
             cast(list[str], self.nodes[end].channels).append(start)
 
     def attach_branch(self, start: str, name: str, branch: Branch) -> None:
-        def branch_writer(
-            packets: Sequence[Union[str, Send]], config: RunnableConfig
-        ) -> Optional[ChannelWrite]:
-            writes = [
+        def get_writes(
+            packets: Sequence[Union[str, Send]],
+        ) -> Sequence[Union[ChannelWriteEntry, Send]]:
+            return [
                 (
                     ChannelWriteEntry(f"branch:{start}:{name}:{p}" if p != END else END)
                     if not isinstance(p, Send)
@@ -391,14 +384,13 @@ class CompiledGraph(Pregel):
                 )
                 for p in packets
             ]
-            return ChannelWrite(cast(Sequence[Union[ChannelWriteEntry, Send]], writes))
 
         # add hidden start node
         if start == START and start not in self.nodes:
             self.nodes[start] = Channel.subscribe_to(START, tags=[TAG_HIDDEN])
 
         # attach branch writer
-        self.nodes[start] |= branch.run(branch_writer)
+        self.nodes[start] |= branch.run(get_writes)
 
         # attach branch readers
         ends = branch.ends.values() if branch.ends else [node for node in self.nodes]
@@ -408,171 +400,3 @@ class CompiledGraph(Pregel):
                 self.channels[channel_name] = EphemeralValue(Any)
                 self.nodes[end].triggers.append(channel_name)
                 cast(list[str], self.nodes[end].channels).append(channel_name)
-
-    async def aget_graph(
-        self,
-        config: Optional[RunnableConfig] = None,
-        *,
-        xray: Union[int, bool] = False,
-    ) -> DrawableGraph:
-        """Returns a drawable representation of the computation graph."""
-        from langgraph.pregel.remote import RemoteGraph
-
-        # gather subgraphs
-        if xray:
-            subpregels: dict[str, PregelProtocol] = {
-                k: v
-                async for k, v in self.aget_subgraphs()
-                if isinstance(v, (CompiledGraph, RemoteGraph))
-            }
-            subgraphs = {
-                k: v
-                for k, v in zip(
-                    subpregels,
-                    await asyncio.gather(
-                        *(
-                            p.aget_graph(
-                                config,
-                                xray=xray
-                                if isinstance(xray, bool) or xray <= 0
-                                else xray - 1,
-                            )
-                            for p in subpregels.values()
-                        )
-                    ),
-                )
-            }
-        else:
-            subgraphs = {}
-
-        # draw the graph
-        return self._draw_graph(config, subgraphs=subgraphs)
-
-    def get_graph(
-        self,
-        config: Optional[RunnableConfig] = None,
-        *,
-        xray: Union[int, bool] = False,
-    ) -> DrawableGraph:
-        """Returns a drawable representation of the computation graph."""
-        from langgraph.pregel.remote import RemoteGraph
-
-        # gather subgraphs
-        if xray:
-            subgraphs = {
-                k: v.get_graph(
-                    config,
-                    xray=xray if isinstance(xray, bool) or xray <= 0 else xray - 1,
-                )
-                for k, v in self.get_subgraphs()
-                if isinstance(v, (CompiledGraph, RemoteGraph))
-            }
-        else:
-            subgraphs = {}
-
-        # draw the graph
-        return self._draw_graph(config, subgraphs=subgraphs)
-
-    def _draw_graph(
-        self,
-        config: Optional[RunnableConfig] = None,
-        *,
-        subgraphs: dict[str, DrawableGraph] = {},
-    ) -> DrawableGraph:
-        # create the graph
-        graph = DrawableGraph()
-        start_nodes: dict[str, DrawableNode] = {
-            START: graph.add_node(self.get_input_schema(config), START)
-        }
-        end_nodes: dict[str, DrawableNode] = {}
-
-        def add_edge(
-            start: str,
-            end: str,
-            label: Optional[Hashable] = None,
-            conditional: bool = False,
-        ) -> None:
-            if end == END and END not in end_nodes:
-                end_nodes[END] = graph.add_node(self.get_output_schema(config), END)
-            if start not in start_nodes or end not in end_nodes:
-                logger.warning(
-                    f"Could not add edge from '{start}' to '{end}' due to missing nodes"
-                )
-                return
-            return graph.add_edge(
-                start_nodes[start],
-                end_nodes[end],
-                str(label) if label is not None else None,
-                conditional,
-            )
-
-        for key, n in self.builder.nodes.items():
-            node = n.runnable
-            metadata = n.metadata or {}
-            if key in self.interrupt_before_nodes and key in self.interrupt_after_nodes:
-                metadata["__interrupt"] = "before,after"
-            elif key in self.interrupt_before_nodes:
-                metadata["__interrupt"] = "before"
-            elif key in self.interrupt_after_nodes:
-                metadata["__interrupt"] = "after"
-            if key in subgraphs:
-                subgraph = subgraphs[key]
-                subgraph.trim_first_node()
-                subgraph.trim_last_node()
-                if len(subgraph.nodes) >= 1:
-                    e, s = graph.extend(subgraph, prefix=key)
-                    if e is None:
-                        logger.warning(
-                            f"Could not extend subgraph '{key}' due to missing entrypoint"
-                        )
-                        continue
-                    if s is not None:
-                        start_nodes[key] = s
-                    end_nodes[key] = e
-                else:
-                    nn = graph.add_node(node, key, metadata=metadata or None)
-                    start_nodes[key] = nn
-                    end_nodes[key] = nn
-            else:
-                nn = graph.add_node(node, key, metadata=metadata or None)
-                start_nodes[key] = nn
-                end_nodes[key] = nn
-        for start, end in sorted(self.builder._all_edges):
-            add_edge(start, end)
-        for start, branches in self.builder.branches.items():
-            default_ends = {
-                **{k: k for k in self.builder.nodes if k != start},
-                END: END,
-            }
-            for _, branch in branches.items():
-                if branch.ends is not None:
-                    ends = branch.ends
-                elif branch.then is not None:
-                    ends = {k: k for k in default_ends if k not in (END, branch.then)}
-                else:
-                    ends = cast(dict[Hashable, str], default_ends)
-                for label, end in ends.items():
-                    add_edge(
-                        start,
-                        end,
-                        label if label != end else None,
-                        conditional=True,
-                    )
-                    if branch.then is not None:
-                        add_edge(end, branch.then)
-        for key, n in self.builder.nodes.items():
-            if isinstance(n.ends, dict):
-                for end, label in n.ends.items():
-                    add_edge(key, end, label, conditional=True)
-            elif isinstance(n.ends, tuple):
-                for end in n.ends:
-                    add_edge(key, end, conditional=True)
-
-        return graph
-
-    def _repr_mimebundle_(self, **kwargs: Any) -> dict[str, Any]:
-        """Mime bundle used by Jupyter to display the graph"""
-        return {
-            "text/plain": repr(self),
-            "image/png": self.get_graph().draw_mermaid_png(),
-        }

libs/langgraph/langgraph/graph/message.py

@@ -1,5 +1,6 @@
 import uuid
 import warnings
+from collections.abc import Sequence
 from functools import partial
 from typing import (
     Annotated,
@@ -7,7 +8,6 @@ from typing import (
     Callable,
     Literal,
     Optional,
-    Sequence,
     Union,
     cast,
 )

libs/langgraph/langgraph/graph/schema_utils.py

@@ -3,10 +3,10 @@ import logging
 import weakref
 from inspect import isclass
 from typing import (
+    Annotated,
     Any,
     Callable,
     Optional,
-    Type,
     Union,
     get_args,
     get_origin,
@@ -15,14 +15,13 @@ from typing import (
 
 from pydantic import BaseModel
 from pydantic.v1 import BaseModel as BaseModelV1
-from typing_extensions import Annotated
 
 __all__ = ["SchemaCoercionMapper"]
 
 logger = logging.getLogger(__name__)
 
 
-_cache: weakref.WeakKeyDictionary[Type[Any], dict[int, "SchemaCoercionMapper"]] = (
+_cache: weakref.WeakKeyDictionary[type[Any], dict[int, "SchemaCoercionMapper"]] = (
     weakref.WeakKeyDictionary()
 )
 
@@ -32,7 +31,7 @@ class SchemaCoercionMapper:
 
     def __new__(
         cls,
-        schema: Type[Any],
+        schema: type[Any],
         type_hints: Optional[dict[str, Any]] = None,
         *,
         max_depth: int = 12,
@@ -46,7 +45,7 @@ class SchemaCoercionMapper:
 
     def __init__(
         self,
-        schema: Type[Any],
+        schema: type[Any],
         type_hints: Optional[dict[str, Any]] = None,
         *,
         max_depth: int = 12,
@@ -70,6 +69,17 @@ class SchemaCoercionMapper:
                 for n, f in schema.__fields__.items()
             }
             self._construct = schema.construct
+            unhandled_attrs = (
+                "__pre_root_validators__",
+                "__post_root_validators__",
+                "__validators__",
+            )
+            if any(getattr(schema, c, None) for c in unhandled_attrs):
+                self.coerce: Callable[[Any, Any], Union[BaseModelV1, BaseModel]] = (
+                    lambda v, _: schema(**v)
+                )
+            else:
+                self.coerce = self._coerce
 
         elif issubclass(schema, BaseModel):
             self._fields = {
@@ -77,6 +87,13 @@ class SchemaCoercionMapper:
                 for n, f in schema.model_fields.items()
             }
             self._construct: Callable[..., Any] = schema.model_construct  # type: ignore
+            unhandled_attrs = ("validators", "field_validators", "root_validators")
+            if (decorators := getattr(schema, "__pydantic_decorators__", None)) and any(
+                getattr(decorators, attr, None) for attr in unhandled_attrs
+            ):
+                self.coerce = lambda v, _: schema.model_validate(v)
+            else:
+                self.coerce = self._coerce
 
         else:
             raise TypeError("Schema is neither a Pydantic v1 nor v2 model.")
@@ -86,7 +103,7 @@ class SchemaCoercionMapper:
     def __call__(self, input_data: Any, depth: Optional[int] = None) -> Any:
         return self.coerce(input_data, depth)
 
-    def coerce(self, input_data: Any, depth: Optional[int] = None) -> Any:
+    def _coerce(self, input_data: Any, depth: Optional[int] = None) -> Any:
         if depth is None:
             depth = self.max_depth
         if not isinstance(input_data, dict) or depth <= 0:
@@ -169,7 +186,7 @@ class SchemaCoercionMapper:
                 def dict_coercer(v: Any, d: Any) -> Any:
                     if not isinstance(v, dict):
                         if throw:
-                            raise TypeError("Expected dict, got %s" % type(v))
+                            raise TypeError(f"Expected dict, got {type(v)}")
                     return v
 
                 return dict_coercer
@@ -179,7 +196,7 @@ class SchemaCoercionMapper:
             def dict_coercer(v: Any, d: Any) -> Any:
                 if not isinstance(v, dict):
                     if throw:
-                        raise TypeError("Expected dict, got %s" % type(v))
+                        raise TypeError(f"Expected dict, got {type(v)}")
                     return v
                 return {k_sub(k, d - 1): v_sub(val, d - 1) for k, val in v.items()}
 

libs/langgraph/langgraph/graph/state.py

@@ -3,19 +3,16 @@ import logging
 import typing
 import warnings
 from collections import defaultdict
+from collections.abc import Awaitable, Hashable, Sequence
 from functools import partial
 from inspect import isclass, isfunction, ismethod, signature
 from types import FunctionType
 from typing import (
     Any,
-    Awaitable,
     Callable,
-    Hashable,
     Literal,
     NamedTuple,
     Optional,
-    Sequence,
-    Type,
     Union,
     cast,
     get_args,
@@ -84,7 +81,7 @@ from langgraph.utils.runnable import RunnableLike, coerce_to_runnable
 logger = logging.getLogger(__name__)
 
 
-def _warn_invalid_state_schema(schema: Union[Type[Any], Any]) -> None:
+def _warn_invalid_state_schema(schema: Union[type[Any], Any]) -> None:
     if isinstance(schema, type):
         return
     if typing.get_args(schema):
@@ -108,7 +105,7 @@ def _get_node_name(node: RunnableLike) -> str:
 class StateNodeSpec(NamedTuple):
     runnable: Runnable
     metadata: Optional[dict[str, Any]]
-    input: Type[Any]
+    input: type[Any]
     retry_policy: Optional[Union[RetryPolicy, Sequence[RetryPolicy]]]
     ends: Optional[Union[tuple[str, ...], dict[str, str]]] = EMPTY_SEQ
 
@@ -166,15 +163,15 @@ class StateGraph(Graph):
     nodes: dict[str, StateNodeSpec]  # type: ignore[assignment]
     channels: dict[str, BaseChannel]
     managed: dict[str, ManagedValueSpec]
-    schemas: dict[Type[Any], dict[str, Union[BaseChannel, ManagedValueSpec]]]
+    schemas: dict[type[Any], dict[str, Union[BaseChannel, ManagedValueSpec]]]
 
     def __init__(
         self,
-        state_schema: Optional[Type[Any]] = None,
-        config_schema: Optional[Type[Any]] = None,
+        state_schema: Optional[type[Any]] = None,
+        config_schema: Optional[type[Any]] = None,
         *,
-        input: Optional[Type[Any]] = None,
-        output: Optional[Type[Any]] = None,
+        input: Optional[type[Any]] = None,
+        output: Optional[type[Any]] = None,
     ) -> None:
         super().__init__()
         if state_schema is None:
@@ -195,7 +192,7 @@ class StateGraph(Graph):
         self.schemas = {}
         self.channels = {}
         self.managed = {}
-        self.type_hints: dict[Type[Any], dict[str, Any]] = {}
+        self.type_hints: dict[type[Any], dict[str, Any]] = {}
         self.schema = state_schema
         self.input = input
         self.output = output
@@ -211,7 +208,7 @@ class StateGraph(Graph):
             (start, end) for starts, end in self.waiting_edges for start in starts
         }
 
-    def _add_schema(self, schema: Type[Any], /, allow_managed: bool = True) -> None:
+    def _add_schema(self, schema: type[Any], /, allow_managed: bool = True) -> None:
         if schema not in self.schemas:
             _warn_invalid_state_schema(schema)
             channels, managed, type_hints = _get_channels(schema)
@@ -250,7 +247,7 @@ class StateGraph(Graph):
         node: RunnableLike,
         *,
         metadata: Optional[dict[str, Any]] = None,
-        input: Optional[Type[Any]] = None,
+        input: Optional[type[Any]] = None,
         retry: Optional[Union[RetryPolicy, Sequence[RetryPolicy]]] = None,
         destinations: Optional[Union[dict[str, str], tuple[str, ...]]] = None,
     ) -> Self:
@@ -275,7 +272,7 @@ class StateGraph(Graph):
         action: RunnableLike,
         *,
         metadata: Optional[dict[str, Any]] = None,
-        input: Optional[Type[Any]] = None,
+        input: Optional[type[Any]] = None,
         retry: Optional[Union[RetryPolicy, Sequence[RetryPolicy]]] = None,
         destinations: Optional[Union[dict[str, str], tuple[str, ...]]] = None,
     ) -> Self:
@@ -299,7 +296,7 @@ class StateGraph(Graph):
         action: Optional[RunnableLike] = None,
         *,
         metadata: Optional[dict[str, Any]] = None,
-        input: Optional[Type[Any]] = None,
+        input: Optional[type[Any]] = None,
         retry: Optional[Union[RetryPolicy, Sequence[RetryPolicy]]] = None,
         destinations: Optional[Union[dict[str, str], tuple[str, ...]]] = None,
     ) -> Self:
@@ -527,7 +524,7 @@ class StateGraph(Graph):
         # validate the condition
         if name in self.branches[source]:
             raise ValueError(
-                f"Branch with name `{path.name}` already exists for node " f"`{source}`"
+                f"Branch with name `{path.name}` already exists for node `{source}`"
             )
         # save it
         self.branches[source][name] = Branch.from_path(path, path_map, then, True)
@@ -686,12 +683,12 @@ class StateGraph(Graph):
 
 class CompiledStateGraph(CompiledGraph):
     builder: StateGraph
-    schema_to_mapper: dict[Type[Any], Optional[Callable[[Any], Any]]]
+    schema_to_mapper: dict[type[Any], Optional[Callable[[Any], Any]]]
 
     def __init__(
         self,
         *,
-        schema_to_mapper: dict[Type[Any], Optional[Callable[[Any], Any]]],
+        schema_to_mapper: dict[type[Any], Optional[Callable[[Any], Any]]],
         **kwargs: Any,
     ) -> None:
         super().__init__(**kwargs)
@@ -774,7 +771,12 @@ class CompiledStateGraph(CompiledGraph):
             ChannelWriteTupleEntry(
                 mapper=_get_root if output_keys == ["__root__"] else _get_updates
             ),
-            ChannelWriteTupleEntry(mapper=_control_branch),
+            ChannelWriteTupleEntry(
+                mapper=_control_branch,
+                static=_control_static(node.ends)
+                if node is not None and node.ends is not None
+                else None,
+            ),
         )
 
         # add node and output channel
@@ -840,9 +842,9 @@ class CompiledStateGraph(CompiledGraph):
     def attach_branch(
         self, start: str, name: str, branch: Branch, *, with_reader: bool = True
     ) -> None:
-        def branch_writer(
-            packets: Sequence[Union[str, Send]], config: RunnableConfig
-        ) -> None:
+        def get_writes(
+            packets: Sequence[Union[str, Send]],
+        ) -> Sequence[Union[ChannelWriteEntry, Send]]:
             if filtered := [p for p in packets if p != END]:
                 writes = [
                     (
@@ -857,13 +859,15 @@ class CompiledStateGraph(CompiledGraph):
                         ChannelWriteEntry(
                             f"branch:{start}:{name}::then",
                             WaitForNames(
-                                {p.node if isinstance(p, Send) else p for p in filtered}
+                                frozenset(
+                                    p.node if isinstance(p, Send) else p
+                                    for p in filtered
+                                )
                             ),
                         )
                     )
-                ChannelWrite.do_write(
-                    config, cast(Sequence[Union[Send, ChannelWriteEntry]], writes)
-                )
+                return writes
+            return []
 
         if with_reader:
             # get schema
@@ -891,7 +895,7 @@ class CompiledStateGraph(CompiledGraph):
             reader = None
 
         # attach branch publisher
-        self.nodes[start].writers.append(branch.run(branch_writer, reader))
+        self.nodes[start].writers.append(branch.run(get_writes, reader))
 
         # attach then subscriber
         if branch.then and branch.then != END:
@@ -1015,7 +1019,7 @@ class CompiledStateGraph(CompiledGraph):
 
 
 def _pick_mapper(
-    state_keys: Sequence[str], schema: Type[Any], type_hints: Optional[dict[str, Any]]
+    state_keys: Sequence[str], schema: type[Any], type_hints: Optional[dict[str, Any]]
 ) -> Optional[Callable[[Any], Any]]:
     if state_keys == ["__root__"]:
         return None
@@ -1027,7 +1031,7 @@ def _pick_mapper(
     return partial(_coerce_state, schema)
 
 
-def _coerce_state(schema: Type[Any], input: dict[str, Any]) -> dict[str, Any]:
+def _coerce_state(schema: type[Any], input: dict[str, Any]) -> dict[str, Any]:
     return schema(**input)
 
 
@@ -1059,6 +1063,19 @@ def _control_branch(value: Any) -> Sequence[tuple[str, Any]]:
     return rtn
 
 
+def _control_static(
+    ends: Union[tuple[str, ...], dict[str, str]],
+) -> Sequence[tuple[str, Any, Optional[str]]]:
+    if isinstance(ends, dict):
+        return [
+            (CHANNEL_BRANCH_TO.format(k), None, label)
+            for k, label in ends.items()
+            if k != END
+        ]
+    else:
+        return [(CHANNEL_BRANCH_TO.format(e), None, None) for e in ends if e != END]
+
+
 def _get_root(input: Any) -> Optional[Sequence[tuple[str, Any]]]:
     if isinstance(input, Command):
         if input.graph == Command.PARENT:
@@ -1083,7 +1100,7 @@ def _get_root(input: Any) -> Optional[Sequence[tuple[str, Any]]]:
 
 
 def _get_channels(
-    schema: Type[dict],
+    schema: type[dict],
 ) -> tuple[dict[str, BaseChannel], dict[str, ManagedValueSpec], dict[str, Any]]:
     if not hasattr(schema, "__annotations__"):
         return (
@@ -1137,7 +1154,7 @@ def _get_channel(
     return fallback
 
 
-def _is_field_channel(typ: Type[Any]) -> Optional[BaseChannel]:
+def _is_field_channel(typ: type[Any]) -> Optional[BaseChannel]:
     if hasattr(typ, "__metadata__"):
         meta = typ.__metadata__
         if len(meta) >= 1 and isinstance(meta[-1], BaseChannel):
@@ -1147,7 +1164,7 @@ def _is_field_channel(typ: Type[Any]) -> Optional[BaseChannel]:
     return None
 
 
-def _is_field_binop(typ: Type[Any]) -> Optional[BinaryOperatorAggregate]:
+def _is_field_binop(typ: type[Any]) -> Optional[BinaryOperatorAggregate]:
     if hasattr(typ, "__metadata__"):
         meta = typ.__metadata__
         if len(meta) >= 1 and callable(meta[-1]):
@@ -1168,7 +1185,7 @@ def _is_field_binop(typ: Type[Any]) -> Optional[BinaryOperatorAggregate]:
     return None
 
 
-def _is_field_managed_value(name: str, typ: Type[Any]) -> Optional[ManagedValueSpec]:
+def _is_field_managed_value(name: str, typ: type[Any]) -> Optional[ManagedValueSpec]:
     if hasattr(typ, "__metadata__"):
         meta = typ.__metadata__
         if len(meta) >= 1:
@@ -1186,7 +1203,7 @@ def _is_field_managed_value(name: str, typ: Type[Any]) -> Optional[ManagedValueS
 
 
 def _get_schema(
-    typ: Type,
+    typ: type,
     schemas: dict,
     channels: dict,
     name: str,

libs/langgraph/langgraph/managed/base.py

@@ -1,14 +1,11 @@
 from abc import ABC, abstractmethod
+from collections.abc import AsyncIterator, Iterator, Sequence
 from contextlib import asynccontextmanager, contextmanager
 from inspect import isclass
 from typing import (
     Any,
-    AsyncIterator,
     Generic,
-    Iterator,
     NamedTuple,
-    Sequence,
-    Type,
     TypeVar,
     Union,
 )
@@ -66,11 +63,11 @@ class WritableManagedValue(Generic[V, U], ManagedValue[V], ABC):
 
 
 class ConfiguredManagedValue(NamedTuple):
-    cls: Type[ManagedValue]
+    cls: type[ManagedValue]
     kwargs: dict[str, Any]
 
 
-ManagedValueSpec = Union[Type[ManagedValue], ConfiguredManagedValue]
+ManagedValueSpec = Union[type[ManagedValue], ConfiguredManagedValue]
 
 
 def is_managed_value(value: Any) -> TypeGuard[ManagedValueSpec]:
@@ -79,7 +76,7 @@ def is_managed_value(value: Any) -> TypeGuard[ManagedValueSpec]:
     )
 
 
-def is_readonly_managed_value(value: Any) -> TypeGuard[Type[ManagedValue]]:
+def is_readonly_managed_value(value: Any) -> TypeGuard[type[ManagedValue]]:
     return (
         isclass(value)
         and issubclass(value, ManagedValue)
@@ -90,7 +87,7 @@ def is_readonly_managed_value(value: Any) -> TypeGuard[Type[ManagedValue]]:
     )
 
 
-def is_writable_managed_value(value: Any) -> TypeGuard[Type[WritableManagedValue]]:
+def is_writable_managed_value(value: Any) -> TypeGuard[type[WritableManagedValue]]:
     return (isclass(value) and issubclass(value, WritableManagedValue)) or (
         isinstance(value, ConfiguredManagedValue)
         and issubclass(value.cls, WritableManagedValue)

libs/langgraph/langgraph/managed/context.py

@@ -1,15 +1,16 @@
-from contextlib import asynccontextmanager, contextmanager
+from collections.abc import AsyncIterator, Iterator
+from contextlib import (
+    AbstractAsyncContextManager,
+    AbstractContextManager,
+    asynccontextmanager,
+    contextmanager,
+)
 from inspect import signature
 from typing import (
     Any,
-    AsyncContextManager,
-    AsyncIterator,
     Callable,
-    ContextManager,
     Generic,
-    Iterator,
     Optional,
-    Type,
     Union,
 )
 
@@ -28,15 +29,15 @@ class Context(ManagedValue[V], Generic[V]):
     def of(
         ctx: Union[
             None,
-            Callable[..., ContextManager[V]],
-            Type[ContextManager[V]],
-            Callable[..., AsyncContextManager[V]],
-            Type[AsyncContextManager[V]],
+            Callable[..., AbstractContextManager[V]],
+            type[AbstractContextManager[V]],
+            Callable[..., AbstractAsyncContextManager[V]],
+            type[AbstractAsyncContextManager[V]],
         ] = None,
         actx: Optional[
             Union[
-                Callable[..., AsyncContextManager[V]],
-                Type[AsyncContextManager[V]],
+                Callable[..., AbstractAsyncContextManager[V]],
+                type[AbstractAsyncContextManager[V]],
             ]
         ] = None,
     ) -> ConfiguredManagedValue:
@@ -98,8 +99,10 @@ class Context(ManagedValue[V], Generic[V]):
         self,
         loop: LoopProtocol,
         *,
-        ctx: Union[None, Type[ContextManager[V]], Type[AsyncContextManager[V]]] = None,
-        actx: Optional[Type[AsyncContextManager[V]]] = None,
+        ctx: Union[
+            None, type[AbstractContextManager[V]], type[AbstractAsyncContextManager[V]]
+        ] = None,
+        actx: Optional[type[AbstractAsyncContextManager[V]]] = None,
     ) -> None:
         self.ctx = ctx
         self.actx = actx

libs/langgraph/langgraph/managed/shared_value.py

@@ -1,12 +1,9 @@
 import collections.abc
+from collections.abc import AsyncIterator, Iterator, Sequence
 from contextlib import asynccontextmanager, contextmanager
 from typing import (
     Any,
-    AsyncIterator,
-    Iterator,
     Optional,
-    Sequence,
-    Type,
 )
 
 from typing_extensions import NotRequired, Required, Self
@@ -71,7 +68,7 @@ class SharedValue(WritableManagedValue[Value, Update]):
             yield value
 
     def __init__(
-        self, loop: LoopProtocol, *, typ: Type[Any], scope: str, key: str
+        self, loop: LoopProtocol, *, typ: type[Any], scope: str, key: str
     ) -> None:
         super().__init__(loop)
         if typ := _strip_extras(typ):

libs/langgraph/langgraph/pregel/__init__.py

@@ -6,17 +6,11 @@ import concurrent.futures
 import queue
 import weakref
 from collections import defaultdict, deque
+from collections.abc import AsyncIterator, Iterator, Mapping, Sequence
 from functools import partial
 from typing import (
     Any,
-    AsyncIterator,
     Callable,
-    Dict,
-    Iterator,
-    Mapping,
-    Optional,
-    Sequence,
-    Type,
     Union,
     cast,
     get_type_hints,
@@ -93,6 +87,7 @@ from langgraph.pregel.algo import (
 )
 from langgraph.pregel.checkpoint import create_checkpoint, empty_checkpoint
 from langgraph.pregel.debug import tasks_w_writes
+from langgraph.pregel.draw import draw_graph
 from langgraph.pregel.io import map_input, read_channels
 from langgraph.pregel.loop import AsyncPregelLoop, StreamProtocol, SyncPregelLoop
 from langgraph.pregel.manager import AsyncChannelsManager, ChannelsManager
@@ -141,8 +136,8 @@ class Channel:
         cls,
         channels: str,
         *,
-        key: Optional[str] = None,
-        tags: Optional[list[str]] = None,
+        key: str | None = None,
+        tags: list[str] | None = None,
     ) -> PregelNode: ...
 
     @overload
@@ -152,16 +147,16 @@ class Channel:
         channels: Sequence[str],
         *,
         key: None = None,
-        tags: Optional[list[str]] = None,
+        tags: list[str] | None = None,
     ) -> PregelNode: ...
 
     @classmethod
     def subscribe_to(
         cls,
-        channels: Union[str, Sequence[str]],
+        channels: str | Sequence[str],
         *,
-        key: Optional[str] = None,
-        tags: Optional[list[str]] = None,
+        key: str | None = None,
+        tags: list[str] | None = None,
     ) -> PregelNode:
         """Runs process.invoke() each time channels are updated,
         with a dict of the channel values as input."""
@@ -467,7 +462,7 @@ class Pregel(PregelProtocol):
 
     nodes: dict[str, PregelNode]
 
-    channels: dict[str, Union[BaseChannel, ManagedValueSpec]]
+    channels: dict[str, BaseChannel | ManagedValueSpec]
 
     stream_mode: StreamMode = "values"
     """Mode to stream output, defaults to 'values'."""
@@ -476,18 +471,18 @@ class Pregel(PregelProtocol):
     """Whether to force emitting stream events eagerly, automatically turned on
     for stream_mode "messages" and "custom"."""
 
-    output_channels: Union[str, Sequence[str]]
+    output_channels: str | Sequence[str]
 
-    stream_channels: Optional[Union[str, Sequence[str]]] = None
+    stream_channels: str | Sequence[str] | None = None
     """Channels to stream, defaults to all channels not in reserved channels"""
 
-    interrupt_after_nodes: Union[All, Sequence[str]]
+    interrupt_after_nodes: All | Sequence[str]
 
-    interrupt_before_nodes: Union[All, Sequence[str]]
+    interrupt_before_nodes: All | Sequence[str]
 
-    input_channels: Union[str, Sequence[str]]
+    input_channels: str | Sequence[str]
 
-    step_timeout: Optional[float] = None
+    step_timeout: float | None = None
     """Maximum time to wait for a step to complete, in seconds. Defaults to None."""
 
     debug: bool
@@ -496,44 +491,44 @@ class Pregel(PregelProtocol):
     checkpointer: Checkpointer = None
     """Checkpointer used to save and load graph state. Defaults to None."""
 
-    store: Optional[BaseStore] = None
+    store: BaseStore | None = None
     """Memory store to use for SharedValues. Defaults to None."""
 
-    retry_policy: Optional[Sequence[RetryPolicy]] = None
+    retry_policy: Sequence[RetryPolicy] | None = None
     """Retry policies to use when running tasks. Set to None to disable."""
 
-    config_type: Optional[Type[Any]] = None
+    config_type: type[Any] | None = None
 
-    input_model: Optional[Type[BaseModel]] = None
+    input_model: type[BaseModel] | None = None
 
-    config: Optional[RunnableConfig] = None
+    config: RunnableConfig | None = None
 
     name: str = "LangGraph"
 
-    trigger_to_nodes: Optional[Mapping[str, Sequence[str]]] = None
+    trigger_to_nodes: Mapping[str, Sequence[str]] | None = None
 
     def __init__(
         self,
         *,
         nodes: dict[str, PregelNode],
-        channels: Optional[dict[str, Union[BaseChannel, ManagedValueSpec]]],
+        channels: dict[str, BaseChannel | ManagedValueSpec] | None,
         auto_validate: bool = True,
         stream_mode: StreamMode = "values",
         stream_eager: bool = False,
-        output_channels: Union[str, Sequence[str]],
-        stream_channels: Optional[Union[str, Sequence[str]]] = None,
-        interrupt_after_nodes: Union[All, Sequence[str]] = (),
-        interrupt_before_nodes: Union[All, Sequence[str]] = (),
-        input_channels: Union[str, Sequence[str]],
-        step_timeout: Optional[float] = None,
-        debug: Optional[bool] = None,
-        checkpointer: Optional[BaseCheckpointSaver] = None,
-        store: Optional[BaseStore] = None,
-        retry_policy: Optional[Union[RetryPolicy, Sequence[RetryPolicy]]] = None,
-        config_type: Optional[Type[Any]] = None,
-        input_model: Optional[Type[BaseModel]] = None,
-        config: Optional[RunnableConfig] = None,
-        trigger_to_nodes: Optional[Mapping[str, Sequence[str]]] = None,
+        output_channels: str | Sequence[str],
+        stream_channels: str | Sequence[str] | None = None,
+        interrupt_after_nodes: All | Sequence[str] = (),
+        interrupt_before_nodes: All | Sequence[str] = (),
+        input_channels: str | Sequence[str],
+        step_timeout: float | None = None,
+        debug: bool | None = None,
+        checkpointer: BaseCheckpointSaver | None = None,
+        store: BaseStore | None = None,
+        retry_policy: RetryPolicy | Sequence[RetryPolicy] | None = None,
+        config_type: type[Any] | None = None,
+        input_model: type[BaseModel] | None = None,
+        config: RunnableConfig | None = None,
+        trigger_to_nodes: Mapping[str, Sequence[str]] | None = None,
         name: str = "LangGraph",
     ) -> None:
         self.nodes = nodes
@@ -562,22 +557,87 @@ class Pregel(PregelProtocol):
             self.validate()
 
     def get_graph(
-        self, config: Optional[RunnableConfig] = None, *, xray: Union[int, bool] = False
+        self, config: RunnableConfig | None = None, *, xray: int | bool = False
     ) -> Graph:
-        raise NotImplementedError
+        """Returns a drawable representation of the computation graph."""
+        # gather subgraphs
+        if xray:
+            subgraphs = {
+                k: v.get_graph(
+                    config,
+                    xray=xray if isinstance(xray, bool) or xray <= 0 else xray - 1,
+                )
+                for k, v in self.get_subgraphs()
+            }
+        else:
+            subgraphs = {}
+
+        return draw_graph(
+            merge_configs(self.config, config),
+            nodes=self.nodes,
+            specs=self.channels,
+            input_channels=self.input_channels,
+            interrupt_after_nodes=self.interrupt_after_nodes,
+            interrupt_before_nodes=self.interrupt_before_nodes,
+            trigger_to_nodes=self.trigger_to_nodes,
+            checkpointer=self.checkpointer,
+            subgraphs=subgraphs,
+        )
 
     async def aget_graph(
-        self, config: Optional[RunnableConfig] = None, *, xray: Union[int, bool] = False
+        self, config: RunnableConfig | None = None, *, xray: int | bool = False
     ) -> Graph:
-        raise NotImplementedError
+        """Returns a drawable representation of the computation graph."""
 
-    def copy(self, update: Optional[dict[str, Any]] = None) -> Self:
+        # gather subgraphs
+        if xray:
+            subpregels: dict[str, PregelProtocol] = {
+                k: v async for k, v in self.aget_subgraphs()
+            }
+            subgraphs = {
+                k: v
+                for k, v in zip(
+                    subpregels,
+                    await asyncio.gather(
+                        *(
+                            p.aget_graph(
+                                config,
+                                xray=xray
+                                if isinstance(xray, bool) or xray <= 0
+                                else xray - 1,
+                            )
+                            for p in subpregels.values()
+                        )
+                    ),
+                )
+            }
+        else:
+            subgraphs = {}
+
+        return draw_graph(
+            merge_configs(self.config, config),
+            nodes=self.nodes,
+            specs=self.channels,
+            input_channels=self.input_channels,
+            interrupt_after_nodes=self.interrupt_after_nodes,
+            interrupt_before_nodes=self.interrupt_before_nodes,
+            trigger_to_nodes=self.trigger_to_nodes,
+            checkpointer=self.checkpointer,
+            subgraphs=subgraphs,
+        )
+
+    def _repr_mimebundle_(self, **kwargs: Any) -> dict[str, Any]:
+        """Mime bundle used by Jupyter to display the graph"""
+        return {
+            "text/plain": repr(self),
+            "image/png": self.get_graph().draw_mermaid_png(),
+        }
+
+    def copy(self, update: dict[str, Any] | None = None) -> Self:
         attrs = {**self.__dict__, **(update or {})}
         return self.__class__(**attrs)
 
-    def with_config(
-        self, config: Optional[RunnableConfig] = None, **kwargs: Any
-    ) -> Self:
+    def with_config(self, config: RunnableConfig | None = None, **kwargs: Any) -> Self:
         return self.copy(
             {"config": merge_configs(self.config, config, cast(RunnableConfig, kwargs))}
         )
@@ -632,9 +692,7 @@ class Pregel(PregelProtocol):
             ]
         ]
 
-    def config_schema(
-        self, *, include: Optional[Sequence[str]] = None
-    ) -> Type[BaseModel]:
+    def config_schema(self, *, include: Sequence[str] | None = None) -> type[BaseModel]:
         # If the config type is not set explicitly, we will try to infer it.
         # If the config type is provided, but isn't directly supported by pydantic
         # (e.g., vanilla python class), we will also delegate to the parent class,
@@ -654,8 +712,8 @@ class Pregel(PregelProtocol):
         return create_model(self.get_name("Config"), field_definitions=fields)
 
     def get_config_jsonschema(
-        self, *, include: Optional[Sequence[str]] = None
-    ) -> Dict[str, Any]:
+        self, *, include: Sequence[str] | None = None
+    ) -> dict[str, Any]:
         schema = self.config_schema(include=include)
         if hasattr(schema, "model_json_schema"):
             return schema.model_json_schema()
@@ -669,9 +727,7 @@ class Pregel(PregelProtocol):
             if isinstance(channel, BaseChannel):
                 return channel.UpdateType
 
-    def get_input_schema(
-        self, config: Optional[RunnableConfig] = None
-    ) -> Type[BaseModel]:
+    def get_input_schema(self, config: RunnableConfig | None = None) -> type[BaseModel]:
         if self.input_model is not None:
             return self.input_model
         config = merge_configs(self.config, config)
@@ -688,8 +744,8 @@ class Pregel(PregelProtocol):
             )
 
     def get_input_jsonschema(
-        self, config: Optional[RunnableConfig] = None
-    ) -> Dict[str, Any]:
+        self, config: RunnableConfig | None = None
+    ) -> dict[str, Any]:
         schema = self.get_input_schema(config)
         if hasattr(schema, "model_json_schema"):
             return schema.model_json_schema()
@@ -704,8 +760,8 @@ class Pregel(PregelProtocol):
                 return channel.ValueType
 
     def get_output_schema(
-        self, config: Optional[RunnableConfig] = None
-    ) -> Type[BaseModel]:
+        self, config: RunnableConfig | None = None
+    ) -> type[BaseModel]:
         config = merge_configs(self.config, config)
         if isinstance(self.output_channels, str):
             return super().get_output_schema(config)
@@ -720,8 +776,8 @@ class Pregel(PregelProtocol):
             )
 
     def get_output_jsonschema(
-        self, config: Optional[RunnableConfig] = None
-    ) -> Dict[str, Any]:
+        self, config: RunnableConfig | None = None
+    ) -> dict[str, Any]:
         schema = self.get_output_schema(config)
         if hasattr(schema, "model_json_schema"):
             return schema.model_json_schema()
@@ -736,13 +792,13 @@ class Pregel(PregelProtocol):
         )
 
     @property
-    def stream_channels_asis(self) -> Union[str, Sequence[str]]:
+    def stream_channels_asis(self) -> str | Sequence[str]:
         return self.stream_channels or [
             k for k in self.channels if isinstance(self.channels[k], BaseChannel)
         ]
 
     def get_subgraphs(
-        self, *, namespace: Optional[str] = None, recurse: bool = False
+        self, *, namespace: str | None = None, recurse: bool = False
     ) -> Iterator[tuple[str, PregelProtocol]]:
         for name, node in self.nodes.items():
             # filter by prefix
@@ -771,7 +827,7 @@ class Pregel(PregelProtocol):
                     )
 
     async def aget_subgraphs(
-        self, *, namespace: Optional[str] = None, recurse: bool = False
+        self, *, namespace: str | None = None, recurse: bool = False
     ) -> AsyncIterator[tuple[str, PregelProtocol]]:
         for name, node in self.get_subgraphs(namespace=namespace, recurse=recurse):
             yield name, node
@@ -783,8 +839,8 @@ class Pregel(PregelProtocol):
     def _prepare_state_snapshot(
         self,
         config: RunnableConfig,
-        saved: Optional[CheckpointTuple],
-        recurse: Optional[BaseCheckpointSaver] = None,
+        saved: CheckpointTuple | None,
+        recurse: BaseCheckpointSaver | None = None,
         apply_pending_writes: bool = False,
     ) -> StateSnapshot:
         if not saved:
@@ -832,7 +888,7 @@ class Pregel(PregelProtocol):
             # get the subgraphs
             subgraphs = dict(self.get_subgraphs())
             parent_ns = saved.config[CONF].get(CONFIG_KEY_CHECKPOINT_NS, "")
-            task_states: dict[str, Union[RunnableConfig, StateSnapshot]] = {}
+            task_states: dict[str, RunnableConfig | StateSnapshot] = {}
             for task in next_tasks.values():
                 if task.name not in subgraphs:
                     continue
@@ -899,8 +955,8 @@ class Pregel(PregelProtocol):
     async def _aprepare_state_snapshot(
         self,
         config: RunnableConfig,
-        saved: Optional[CheckpointTuple],
-        recurse: Optional[BaseCheckpointSaver] = None,
+        saved: CheckpointTuple | None,
+        recurse: BaseCheckpointSaver | None = None,
         apply_pending_writes: bool = False,
     ) -> StateSnapshot:
         if not saved:
@@ -951,7 +1007,7 @@ class Pregel(PregelProtocol):
             # get the subgraphs
             subgraphs = {n: g async for n, g in self.aget_subgraphs()}
             parent_ns = saved.config[CONF].get(CONFIG_KEY_CHECKPOINT_NS, "")
-            task_states: dict[str, Union[RunnableConfig, StateSnapshot]] = {}
+            task_states: dict[str, RunnableConfig | StateSnapshot] = {}
             for task in next_tasks.values():
                 if task.name not in subgraphs:
                     continue
@@ -1019,7 +1075,7 @@ class Pregel(PregelProtocol):
         self, config: RunnableConfig, *, subgraphs: bool = False
     ) -> StateSnapshot:
         """Get the current state of the graph."""
-        checkpointer: Optional[BaseCheckpointSaver] = ensure_config(config)[CONF].get(
+        checkpointer: BaseCheckpointSaver | None = ensure_config(config)[CONF].get(
             CONFIG_KEY_CHECKPOINTER, self.checkpointer
         )
         if not checkpointer:
@@ -1061,7 +1117,7 @@ class Pregel(PregelProtocol):
         self, config: RunnableConfig, *, subgraphs: bool = False
     ) -> StateSnapshot:
         """Get the current state of the graph."""
-        checkpointer: Optional[BaseCheckpointSaver] = ensure_config(config)[CONF].get(
+        checkpointer: BaseCheckpointSaver | None = ensure_config(config)[CONF].get(
             CONFIG_KEY_CHECKPOINTER, self.checkpointer
         )
         if not checkpointer:
@@ -1103,13 +1159,13 @@ class Pregel(PregelProtocol):
         self,
         config: RunnableConfig,
         *,
-        filter: Optional[Dict[str, Any]] = None,
-        before: Optional[RunnableConfig] = None,
-        limit: Optional[int] = None,
+        filter: dict[str, Any] | None = None,
+        before: RunnableConfig | None = None,
+        limit: int | None = None,
     ) -> Iterator[StateSnapshot]:
         config = ensure_config(config)
         """Get the history of the state of the graph."""
-        checkpointer: Optional[BaseCheckpointSaver] = ensure_config(config)[CONF].get(
+        checkpointer: BaseCheckpointSaver | None = ensure_config(config)[CONF].get(
             CONFIG_KEY_CHECKPOINTER, self.checkpointer
         )
         if not checkpointer:
@@ -1154,13 +1210,13 @@ class Pregel(PregelProtocol):
         self,
         config: RunnableConfig,
         *,
-        filter: Optional[Dict[str, Any]] = None,
-        before: Optional[RunnableConfig] = None,
-        limit: Optional[int] = None,
+        filter: dict[str, Any] | None = None,
+        before: RunnableConfig | None = None,
+        limit: int | None = None,
     ) -> AsyncIterator[StateSnapshot]:
         config = ensure_config(config)
         """Get the history of the state of the graph."""
-        checkpointer: Optional[BaseCheckpointSaver] = ensure_config(config)[CONF].get(
+        checkpointer: BaseCheckpointSaver | None = ensure_config(config)[CONF].get(
             CONFIG_KEY_CHECKPOINTER, self.checkpointer
         )
         if not checkpointer:
@@ -1225,7 +1281,7 @@ class Pregel(PregelProtocol):
             RunnableConfig: The updated config.
         """
 
-        checkpointer: Optional[BaseCheckpointSaver] = ensure_config(config)[CONF].get(
+        checkpointer: BaseCheckpointSaver | None = ensure_config(config)[CONF].get(
             CONFIG_KEY_CHECKPOINTER, self.checkpointer
         )
         if not checkpointer:
@@ -1500,7 +1556,7 @@ class Pregel(PregelProtocol):
                         next_tasks[tid].writes.append((k, v))
                     if tasks := [t for t in next_tasks.values() if t.writes]:
                         apply_writes(checkpoint, channels, tasks, None)
-            valid_updates: list[tuple[str, Optional[dict[str, Any]]]] = []
+            valid_updates: list[tuple[str, dict[str, Any] | None]] = []
             if len(updates) == 1:
                 values, as_node = updates[0]
                 # find last node that updated the state, if not provided
@@ -1639,7 +1695,7 @@ class Pregel(PregelProtocol):
             RunnableConfig: The updated config.
         """
 
-        checkpointer: Optional[BaseCheckpointSaver] = ensure_config(config)[CONF].get(
+        checkpointer: BaseCheckpointSaver | None = ensure_config(config)[CONF].get(
             CONFIG_KEY_CHECKPOINTER, self.checkpointer
         )
         if not checkpointer:
@@ -1914,7 +1970,7 @@ class Pregel(PregelProtocol):
                         next_tasks[tid].writes.append((k, v))
                     if tasks := [t for t in next_tasks.values() if t.writes]:
                         apply_writes(checkpoint, channels, tasks, None)
-            valid_updates: list[tuple[str, Optional[dict[str, Any]]]] = []
+            valid_updates: list[tuple[str, dict[str, Any] | None]] = []
             if len(updates) == 1:
                 values, as_node = updates[0]
                 # find last node that updated the state, if not provided
@@ -2034,8 +2090,8 @@ class Pregel(PregelProtocol):
     def update_state(
         self,
         config: RunnableConfig,
-        values: Optional[Union[dict[str, Any], Any]],
-        as_node: Optional[str] = None,
+        values: dict[str, Any] | Any | None,
+        as_node: str | None = None,
     ) -> RunnableConfig:
         """Update the state of the graph with the given values, as if they came from
         node `as_node`. If `as_node` is not provided, it will be set to the last node
@@ -2047,7 +2103,7 @@ class Pregel(PregelProtocol):
         self,
         config: RunnableConfig,
         values: dict[str, Any] | Any,
-        as_node: Optional[str] = None,
+        as_node: str | None = None,
     ) -> RunnableConfig:
         """Update the state of the graph asynchronously with the given values, as if they came from
         node `as_node`. If `as_node` is not provided, it will be set to the last node
@@ -2059,19 +2115,19 @@ class Pregel(PregelProtocol):
         self,
         config: RunnableConfig,
         *,
-        stream_mode: Optional[Union[StreamMode, list[StreamMode]]],
-        output_keys: Optional[Union[str, Sequence[str]]],
-        interrupt_before: Optional[Union[All, Sequence[str]]],
-        interrupt_after: Optional[Union[All, Sequence[str]]],
-        debug: Optional[bool],
+        stream_mode: StreamMode | list[StreamMode] | None,
+        output_keys: str | Sequence[str] | None,
+        interrupt_before: All | Sequence[str] | None,
+        interrupt_after: All | Sequence[str] | None,
+        debug: bool | None,
     ) -> tuple[
         bool,
         set[StreamMode],
-        Union[str, Sequence[str]],
-        Union[All, Sequence[str]],
-        Union[All, Sequence[str]],
-        Optional[BaseCheckpointSaver],
-        Optional[BaseStore],
+        str | Sequence[str],
+        All | Sequence[str],
+        All | Sequence[str],
+        BaseCheckpointSaver | None,
+        BaseStore | None,
     ]:
         if config["recursion_limit"] < 1:
             raise ValueError("recursion_limit must be at least 1")
@@ -2089,7 +2145,7 @@ class Pregel(PregelProtocol):
             # if being called as a node in another graph, always use values mode
             stream_mode = ["values"]
         if self.checkpointer is False:
-            checkpointer: Optional[BaseCheckpointSaver] = None
+            checkpointer: BaseCheckpointSaver | None = None
         elif CONFIG_KEY_CHECKPOINTER in config.get(CONF, {}):
             checkpointer = config[CONF][CONFIG_KEY_CHECKPOINTER]
         elif self.checkpointer is True:
@@ -2101,7 +2157,7 @@ class Pregel(PregelProtocol):
                 f"Checkpointer requires one or more of the following 'configurable' keys: {[s.id for s in checkpointer.config_specs]}"
             )
         if CONFIG_KEY_STORE in config.get(CONF, {}):
-            store: Optional[BaseStore] = config[CONF][CONFIG_KEY_STORE]
+            store: BaseStore | None = config[CONF][CONFIG_KEY_STORE]
         else:
             store = self.store
         return (
@@ -2116,17 +2172,17 @@ class Pregel(PregelProtocol):
 
     def stream(
         self,
-        input: Union[dict[str, Any], Any],
-        config: Optional[RunnableConfig] = None,
+        input: dict[str, Any] | Any,
+        config: RunnableConfig | None = None,
         *,
-        stream_mode: Optional[Union[StreamMode, list[StreamMode]]] = None,
-        output_keys: Optional[Union[str, Sequence[str]]] = None,
-        interrupt_before: Optional[Union[All, Sequence[str]]] = None,
-        interrupt_after: Optional[Union[All, Sequence[str]]] = None,
-        checkpoint_during: Optional[bool] = None,
-        debug: Optional[bool] = None,
+        stream_mode: StreamMode | list[StreamMode] | None = None,
+        output_keys: str | Sequence[str] | None = None,
+        interrupt_before: All | Sequence[str] | None = None,
+        interrupt_after: All | Sequence[str] | None = None,
+        checkpoint_during: bool | None = None,
+        debug: bool | None = None,
         subgraphs: bool = False,
-    ) -> Iterator[Union[dict[str, Any], Any]]:
+    ) -> Iterator[dict[str, Any] | Any]:
         """Stream graph steps for a single input.
 
         Args:
@@ -2352,7 +2408,7 @@ class Pregel(PregelProtocol):
                 ):
                     # we are careful to have a single waiter live at any one time
                     # because on exit we increment semaphore count by exactly 1
-                    waiter: Optional[concurrent.futures.Future] = None
+                    waiter: concurrent.futures.Future | None = None
                     # because sync futures cannot be cancelled, we instead
                     # release the stream semaphore on exit, which will cause
                     # a pending waiter to return immediately
@@ -2403,17 +2459,17 @@ class Pregel(PregelProtocol):
 
     async def astream(
         self,
-        input: Union[dict[str, Any], Any],
-        config: Optional[RunnableConfig] = None,
+        input: dict[str, Any] | Any,
+        config: RunnableConfig | None = None,
         *,
-        stream_mode: Optional[Union[StreamMode, list[StreamMode]]] = None,
-        output_keys: Optional[Union[str, Sequence[str]]] = None,
-        interrupt_before: Optional[Union[All, Sequence[str]]] = None,
-        interrupt_after: Optional[Union[All, Sequence[str]]] = None,
-        checkpoint_during: Optional[bool] = None,
-        debug: Optional[bool] = None,
+        stream_mode: StreamMode | list[StreamMode] | None = None,
+        output_keys: str | Sequence[str] | None = None,
+        interrupt_before: All | Sequence[str] | None = None,
+        interrupt_after: All | Sequence[str] | None = None,
+        checkpoint_during: bool | None = None,
+        debug: bool | None = None,
         subgraphs: bool = False,
-    ) -> AsyncIterator[Union[dict[str, Any], Any]]:
+    ) -> AsyncIterator[dict[str, Any] | Any]:
         """Stream graph steps for a single input.
 
         Args:
@@ -2704,17 +2760,17 @@ class Pregel(PregelProtocol):
 
     def invoke(
         self,
-        input: Union[dict[str, Any], Any],
-        config: Optional[RunnableConfig] = None,
+        input: dict[str, Any] | Any,
+        config: RunnableConfig | None = None,
         *,
         stream_mode: StreamMode = "values",
-        output_keys: Optional[Union[str, Sequence[str]]] = None,
-        interrupt_before: Optional[Union[All, Sequence[str]]] = None,
-        interrupt_after: Optional[Union[All, Sequence[str]]] = None,
-        checkpoint_during: Optional[bool] = None,
-        debug: Optional[bool] = None,
+        output_keys: str | Sequence[str] | None = None,
+        interrupt_before: All | Sequence[str] | None = None,
+        interrupt_after: All | Sequence[str] | None = None,
+        checkpoint_during: bool | None = None,
+        debug: bool | None = None,
         **kwargs: Any,
-    ) -> Union[dict[str, Any], Any]:
+    ) -> dict[str, Any] | Any:
         """Run the graph with a single input and config.
 
         Args:
@@ -2733,7 +2789,7 @@ class Pregel(PregelProtocol):
         """
         output_keys = output_keys if output_keys is not None else self.output_channels
         if stream_mode == "values":
-            latest: Union[dict[str, Any], Any] = None
+            latest: dict[str, Any] | Any = None
         else:
             chunks = []
         for chunk in self.stream(
@@ -2758,17 +2814,17 @@ class Pregel(PregelProtocol):
 
     async def ainvoke(
         self,
-        input: Union[dict[str, Any], Any],
-        config: Optional[RunnableConfig] = None,
+        input: dict[str, Any] | Any,
+        config: RunnableConfig | None = None,
         *,
         stream_mode: StreamMode = "values",
-        output_keys: Optional[Union[str, Sequence[str]]] = None,
-        interrupt_before: Optional[Union[All, Sequence[str]]] = None,
-        interrupt_after: Optional[Union[All, Sequence[str]]] = None,
-        checkpoint_during: Optional[bool] = None,
-        debug: Optional[bool] = None,
+        output_keys: str | Sequence[str] | None = None,
+        interrupt_before: All | Sequence[str] | None = None,
+        interrupt_after: All | Sequence[str] | None = None,
+        checkpoint_during: bool | None = None,
+        debug: bool | None = None,
         **kwargs: Any,
-    ) -> Union[dict[str, Any], Any]:
+    ) -> dict[str, Any] | Any:
         """Asynchronously invoke the graph on a single input.
 
         Args:
@@ -2788,7 +2844,7 @@ class Pregel(PregelProtocol):
 
         output_keys = output_keys if output_keys is not None else self.output_channels
         if stream_mode == "values":
-            latest: Union[dict[str, Any], Any] = None
+            latest: dict[str, Any] | Any = None
         else:
             chunks = []
         async for chunk in self.astream(

libs/langgraph/langgraph/pregel/algo.py

@@ -3,19 +3,17 @@ import itertools
 import sys
 import threading
 from collections import defaultdict, deque
+from collections.abc import Iterable, Mapping, Sequence
 from copy import copy
 from functools import partial
 from hashlib import sha1
 from typing import (
     Any,
     Callable,
-    Iterable,
     Literal,
-    Mapping,
     NamedTuple,
     Optional,
     Protocol,
-    Sequence,
     Union,
     cast,
     overload,

libs/langgraph/langgraph/pregel/call.py

@@ -5,7 +5,8 @@ import functools
 import inspect
 import sys
 import types
-from typing import Any, Callable, Generator, Generic, Optional, Sequence, TypeVar, cast
+from collections.abc import Generator, Sequence
+from typing import Any, Callable, Generic, Optional, TypeVar, cast
 
 from langchain_core.runnables import Runnable
 from typing_extensions import ParamSpec
@@ -29,16 +30,12 @@ from langgraph.utils.runnable import (
 def _getattribute(obj: Any, name: str) -> Any:
     for subpath in name.split("."):
         if subpath == "<locals>":
-            raise AttributeError(
-                "Can't get local attribute {!r} on {!r}".format(name, obj)
-            )
+            raise AttributeError(f"Can't get local attribute {name!r} on {obj!r}")
         try:
             parent = obj
             obj = getattr(obj, subpath)
         except AttributeError:
-            raise AttributeError(
-                "Can't get attribute {!r} on {!r}".format(name, obj)
-            ) from None
+            raise AttributeError(f"Can't get attribute {name!r} on {obj!r}") from None
     return obj, parent
 
 

libs/langgraph/langgraph/pregel/checkpoint.py

@@ -1,5 +1,6 @@
+from collections.abc import Mapping
 from datetime import datetime, timezone
-from typing import Mapping, Optional
+from typing import Optional
 
 from langgraph.channels.base import BaseChannel
 from langgraph.checkpoint.base import Checkpoint

libs/langgraph/langgraph/pregel/debug.py

@@ -1,15 +1,12 @@
 from collections import defaultdict
+from collections.abc import Iterable, Iterator, Mapping, Sequence
 from dataclasses import asdict
 from datetime import datetime, timezone
 from pprint import pformat
 from typing import (
     Any,
-    Iterable,
-    Iterator,
     Literal,
-    Mapping,
     Optional,
-    Sequence,
     Union,
 )
 from uuid import UUID

libs/langgraph/langgraph/pregel/draw.py

@@ -0,0 +1,212 @@
+from collections import defaultdict
+from collections.abc import Mapping, Sequence
+from typing import Any, Optional, Union, cast
+
+from langchain_core.runnables.config import RunnableConfig
+from langchain_core.runnables.graph import Graph, Node
+
+from langgraph.channels.base import BaseChannel
+from langgraph.checkpoint.base import BaseCheckpointSaver
+from langgraph.constants import CONF, CONFIG_KEY_SEND, END, INPUT, START
+from langgraph.managed.base import ManagedValueSpec
+from langgraph.pregel.algo import (
+    PregelTaskWrites,
+    apply_writes,
+    increment,
+    prepare_next_tasks,
+)
+from langgraph.pregel.checkpoint import empty_checkpoint
+from langgraph.pregel.io import map_input
+from langgraph.pregel.manager import ChannelsManager
+from langgraph.pregel.read import PregelNode
+from langgraph.pregel.write import ChannelWrite
+from langgraph.types import All, Checkpointer, LoopProtocol
+
+
+def draw_graph(
+    config: RunnableConfig,
+    *,
+    nodes: dict[str, PregelNode],
+    specs: dict[str, Union[BaseChannel, ManagedValueSpec]],
+    input_channels: Union[str, Sequence[str]],
+    interrupt_after_nodes: Union[All, Sequence[str]],
+    interrupt_before_nodes: Union[All, Sequence[str]],
+    trigger_to_nodes: Optional[Mapping[str, Sequence[str]]],
+    checkpointer: Checkpointer,
+    subgraphs: dict[str, Graph],
+) -> Graph:
+    """Get the graph for this Pregel instance.
+
+    Args:
+        config: The configuration to use for the graph.
+        subgraphs: The subgraphs to include in the graph.
+        checkpointer: The checkpointer to use for the graph.
+
+    Returns:
+        The graph for this Pregel instance.
+    """
+    # (src, dest, is_conditional, label)
+    edges: set[tuple[str, str, bool, Optional[str]]] = set()
+
+    step = -1
+    checkpoint = empty_checkpoint()
+    get_next_version = (
+        checkpointer.get_next_version
+        if isinstance(checkpointer, BaseCheckpointSaver)
+        else increment
+    )
+    with ChannelsManager(
+        specs,
+        checkpoint,
+        LoopProtocol(step=step, stop=-1, config=config),
+        skip_context=True,
+    ) as (channels, managed):
+        static_seen: set[Any] = set()
+        sources: dict[str, set[tuple[str, bool, Optional[str]]]] = {}
+        step_sources: dict[str, set[tuple[str, bool, Optional[str]]]] = {}
+        # remove node mappers
+        nodes = {
+            k: v.copy(update={"mapper": None}) if v.mapper is not None else v
+            for k, v in nodes.items()
+        }
+        # apply input writes
+        input_writes = list(map_input(input_channels, {}))
+        _, updated_channels = apply_writes(
+            checkpoint,
+            channels,
+            [
+                PregelTaskWrites((), INPUT, input_writes, []),
+            ],
+            get_next_version,
+        )
+        # prepare first tasks
+        tasks = prepare_next_tasks(
+            checkpoint,
+            [],
+            nodes,
+            channels,
+            managed,
+            config,
+            step,
+            for_execution=True,
+            store=None,
+            checkpointer=None,
+            manager=None,
+            trigger_to_nodes=trigger_to_nodes,
+            updated_channels=updated_channels,
+        )
+        start_tasks = tasks
+        # run the pregel loop
+        while tasks:
+            conditionals: dict[tuple[str, str, Any], Optional[str]] = {}
+            # run task writers
+            for task in tasks.values():
+                for w in task.writers:
+                    # apply regular writes
+                    if isinstance(w, ChannelWrite):
+                        w.invoke(None, task.config)
+                    # apply conditional writes declared for static analysis, only once
+                    if w not in static_seen:
+                        static_seen.add(w)
+                        # apply static writes
+                        if writes := ChannelWrite.get_static_writes(w):
+                            conditionals.update(
+                                {(task.name, *t[:2]): t[2] for t in writes}
+                            )
+                            task.config[CONF][CONFIG_KEY_SEND]([t[:2] for t in writes])
+            # collect sources
+            step_sources = {
+                task.name: {
+                    (
+                        w[0],
+                        (task.name, *w) in conditionals,
+                        conditionals.get((task.name, *w)),
+                    )
+                    for w in task.writes
+                }
+                for task in tasks.values()
+            }
+            sources.update(step_sources)
+            # invert triggers
+            trigger_to_sources: dict[str, set[tuple[str, bool, Optional[str]]]] = (
+                defaultdict(set)
+            )
+            for src, triggers in sources.items():
+                for trigger, cond, label in triggers:
+                    trigger_to_sources[trigger].add((src, cond, label))
+            # apply writes
+            _, updated_channels = apply_writes(
+                checkpoint, channels, tasks.values(), get_next_version
+            )
+            # prepare next tasks
+            tasks = prepare_next_tasks(
+                checkpoint,
+                [],
+                nodes,
+                channels,
+                managed,
+                config,
+                step,
+                for_execution=True,
+                store=None,
+                checkpointer=None,
+                manager=None,
+                trigger_to_nodes=trigger_to_nodes,
+                updated_channels=updated_channels,
+            )
+            # collect edges
+            for task in tasks.values():
+                for trigger in task.triggers:
+                    for src, cond, label in sorted(trigger_to_sources[trigger]):
+                        edges.add((src, task.name, cond, label))
+        # assemble the graph
+        graph = Graph()
+        # add nodes
+        for name, node in nodes.items():
+            metadata = dict(node.metadata or {})
+            if name in interrupt_before_nodes and name in interrupt_after_nodes:
+                metadata["__interrupt"] = "before,after"
+            elif name in interrupt_before_nodes:
+                metadata["__interrupt"] = "before"
+            elif name in interrupt_after_nodes:
+                metadata["__interrupt"] = "after"
+            graph.add_node(node.bound, name, metadata=metadata or None)
+        # add start node
+        if START not in nodes:
+            graph.add_node(None, START)
+            for task in start_tasks.values():
+                graph.add_edge(graph.nodes[START], graph.nodes[task.name])
+        # add discovered edges
+        for src, dest, is_conditional, label in sorted(edges):
+            graph.add_edge(
+                graph.nodes[src],
+                graph.nodes[dest],
+                data=label if label != dest else None,
+                conditional=is_conditional,
+            )
+        # add end edges
+        if step_sources:
+            end = graph.add_node(None, END)
+            termini = {d for _, d, _, _ in edges}.difference(s for s, _, _, _ in edges)
+            for src in sorted(termini.union(step_sources)):
+                graph.add_edge(graph.nodes[src], end, conditional=src not in termini)
+        # replace subgraphs
+        for name, subgraph in subgraphs.items():
+            subgraph.trim_first_node()
+            subgraph.trim_last_node()
+            if (
+                len(subgraph.nodes) > 1
+                and name in graph.nodes
+                and subgraph.first_node()
+                and subgraph.last_node()
+            ):
+                # replace the node with the subgraph
+                graph.nodes.pop(name)
+                first, last = graph.extend(subgraph, prefix=name)
+                for idx, edge in enumerate(graph.edges):
+                    if edge.source == name:
+                        graph.edges[idx] = edge.copy(source=cast(Node, last).id)
+                    elif edge.target == name:
+                        graph.edges[idx] = edge.copy(target=cast(Node, first).id)
+
+        return graph

libs/langgraph/langgraph/pregel/executor.py

@@ -1,15 +1,12 @@
 import asyncio
 import concurrent.futures
 import time
-from contextlib import ExitStack
+from collections.abc import Awaitable, Coroutine
+from contextlib import AbstractAsyncContextManager, AbstractContextManager, ExitStack
 from contextvars import copy_context
 from types import TracebackType
 from typing import (
-    AsyncContextManager,
-    Awaitable,
     Callable,
-    ContextManager,
-    Coroutine,
     Optional,
     Protocol,
     TypeVar,
@@ -40,7 +37,7 @@ class Submit(Protocol[P, T]):
     ) -> concurrent.futures.Future[T]: ...
 
 
-class BackgroundExecutor(ContextManager):
+class BackgroundExecutor(AbstractContextManager):
     """A context manager that runs sync tasks in the background.
     Uses a thread pool executor to delegate tasks to separate threads.
     On exit,
@@ -122,7 +119,7 @@ class BackgroundExecutor(ContextManager):
                     pass
 
 
-class AsyncBackgroundExecutor(AsyncContextManager):
+class AsyncBackgroundExecutor(AbstractAsyncContextManager):
     """A context manager that runs async tasks in the background.
     Uses the current event loop to delegate tasks to asyncio tasks.
     On exit,

libs/langgraph/langgraph/pregel/io.py

@@ -1,5 +1,6 @@
 from collections import Counter
-from typing import Any, Iterator, Literal, Mapping, Optional, Sequence, TypeVar, Union
+from collections.abc import Iterator, Mapping, Sequence
+from typing import Any, Literal, Optional, TypeVar, Union
 from uuid import UUID
 
 from langchain_core.runnables.utils import AddableDict

libs/langgraph/langgraph/pregel/loop.py

@@ -3,21 +3,20 @@ import binascii
 import concurrent.futures
 import dataclasses
 from collections import defaultdict, deque
-from contextlib import AsyncExitStack, ExitStack
+from collections.abc import Iterator, Mapping, Sequence
+from contextlib import (
+    AbstractAsyncContextManager,
+    AbstractContextManager,
+    AsyncExitStack,
+    ExitStack,
+)
 from inspect import signature
 from types import TracebackType
 from typing import (
     Any,
-    AsyncContextManager,
     Callable,
-    ContextManager,
-    Iterator,
-    List,
     Literal,
-    Mapping,
     Optional,
-    Sequence,
-    Type,
     TypeVar,
     Union,
     cast,
@@ -146,7 +145,7 @@ def DuplexStream(*streams: StreamProtocol) -> StreamProtocol:
 
 class PregelLoop(LoopProtocol):
     input: Optional[Any]
-    input_model: Optional[Type[BaseModel]]
+    input_model: Optional[type[BaseModel]]
     checkpointer: Optional[BaseCheckpointSaver]
     nodes: Mapping[str, PregelNode]
     specs: Mapping[str, Union[BaseChannel, ManagedValueSpec]]
@@ -186,7 +185,7 @@ class PregelLoop(LoopProtocol):
     checkpoint_ns: tuple[str, ...]
     checkpoint_config: RunnableConfig
     checkpoint_metadata: CheckpointMetadata
-    checkpoint_pending_writes: List[PendingWrite]
+    checkpoint_pending_writes: list[PendingWrite]
     checkpoint_previous_versions: dict[str, Union[str, float, int]]
     prev_checkpoint_config: Optional[RunnableConfig]
 
@@ -214,7 +213,7 @@ class PregelLoop(LoopProtocol):
         interrupt_after: Union[All, Sequence[str]] = EMPTY_SEQ,
         interrupt_before: Union[All, Sequence[str]] = EMPTY_SEQ,
         manager: Union[None, AsyncParentRunManager, ParentRunManager] = None,
-        input_model: Optional[Type[BaseModel]] = None,
+        input_model: Optional[type[BaseModel]] = None,
         debug: bool = False,
         migrate_checkpoint: Optional[Callable[[Checkpoint], None]] = None,
         trigger_to_nodes: Optional[Mapping[str, Sequence[str]]] = None,
@@ -491,7 +490,7 @@ class PregelLoop(LoopProtocol):
             if self.input is INPUT_SHOULD_VALIDATE:
                 self.input = INPUT_DONE
                 # validate
-                cast(Type[BaseModel], self.input_model)(
+                cast(type[BaseModel], self.input_model)(
                     **read_channels(self.channels, self.stream_keys)
                 )
             # produce values output
@@ -839,7 +838,7 @@ class PregelLoop(LoopProtocol):
 
     def _suppress_interrupt(
         self,
-        exc_type: Optional[Type[BaseException]],
+        exc_type: Optional[type[BaseException]],
         exc_value: Optional[BaseException],
         traceback: Optional[TracebackType],
     ) -> Optional[bool]:
@@ -945,7 +944,7 @@ class PregelLoop(LoopProtocol):
                 )
 
 
-class SyncPregelLoop(PregelLoop, ContextManager):
+class SyncPregelLoop(PregelLoop, AbstractContextManager):
     def __init__(
         self,
         input: Optional[Any],
@@ -961,7 +960,7 @@ class SyncPregelLoop(PregelLoop, ContextManager):
         interrupt_before: Union[All, Sequence[str]] = EMPTY_SEQ,
         output_keys: Union[str, Sequence[str]] = EMPTY_SEQ,
         stream_keys: Union[str, Sequence[str]] = EMPTY_SEQ,
-        input_model: Optional[Type[BaseModel]] = None,
+        input_model: Optional[type[BaseModel]] = None,
         debug: bool = False,
         migrate_checkpoint: Optional[Callable[[Checkpoint], None]] = None,
         trigger_to_nodes: Optional[Mapping[str, Sequence[str]]] = None,
@@ -1087,7 +1086,7 @@ class SyncPregelLoop(PregelLoop, ContextManager):
 
     def __exit__(
         self,
-        exc_type: Optional[Type[BaseException]],
+        exc_type: Optional[type[BaseException]],
         exc_value: Optional[BaseException],
         traceback: Optional[TracebackType],
     ) -> Optional[bool]:
@@ -1095,7 +1094,7 @@ class SyncPregelLoop(PregelLoop, ContextManager):
         return self.stack.__exit__(exc_type, exc_value, traceback)
 
 
-class AsyncPregelLoop(PregelLoop, AsyncContextManager):
+class AsyncPregelLoop(PregelLoop, AbstractAsyncContextManager):
     def __init__(
         self,
         input: Optional[Any],
@@ -1111,7 +1110,7 @@ class AsyncPregelLoop(PregelLoop, AsyncContextManager):
         manager: Union[None, AsyncParentRunManager, ParentRunManager] = None,
         output_keys: Union[str, Sequence[str]] = EMPTY_SEQ,
         stream_keys: Union[str, Sequence[str]] = EMPTY_SEQ,
-        input_model: Optional[Type[BaseModel]] = None,
+        input_model: Optional[type[BaseModel]] = None,
         debug: bool = False,
         migrate_checkpoint: Optional[Callable[[Checkpoint], None]] = None,
         trigger_to_nodes: Optional[Mapping[str, Sequence[str]]] = None,
@@ -1240,7 +1239,7 @@ class AsyncPregelLoop(PregelLoop, AsyncContextManager):
 
     async def __aexit__(
         self,
-        exc_type: Optional[Type[BaseException]],
+        exc_type: Optional[type[BaseException]],
         exc_value: Optional[BaseException],
         traceback: Optional[TracebackType],
     ) -> Optional[bool]:

libs/langgraph/langgraph/pregel/manager.py

@@ -1,6 +1,7 @@
 import asyncio
+from collections.abc import AsyncIterator, Iterator, Mapping
 from contextlib import AsyncExitStack, ExitStack, asynccontextmanager, contextmanager
-from typing import AsyncIterator, Iterator, Mapping, Union
+from typing import Union
 
 from langgraph.channels.base import BaseChannel
 from langgraph.checkpoint.base import Checkpoint

libs/langgraph/langgraph/pregel/messages.py

@@ -1,12 +1,8 @@
+from collections.abc import AsyncIterator, Iterator, Sequence
 from typing import (
     Any,
-    AsyncIterator,
     Callable,
-    Dict,
-    Iterator,
-    List,
     Optional,
-    Sequence,
     TypeVar,
     Union,
     cast,
@@ -115,13 +111,13 @@ class StreamMessagesHandler(BaseCallbackHandler, _StreamingCallbackHandler):
 
     def on_chain_start(
         self,
-        serialized: Dict[str, Any],
-        inputs: Dict[str, Any],
+        serialized: dict[str, Any],
+        inputs: dict[str, Any],
         *,
         run_id: UUID,
         parent_run_id: Optional[UUID] = None,
-        tags: Optional[List[str]] = None,
-        metadata: Optional[Dict[str, Any]] = None,
+        tags: Optional[list[str]] = None,
+        metadata: Optional[dict[str, Any]] = None,
         **kwargs: Any,
     ) -> Any:
         if (

libs/langgraph/langgraph/pregel/protocol.py

@@ -1,10 +1,8 @@
 from abc import ABC, abstractmethod
+from collections.abc import AsyncIterator, Iterator, Sequence
 from typing import (
     Any,
-    AsyncIterator,
-    Iterator,
     Optional,
-    Sequence,
     Union,
 )
 

libs/langgraph/langgraph/pregel/read.py

@@ -1,14 +1,10 @@
 from __future__ import annotations
 
+from collections.abc import AsyncIterator, Iterator, Mapping, Sequence
 from functools import cached_property
 from typing import (
     Any,
-    AsyncIterator,
     Callable,
-    Iterator,
-    Mapping,
-    Optional,
-    Sequence,
     Union,
 )
 
@@ -37,11 +33,11 @@ class ChannelRead(RunnableCallable):
     """Implements the logic for reading state from CONFIG_KEY_READ.
     Usable both as a runnable as well as a static method to call imperatively."""
 
-    channel: Union[str, list[str]]
+    channel: str | list[str]
 
     fresh: bool = False
 
-    mapper: Optional[Callable[[Any], Any]] = None
+    mapper: Callable[[Any], Any] | None = None
 
     @property
     def config_specs(self) -> list[ConfigurableFieldSpec]:
@@ -57,11 +53,11 @@ class ChannelRead(RunnableCallable):
 
     def __init__(
         self,
-        channel: Union[str, list[str]],
+        channel: str | list[str],
         *,
         fresh: bool = False,
-        mapper: Optional[Callable[[Any], Any]] = None,
-        tags: Optional[list[str]] = None,
+        mapper: Callable[[Any], Any] | None = None,
+        tags: list[str] | None = None,
     ) -> None:
         super().__init__(
             func=self._read,
@@ -75,9 +71,7 @@ class ChannelRead(RunnableCallable):
         self.mapper = mapper
         self.channel = channel
 
-    def get_name(
-        self, suffix: Optional[str] = None, *, name: Optional[str] = None
-    ) -> str:
+    def get_name(self, suffix: str | None = None, *, name: str | None = None) -> str:
         if name:
             pass
         elif isinstance(self.channel, str):
@@ -100,9 +94,9 @@ class ChannelRead(RunnableCallable):
     def do_read(
         config: RunnableConfig,
         *,
-        select: Union[str, list[str]],
+        select: str | list[str],
         fresh: bool = False,
-        mapper: Optional[Callable[[Any], Any]] = None,
+        mapper: Callable[[Any], Any] | None = None,
     ) -> Any:
         try:
             read: READ_TYPE = config[CONF][CONFIG_KEY_READ]
@@ -125,7 +119,7 @@ class PregelNode(Runnable):
     itself, but instead acts as a container for the components necessary to make
     a PregelExecutableTask for a node."""
 
-    channels: Union[list[str], Mapping[str, str]]
+    channels: list[str] | Mapping[str, str]
     """The channels that will be passed as input to `bound`.
     If a list, the node will be invoked with the first of that isn't empty.
     If a dict, the keys are the names of the channels, and the values are the keys
@@ -135,7 +129,7 @@ class PregelNode(Runnable):
     """If any of these channels is written to, this node will be triggered in
     the next step."""
 
-    mapper: Optional[Callable[[Any], Any]]
+    mapper: Callable[[Any], Any] | None
     """A function to transform the input before passing it to `bound`."""
 
     writers: list[Runnable]
@@ -146,13 +140,13 @@ class PregelNode(Runnable):
     """The main logic of the node. This will be invoked with the input from 
     `channels`."""
 
-    retry_policy: Optional[Sequence[RetryPolicy]]
+    retry_policy: Sequence[RetryPolicy] | None
     """The retry policies to use when invoking the node."""
 
-    tags: Optional[Sequence[str]]
+    tags: Sequence[str] | None
     """Tags to attach to the node for tracing."""
 
-    metadata: Optional[Mapping[str, Any]]
+    metadata: Mapping[str, Any] | None
     """Metadata to attach to the node for tracing."""
 
     subgraphs: Sequence[PregelProtocol]
@@ -161,15 +155,15 @@ class PregelNode(Runnable):
     def __init__(
         self,
         *,
-        channels: Union[list[str], Mapping[str, str]],
+        channels: list[str] | Mapping[str, str],
         triggers: Sequence[str],
-        mapper: Optional[Callable[[Any], Any]] = None,
-        writers: Optional[list[Runnable]] = None,
-        tags: Optional[list[str]] = None,
-        metadata: Optional[Mapping[str, Any]] = None,
-        bound: Optional[Runnable[Any, Any]] = None,
-        retry_policy: Optional[Union[RetryPolicy, Sequence[RetryPolicy]]] = None,
-        subgraphs: Optional[Sequence[PregelProtocol]] = None,
+        mapper: Callable[[Any], Any] | None = None,
+        writers: list[Runnable] | None = None,
+        tags: list[str] | None = None,
+        metadata: Mapping[str, Any] | None = None,
+        bound: Runnable[Any, Any] | None = None,
+        retry_policy: RetryPolicy | Sequence[RetryPolicy] | None = None,
+        subgraphs: Sequence[PregelProtocol] | None = None,
     ) -> None:
         self.channels = channels
         self.triggers = list(triggers)
@@ -219,7 +213,7 @@ class PregelNode(Runnable):
         return writers
 
     @cached_property
-    def node(self) -> Optional[Runnable[Any, Any]]:
+    def node(self) -> Runnable[Any, Any] | None:
         """Get a runnable that combines `bound` and `writers`."""
         writers = self.flat_writers
         if self.bound is DEFAULT_BOUND and not writers:
@@ -262,11 +256,9 @@ class PregelNode(Runnable):
 
     def __or__(
         self,
-        other: Union[
-            Runnable[Any, Other],
-            Callable[[Any], Other],
-            Mapping[str, Runnable[Any, Other] | Callable[[Any], Other]],
-        ],
+        other: Runnable[Any, Other]
+        | Callable[[Any], Other]
+        | Mapping[str, Runnable[Any, Other] | Callable[[Any], Other]],
     ) -> PregelNode:
         if isinstance(other, Runnable) and ChannelWrite.is_writer(other):
             return self.copy(update=dict(writers=[*self.writers, other]))
@@ -278,7 +270,7 @@ class PregelNode(Runnable):
     def pipe(
         self,
         *others: Runnable[Any, Other] | Callable[[Any], Other],
-        name: Optional[str] = None,
+        name: str | None = None,
     ) -> RunnableSerializable[Any, Other]:
         for other in others:
             self = self | other
@@ -286,19 +278,17 @@ class PregelNode(Runnable):
 
     def __ror__(
         self,
-        other: Union[
-            Runnable[Other, Any],
-            Callable[[Any], Other],
-            Mapping[str, Union[Runnable[Other, Any], Callable[[Other], Any]]],
-        ],
+        other: Runnable[Other, Any]
+        | Callable[[Any], Other]
+        | Mapping[str, Runnable[Other, Any] | Callable[[Other], Any]],
     ) -> RunnableSerializable:
         raise NotImplementedError()
 
     def invoke(
         self,
         input: Input,
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> Any:
         return self.bound.invoke(
             input,
@@ -309,8 +299,8 @@ class PregelNode(Runnable):
     async def ainvoke(
         self,
         input: Input,
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> Any:
         return await self.bound.ainvoke(
             input,
@@ -321,8 +311,8 @@ class PregelNode(Runnable):
     def stream(
         self,
         input: Input,
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> Iterator[Any]:
         yield from self.bound.stream(
             input,
@@ -333,8 +323,8 @@ class PregelNode(Runnable):
     async def astream(
         self,
         input: Input,
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> AsyncIterator[Any]:
         async for item in self.bound.astream(
             input,

libs/langgraph/langgraph/pregel/remote.py

@@ -1,11 +1,9 @@
+from collections.abc import AsyncIterator, Iterator, Sequence
 from dataclasses import asdict
 from typing import (
     Any,
-    AsyncIterator,
-    Iterator,
     Literal,
     Optional,
-    Sequence,
     Union,
     cast,
 )