x

docs/_scripts/notebook_hooks.py

@@ -61,6 +61,7 @@ REDIRECT_MAP = {
     "how-tos/subgraph-persistence.ipynb": "how-tos/persistence.ipynb#use-with-subgraphs",
     "how-tos/cross-thread-persistence.ipynb": "how-tos/persistence.ipynb#add-long-term-memory",
     "cloud/how-tos/copy_threads": "cloud/how-tos/use_threads",
+    "cloud/concepts/threads.md": "concepts/persistence.md#threads",
     # tool calling how-tos
     "how-tos/tool-calling-errors.ipynb": "how-tos/tool-calling.ipynb#handle-errors",
     "how-tos/pass-config-to-tools.ipynb": "how-tos/tool-calling.ipynb#access-config",
@@ -86,6 +87,8 @@ REDIRECT_MAP = {
     "cloud/how-tos/stream_events.md": "cloud/how-tos/streaming.md#stream-events",
     "cloud/how-tos/stream_debug.md": "cloud/how-tos/streaming.md#debug",
     "cloud/how-tos/stream_multiple.md": "cloud/how-tos/streaming.md#stream-multiple-modes",
+    "cloud/concepts/streaming.md": "concepts/streaming.md",
+    "agents/streaming.md": "how-tos/streaming.md",
     # prebuit redirects
     "how-tos/create-react-agent.ipynb": "agents/agents.md#basic-configuration",
     "how-tos/create-react-agent-memory.ipynb": "agents/memory.md",
@@ -107,8 +110,10 @@ REDIRECT_MAP = {
     # deployment redirects
     "how-tos/deploy-self-hosted.md": "cloud/deployment/self_hosted_data_plane.md",
     "concepts/self_hosted.md": "concepts/langgraph_self_hosted_data_plane.md",
+    "tutorials/deployment.md": "concepts/deployment_options.md",
     # assistant redirects
     "cloud/how-tos/assistant_versioning.md": "cloud/how-tos/configuration_cloud.md",
+    "cloud/concepts/runs.md": "concepts/assistants.md#execution",
 }
 
 

docs/docs/agents/deployment.md

@@ -89,4 +89,4 @@ LangGraph Studio Web is a specialized UI that you can connect to LangGraph API s
 
 ## Deployment
 
-Once your LangGraph app is running locally, you can deploy it using LangGraph Platform. Refer to the [deployment options guide](../tutorials/deployment.md) for detailed instructions on all supported deployment models.
+Once your LangGraph app is running locally, you can deploy it using LangGraph Platform. Refer to the [deployment options guide](../concepts/deployment_options.md) for detailed instructions on all supported deployment models.

docs/docs/agents/overview.md

@@ -29,10 +29,10 @@ LangGraph includes several capabilities essential for building robust, productio
 
 - [**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.
+- [**Streaming support**](../how-tos/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.
+    - Supports multiple [**deployment options**](https://langchain-ai.github.io/langgraph/concepts/deployment_options.md) for production.
 
 ## High-level building blocks
 

docs/docs/agents/run_agents.md

@@ -109,7 +109,7 @@ Streaming is available in both sync and async modes:
 
 !!! tip
 
-    For full details, see the [streaming guide](./streaming.md).
+    For full details, see the [streaming guide](../how-tos/streaming.md).
 
 ## Max iterations
 

docs/docs/agents/streaming.md

@@ -1,223 +0,0 @@
----
-search:
-  boost: 2
-tags:
-  - agent
-hide:
-  - tags
----
-
-# 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")
-    ```
-
-## Disable streaming
-
-In some applications you might need to disable streaming of individual tokens for a given model. This is useful in [multi-agent](./multi-agent.md) systems to control which agents stream their output.
-
-See the [Models](./models.md#disable-streaming) guide to learn how to disable streaming.
-
-## Additional resources
-
-* [Streaming in LangGraph](https://langchain-ai.github.io/langgraph/how-tos/streaming)

docs/docs/agents/tools.md

@@ -1,310 +1 @@
----
-search:
-  boost: 2
-tags:
-  - agent
-hide:
-  - tags
----
-
-# 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.
-
-## Working with memory
-
-LangGraph allows access to short-term and long-term memory from tools. See [Memory](./memory.md) guide for more information on:
-
-* how to [read](./memory.md#read-short-term) from and [write](./memory.md#write-short-term) to **short-term** memory
-* how to [read](./memory.md#read-long-term) from and [write](./memory.md#write-long-term) to **long-term** memory
-
-## Prebuilt tools
-
-You can use prebuilt tools from model providers by passing a dictionary with tool specs to the `tools` parameter of `create_react_agent`. For example, to use the `web_search_preview` tool from OpenAI:
-
-```python
-from langgraph.prebuilt import create_react_agent
-
-agent = create_react_agent(
-    model="openai:gpt-4o-mini", 
-    tools=[{"type": "web_search_preview"}]
-)
-response = agent.invoke(
-    {"messages": ["What was a positive news story from today?"]}
-)
-```
-
-Additionally, 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.
-
+delete me

docs/docs/cloud/concepts/runs.md

@@ -1,5 +0,0 @@
-# Runs
-
-A run is an invocation of an [assistant](../../concepts/assistants.md). Each run may have its own input, configuration, and metadata, which may affect execution and output of the underlying graph. A run can optionally be executed on a [thread](./threads.md).
-
-The LangGraph Platform API provides several endpoints for creating and managing runs. See the [API reference](../../cloud/reference/api/api_ref.html#tag/thread-runs/) for more details.

docs/docs/cloud/concepts/streaming.md

@@ -1,138 +0,0 @@
-# Streaming
-
-Streaming is critical for making LLM applications feel responsive to end users.  
-When creating a streaming run, the **streaming mode** determines what kinds of data are streamed back to the API client.
-
-## Supported streaming modes
-
-LangGraph Platform supports the following streaming modes:
-
-| Mode                 | Description                                                                                                                                                    | LangGraph Library Method                                                |
-|----------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------|
-| **`values`**         | Stream the full graph state after each [super-step](https://langchain-ai.github.io/langgraph/concepts/low_level/#graphs). [Guide](../how-tos/streaming.md#stream-graph-state) | `.stream()` / `.astream()` with `stream_mode="values"`                  |
-| **`updates`**        | Stream only the updates to the graph state after each node. [Guide](../how-tos/streaming.md#stream-graph-state)                                                              | `.stream()` / `.astream()` with `stream_mode="updates"`                 |
-| **`messages-tuple`** | Stream LLM tokens for any messages generated inside the graph (useful for chat apps). [Guide](../how-tos/streaming.md#messages)                                   | `.stream()` / `.astream()` with `stream_mode="messages"`                |
-| **`debug`**          | Stream debug information throughout graph execution. [Guide](../how-tos/streaming.md#debug)                                                                       | `.stream()` / `.astream()` with `stream_mode="debug"`                   |
-| **`custom`**         | Stream custom data. [Guide](../../how-tos/streaming.md#stream-custom-data)                                                                                                                                             | `.stream()` / `.astream()` with `stream_mode="custom"`                  |
-| **`events`**         | Stream all events (including the state of the graph); mainly useful when migrating large LCEL apps. [Guide](../how-tos/streaming.md#stream-events)                       | `.astream_events()`                                                     |
-
-✅ You can also **combine multiple modes** at the same time.  See the [how-to guide](../how-tos/streaming.md#stream-multiple-modes) for configuration details.
-
-## Stateless runs
-
-If you don't want to **persist the outputs** of a streaming run in the [checkpointer](../../concepts/persistence.md) DB, you can create a stateless run without creating a thread:
-
-=== "Python"
-
-    ```python
-    from langgraph_sdk import get_client
-    client = get_client(url=<DEPLOYMENT_URL>, api_key=<API_KEY>)
-
-    async for chunk in client.runs.stream(
-        # highlight-next-line
-        None,  # (1)!
-        assistant_id,
-        input=inputs,
-        stream_mode="updates"
-    ):
-        print(chunk.data)
-    ```
-
-    1. We are passing `None` instead of a `thread_id` UUID.
-
-=== "JavaScript"
-
-    ```js
-    import { Client } from "@langchain/langgraph-sdk";
-    const client = new Client({ apiUrl: <DEPLOYMENT_URL>, apiKey: <API_KEY> });
-
-    // create a streaming run
-    // highlight-next-line
-    const streamResponse = client.runs.stream(
-      // highlight-next-line
-      null,  // (1)!
-      assistantID,
-      {
-        input,
-        streamMode: "updates"
-      }
-    );
-    for await (const chunk of streamResponse) {
-      console.log(chunk.data);
-    }
-    ```
-
-    1. We are passing `None` instead of a `thread_id` UUID.
-
-=== "cURL"
-
-    ```bash
-    curl --request POST \
-    --url <DEPLOYMENT_URL>/runs/stream \
-    --header 'Content-Type: application/json' \
-    --header 'x-api-key: <API_KEY>'
-    --data "{
-      \"assistant_id\": \"agent\",
-      \"input\": <inputs>,
-      \"stream_mode\": \"updates\"
-    }"
-    ```
-
-## Join and stream
-
-LangGraph Platform allows you to join an active [background run](../how-tos/background_run.md) and stream outputs from it. To do so, you can use [LangGraph SDK's](https://langchain-ai.github.io/langgraph/cloud/reference/sdk/python_sdk_ref/) `client.runs.join_stream` method:
-
-=== "Python"
-
-    ```python
-    from langgraph_sdk import get_client
-    client = get_client(url=<DEPLOYMENT_URL>, api_key=<API_KEY>)
-
-    # highlight-next-line
-    async for chunk in client.runs.join_stream(
-        thread_id,
-        # highlight-next-line
-        run_id,  # (1)!
-    ):
-        print(chunk)
-    ```
-
-    1. This is the `run_id` of an existing run you want to join.
-
-
-=== "JavaScript"
-
-    ```js
-    import { Client } from "@langchain/langgraph-sdk";
-    const client = new Client({ apiUrl: <DEPLOYMENT_URL>, apiKey: <API_KEY> });
-
-    // highlight-next-line
-    const streamResponse = client.runs.joinStream(
-      threadID,
-      // highlight-next-line
-      runId  // (1)!
-    );
-    for await (const chunk of streamResponse) {
-      console.log(chunk);
-    }
-    ```
-
-    1. This is the `run_id` of an existing run you want to join.
-
-=== "cURL"
-
-    ```bash
-    curl --request GET \
-    --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/<RUN_ID>/stream \
-    --header 'Content-Type: application/json' \
-    --header 'x-api-key: <API_KEY>'
-    ```
-
-!!! warning "Outputs not buffered"
-
-    When you use `.join_stream`, output is not buffered, so any output produced before joining will not be received.
-
-## API Reference
-
-For API usage and implementation, refer to the [API reference](../reference/api/api_ref.html#tag/thread-runs/POST/threads/{thread_id}/runs/stream). 
-

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

@@ -33,7 +33,7 @@ For more information on breakpoints see [here](../../concepts/breakpoints.md).
 
 ### Submit run
 
-To submit the run with the specified input and run settings, click the "Submit" button. This will add a [run](../concepts/runs.md) to the existing selected [thread](../concepts/threads.md). If no thread is currently selected, a new one will be created.
+To submit the run with the specified input and run settings, click the "Submit" button. This will add a [run](../concepts/runs.md) to the existing selected [thread](../../concepts/persistence.md#threads). If no thread is currently selected, a new one will be created.
 
 To cancel the ongoing run, click the "Cancel" button.
 

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

@@ -1,8 +1,12 @@
-# Stream outputs
+# Streaming API
 
-## Streaming API
+[LangGraph SDK](https://langchain-ai.github.io/langgraph/cloud/reference/sdk/python_sdk_ref/) allows you to [stream outputs](../../concepts/streaming.md) from the LangGraph API server.
 
-[LangGraph SDK](https://langchain-ai.github.io/langgraph/cloud/reference/sdk/python_sdk_ref/) allows you to stream outputs from the LangGraph API server.
+!!! note
+
+    LangGraph SDK and LangGraph Server are a part of [LangGraph Platform](../../concepts/langgraph_platform.md).
+
+## Basic usage
 
 Basic usage example:
 
@@ -833,3 +837,121 @@ To stream all events, including the state of the graph:
       \"stream_mode\": \"events\"
     }"
     ```
+
+## Stateless runs
+
+If you don't want to **persist the outputs** of a streaming run in the [checkpointer](../../concepts/persistence.md) DB, you can create a stateless run without creating a thread:
+
+=== "Python"
+
+    ```python
+    from langgraph_sdk import get_client
+    client = get_client(url=<DEPLOYMENT_URL>, api_key=<API_KEY>)
+
+    async for chunk in client.runs.stream(
+        # highlight-next-line
+        None,  # (1)!
+        assistant_id,
+        input=inputs,
+        stream_mode="updates"
+    ):
+        print(chunk.data)
+    ```
+
+    1. We are passing `None` instead of a `thread_id` UUID.
+
+=== "JavaScript"
+
+    ```js
+    import { Client } from "@langchain/langgraph-sdk";
+    const client = new Client({ apiUrl: <DEPLOYMENT_URL>, apiKey: <API_KEY> });
+
+    // create a streaming run
+    // highlight-next-line
+    const streamResponse = client.runs.stream(
+      // highlight-next-line
+      null,  // (1)!
+      assistantID,
+      {
+        input,
+        streamMode: "updates"
+      }
+    );
+    for await (const chunk of streamResponse) {
+      console.log(chunk.data);
+    }
+    ```
+
+    1. We are passing `None` instead of a `thread_id` UUID.
+
+=== "cURL"
+
+    ```bash
+    curl --request POST \
+    --url <DEPLOYMENT_URL>/runs/stream \
+    --header 'Content-Type: application/json' \
+    --header 'x-api-key: <API_KEY>'
+    --data "{
+      \"assistant_id\": \"agent\",
+      \"input\": <inputs>,
+      \"stream_mode\": \"updates\"
+    }"
+    ```
+
+## Join and stream
+
+LangGraph Platform allows you to join an active [background run](../how-tos/background_run.md) and stream outputs from it. To do so, you can use [LangGraph SDK's](https://langchain-ai.github.io/langgraph/cloud/reference/sdk/python_sdk_ref/) `client.runs.join_stream` method:
+
+=== "Python"
+
+    ```python
+    from langgraph_sdk import get_client
+    client = get_client(url=<DEPLOYMENT_URL>, api_key=<API_KEY>)
+
+    # highlight-next-line
+    async for chunk in client.runs.join_stream(
+        thread_id,
+        # highlight-next-line
+        run_id,  # (1)!
+    ):
+        print(chunk)
+    ```
+
+    1. This is the `run_id` of an existing run you want to join.
+
+
+=== "JavaScript"
+
+    ```js
+    import { Client } from "@langchain/langgraph-sdk";
+    const client = new Client({ apiUrl: <DEPLOYMENT_URL>, apiKey: <API_KEY> });
+
+    // highlight-next-line
+    const streamResponse = client.runs.joinStream(
+      threadID,
+      // highlight-next-line
+      runId  // (1)!
+    );
+    for await (const chunk of streamResponse) {
+      console.log(chunk);
+    }
+    ```
+
+    1. This is the `run_id` of an existing run you want to join.
+
+=== "cURL"
+
+    ```bash
+    curl --request GET \
+    --url <DEPLOYMENT_URL>/threads/<THREAD_ID>/runs/<RUN_ID>/stream \
+    --header 'Content-Type: application/json' \
+    --header 'x-api-key: <API_KEY>'
+    ```
+
+!!! warning "Outputs not buffered"
+
+    When you use `.join_stream`, output is not buffered, so any output produced before joining will not be received.
+
+## API Reference
+
+For API usage and implementation, refer to the [API reference](../reference/api/api_ref.html#tag/thread-runs/POST/threads/{thread_id}/runs/stream). 

docs/docs/cloud/how-tos/studio/quick_start.md

@@ -13,7 +13,7 @@ LangGraph Studio is accessed from the LangSmith UI, within the LangGraph Platfor
 
 For applications that are [deployed](../../quick_start.md) on LangGraph Platform, you can access Studio as part of that deployment. To do so, navigate to the deployment in LangGraph Platform within the LangSmith UI and click the "LangGraph Studio" button.
 
-This will load the Studio UI connected to your live deployment, allowing you to create, read, and update the [threads](../../concepts/threads.md), [assistants](../../../concepts/assistants.md), and [memory](../../../concepts//memory.md) in that deployment.
+This will load the Studio UI connected to your live deployment, allowing you to create, read, and update the [threads](../../../concepts/persistence.md#threads), [assistants](../../../concepts/assistants.md), and [memory](../../../concepts//memory.md) in that deployment.
 
 ## Local development server
 

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

@@ -1,10 +1,6 @@
 # Manage threads
 
-!!! info "Prerequisites"
-
-    - [Threads Overview](../concepts/threads.md)
-
-Studio allows you to view threads from the server and edit their state.
+Studio allows you to view [threads](../../concepts/persistence.md#threads) from the server and edit their state.
 
 ## View threads
 

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

@@ -1,10 +1,6 @@
 # Use threads
 
-!!! info "Prerequisites"
-
-    - [Threads Overview](../concepts/threads.md)
-
-In this guide, we will show how to create, view, and inspect threads.
+In this guide, we will show how to create, view, and inspect [threads](../../concepts/persistence.md#threads).
 
 ## Create a thread
 

docs/docs/concepts/assistants.md

@@ -1,29 +1,31 @@
 # Assistants
 
-!!! info "Prerequisites"
+**Assistants** allow you to manage configurations (like prompts, LLM selection, tools) separately from your graph's core logic, enabling rapid changes that don't alter the graph architecture. It is a way to create multiple specialized versions of the same graph architecture, each optimized for different use cases through configuration variations rather than structural changes.
 
-    - [LangGraph Server](./langgraph_server.md)
-    - [Configuration](./low_level.md#configuration)
-
-When building agents, it is common to make rapid changes that _do not_ alter the graph logic. For example, simply changing prompts or the LLM selection can have significant impacts on the behavior of the agent but does not require updating your graph's architecture. Assistants offer a straightforward way to manage these configurations separately from your graph's core logic.
-
-Imagine a general-purpose writing agent built on a common graph architecture. While the structure remains the same, different writing styles—such as blog posts and tweets—require tailored configurations to optimize performance. To support these variations, you can create multiple assistants (e.g., one for blogs and another for tweets) that share the underlying graph but differ in model selection and system prompt.
+For example, imagine a general-purpose writing agent built on a common graph architecture. While the structure remains the same, different writing styles—such as blog posts and tweets—require tailored configurations to optimize performance. To support these variations, you can create multiple assistants (e.g., one for blogs and another for tweets) that share the underlying graph but differ in model selection and system prompt.
 
 ![assistant versions](img/assistants.png)
 
-## Configuring assistants
+The LangGraph Cloud API provides several endpoints for creating and managing assistants and their versions. See the [API reference](../cloud/reference/api/api_ref.html#tag/assistants) for more details.
+
+!!! info
+
+    Assistants are a [LangGraph Platform](langgraph_platform.md) concept. They are not available in the open source LangGraph library.
+
+## Configuration
 
 Assistants build on the LangGraph open source concept of [configuration](low_level.md#configuration).
-While configuration is available in the open source LangGraph library, assistants are only present in [LangGraph Platform](langgraph_platform.md).
-This is due to the fact that assistants are tightly coupled to your deployed graph. Upon deployment, LangGraph Server will automatically create a default assistant for each graph using the graph's default configuration settings.
+While configuration is available in the open source LangGraph library, assistants are only present in [LangGraph Platform](langgraph_platform.md). This is due to the fact that assistants are tightly coupled to your deployed graph. Upon deployment, LangGraph Server will automatically create a default assistant for each graph using the graph's default configuration settings.
 
 In practice, an assistant is just an _instance_ of a graph with a specific configuration. Therefore, multiple assistants can reference the same graph but can contain different configurations (e.g. prompts, models, tools). The LangGraph Server API provides several endpoints for creating and managing assistants. See the [API reference](../cloud/reference/api/api_ref.html) and [this how-to](../cloud/how-tos/configuration_cloud.md) for more details on how to create assistants.
 
-## Versioning assistants
+## Versioning
 
 Assistants support versioning to track changes over time.
 Once you've created an assistant, subsequent edits to that assistant will create new versions. See [this how-to](../cloud/how-tos/configuration_cloud.md#create-a-new-version-for-your-assistant) for more details on how to manage assistant versions.
 
-## Learn more
+## Execution
 
-* The LangGraph Cloud API provides several endpoints for creating and managing assistants and their versions. See the [API reference](../cloud/reference/api/api_ref.html#tag/assistants) for more details.
+A **run** is an invocation of an assistant. Each run may have its own input, configuration, and metadata, which may affect execution and output of the underlying graph. A run can optionally be executed on a [thread](../../concepts/persistence.md#threads).
+
+The LangGraph Platform API provides several endpoints for creating and managing runs. See the [API reference](../../cloud/reference/api/api_ref.html#tag/thread-runs/) for more details.

docs/docs/concepts/deployment_options.md

@@ -5,7 +5,16 @@ search:
 
 # Deployment Options
 
-There are 4 main options for deploying with the LangGraph Platform:
+## Free deployment
+
+There are two free options for deploying LangGraph applications via the LangGraph Server:
+
+1. [Local](../tutorials/langgraph-platform/local-server.md): Deploy for local testing and development. 
+1. [Standalone Container (Lite)](../concepts/langgraph_standalone_container.md): A limited version of Standalone Container for deployments unlikely to see more that 1 million node executions per year and that do not need crons and other enterprise features. Standalone Container (Lite) deployment option is free with a LangSmith API key.
+
+## Production deployment
+
+There are 4 main options for deploying with the [LangGraph Platform](langgraph_platform.md):
 
 1. [Cloud SaaS](#cloud-saas)
 
@@ -22,7 +31,7 @@ A quick comparison:
 |----------------------|----------------|----------------------------|-------------------------------|--------------------------|
 | **[Control plane UI/API](../concepts/langgraph_control_plane.md)** | Yes | Yes | Yes | No |
 | **CI/CD** | Managed internally by platform | Managed externally by you | Managed externally by you | Managed externally by you |
-| **Data/compute residency** | LangChain’s cloud | Your cloud | Your cloud | Your cloud |
+| **Data/compute residency** | LangChain's cloud | Your cloud | Your cloud | Your cloud |
 | **LangSmith compatibility** | Trace to LangSmith SaaS | Trace to LangSmith SaaS | Trace to Self-Hosted LangSmith | Optional tracing |
 | **[Server version compatibility](../concepts/langgraph_server.md#server-versions)** | Enterprise | Enterprise | Enterprise | Lite, Enterprise |
 | **[Pricing](https://www.langchain.com/pricing-langgraph-platform)** | Plus | Enterprise | Enterprise | Developer |

docs/docs/concepts/langgraph_platform.md

@@ -17,7 +17,7 @@ Develop, deploy, scale, and manage agents with **LangGraph Platform** — the pu
 
 LangGraph Platform makes it easy to get your agent running in production —  whether it’s built with LangGraph or another framework — so you can focus on your app logic, not infrastructure. Deploy with one click to get a live endpoint, and use our robust APIs and built-in task queues to handle production scale. 
 
-- **[Streaming Support](../cloud/concepts/streaming.md)**: As agents grow more sophisticated, they often benefit from streaming both token outputs and intermediate states back to the user. Without this, users are left waiting for potentially long operations with no feedback. LangGraph Server provides multiple streaming modes optimized for various application needs.
+- **[Streaming Support](../cloud/how-tos/streaming.md)**: As agents grow more sophisticated, they often benefit from streaming both token outputs and intermediate states back to the user. Without this, users are left waiting for potentially long operations with no feedback. LangGraph Server provides multiple streaming modes optimized for various application needs.
 
 - **[Background Runs](../cloud/how-tos/background_run.md)**: For agents that take longer to process (e.g., hours), maintaining an open connection can be impractical. The LangGraph Server supports launching agent runs in the background and provides both polling endpoints and webhooks to monitor run status effectively.
  

docs/docs/concepts/langgraph_self_hosted_control_plane.md

@@ -3,7 +3,7 @@
 There are two versions of the self-hosted deployment: [Self-Hosted Data Plane](./deployment_options.md#self-hosted-data-plane) and [Self-Hosted Control Plane](./deployment_options.md#self-hosted-control-plane).
 
 !!! info "Important"
-    The Self-Hosted Control Plane deployment option is currently in beta stage and requires an [Enterprise](../../concepts/plans.md) plan.
+    The Self-Hosted Control Plane deployment option is currently in beta stage and requires an [Enterprise](plans.md) plan.
 
 ## Requirements
 

docs/docs/concepts/langgraph_self_hosted_data_plane.md

@@ -8,7 +8,7 @@ search:
 There are two versions of the self-hosted deployment: [Self-Hosted Data Plane](./deployment_options.md#self-hosted-data-plane) and [Self-Hosted Control Plane](./deployment_options.md#self-hosted-control-plane).
 
 !!! info "Important"
-    The Self-Hosted Data Plane deployment option is currently in beta stage and requires an [Enterprise](../../concepts/plans.md) plan.
+    The Self-Hosted Data Plane deployment option is currently in beta stage and requires an [Enterprise](plans.md) plan.
 
 ## Requirements
 

docs/docs/concepts/langgraph_server.md

@@ -7,7 +7,7 @@ search:
 
 **LangGraph Server** offers an API for creating and managing agent-based applications. It is built on the concept of [assistants](assistants.md), which are agents configured for specific tasks, and includes built-in [persistence](persistence.md#memory-store) and a **task queue**. This versatile API supports a wide range of agentic application use cases, from background processing to real-time interactions.
 
-Use LangGraph Server to create and manage [assistants](assistants.md), [threads](../cloud/concepts/threads.md), [runs](../cloud/concepts/runs.md), [cron jobs](../cloud/concepts/cron_jobs.md), [webhooks](../cloud/concepts/webhooks.md), and more.
+Use LangGraph Server to create and manage [assistants](assistants.md), [threads](./persistence.md#threads), [runs](../cloud/concepts/runs.md), [cron jobs](../cloud/concepts/cron_jobs.md), [webhooks](../cloud/concepts/webhooks.md), and more.
 
 !!! tip "API reference"
   

docs/docs/concepts/persistence.md

@@ -15,15 +15,19 @@ LangGraph has a built-in persistence layer, implemented through checkpointers. W
 
 ## Threads
 
-A thread is a unique ID or [thread identifier](#threads) assigned to each checkpoint saved by a checkpointer. When invoking graph with a checkpointer, you **must** specify a `thread_id` as part of the `configurable` portion of the config:
+A thread is a unique ID or thread identifier assigned to each checkpoint saved by a checkpointer. It contains the accumulated state of a sequence of [runs](../cloud/concepts/runs.md). When a run is executed, the [state](../concepts/low_level.md#state) of the underlying graph of the assistant will be persisted to the thread.
+
+When invoking graph with a checkpointer, you **must** specify a `thread_id` as part of the `configurable` portion of the config:
 
 ```python
 {"configurable": {"thread_id": "1"}}
 ```
 
+A thread's current and historical state can be retrieved. To persist state, a thread must be created prior to executing a run. The LangGraph Platform API provides several endpoints for creating and managing threads and thread state. See the [API reference](../cloud/reference/api/api_ref.html#tag/threads) for more details.
+
 ## Checkpoints
 
-Checkpoint is a snapshot of the graph state saved at each super-step and is represented by `StateSnapshot` object with the following key properties:
+The state of a thread at a particular point in time is called a checkpoint. Checkpoint is a snapshot of the graph state saved at each super-step and is represented by `StateSnapshot` object with the following key properties:
 
 - `config`: Config associated with this checkpoint. 
 - `metadata`: Metadata associated with this checkpoint.
@@ -31,6 +35,8 @@ Checkpoint is a snapshot of the graph state saved at each super-step and is repr
 - `next` A tuple of the node names to execute next in the graph.
 - `tasks`: A tuple of `PregelTask` objects that contain information about next tasks to be executed. If the step was previously attempted, it will include error information. If a graph was interrupted [dynamically](../how-tos/human_in_the_loop/breakpoints.ipynb#dynamic-breakpoints) from within a node, tasks will contain additional data associated with interrupts.
 
+Checkpoints are persisted and can be used to restore the state of a thread at a later time.
+
 Let's see what checkpoints are saved when a simple graph is invoked as follows:
 
 ```python

docs/docs/concepts/streaming.md

@@ -18,6 +18,6 @@ There are three main categories of data you can stream:
 
 - [**Stream LLM tokens**](../how-tos/streaming.md#messages) — capture token streams from anywhere: inside nodes, subgraphs, or tools.
 - [**Emit progress notifications from tools**](../how-tos/streaming.md#stream-custom-data) — send custom updates or progress signals directly from tool functions.
-- [**Stream from subgraphs**](../how-tos/streaming.md#subgraphs) — include outputs from both the parent graph and any nested subgraphs.
+- [**Stream from subgraphs**](../how-tos/streaming.md#stream-subgraph-outputs) — include outputs from both the parent graph and any nested subgraphs.
 - [**Use any LLM**](../how-tos/streaming.md#use-with-any-llm) — stream tokens from any LLM, even if it's not a LangChain model using the `custom` streaming mode.
 - [**Use multiple streaming modes**](../how-tos/streaming.md#stream-multiple-modes) — choose from `values` (full state), `updates` (state deltas), `messages` (LLM tokens + metadata), `custom` (arbitrary user data), or `debug` (detailed traces).

docs/docs/concepts/tools.md

@@ -1,62 +1,64 @@
 # Tools
 
-Many AI applications interact directly with humans. In these cases, it is appropriate for models to respond in natural language.
-But what about cases where we want a model to also interact *directly* with systems, such as databases or an API?
-These systems often have a particular input schema; for example, APIs frequently have a required payload structure. You can use [tool calling](https://platform.openai.com/docs/guides/function-calling/example-use-cases) to request model responses that match a particular schema.
+Many AI applications interact with users via natural language. However, some use cases require models to interface directly with external systems—such as APIs, databases, or file systems—using structured input. In these scenarios, **tool calling** enables models to generate requests that conform to a specified input schema.
 
-[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.
-
-**Tools** can be passed to [chat models](https://python.langchain.com/docs/concepts/chat_models) that support [tool calling](https://python.langchain.com/docs/concepts/tool_calling) allowing the model to request the execution of a specific function with specific inputs.
-
-You can [create custom tools](https://python.langchain.com/docs/how_to/custom_tools/) or use [prebuilt](#prebuilt-tools) tools.
+[Tools](https://python.langchain.com/docs/concepts/tools/) encapsulate a callable function and its input schema. These can be passed to compatible [chat models](https://python.langchain.com/docs/concepts/chat_models), allowing the model to decide whether to invoke a tool and with what arguments.
 
 ## Tool calling
 
 ![Diagram of a tool call by a model](./img/tool_call.png)
 
-A key principle of tool calling is that the model decides when to use a tool based on the input's relevance. The model doesn't always need to call a tool.
-For example, given an input that is *irrelevant to the tool*, the model would not call the tool:
+Tool calling is typically **conditional**. Based on the user input and available tools, the model may choose to issue a tool call request. This request is returned in an `AIMessage` object, which includes a `tool_calls` field that specifies the tool name and input arguments:
 
 ```python
-result = llm_with_tools.invoke("Hello world!")
+llm_with_tools.invoke("What is 2 multiplied by 3?")
+# -> AIMessage(tool_calls=[{'name': 'multiply', 'args': {'a': 2, 'b': 3}, ...}])
 ```
 
-The result would be an `AIMessage` containing the model's response in natural language (e.g., "Hello!").
-However, if we pass an input *relevant to the tool*, the model should choose to call it:
+If the input is unrelated to any tool, the model returns only a natural language message:
 
 ```python
-result = llm_with_tools.invoke("What is 2 multiplied by 3?")
+llm_with_tools.invoke("Hello world!")  # -> AIMessage(content="Hello!")
 ```
 
-As before, the output `result` will be an `AIMessage`. 
-But, if the tool was called, `result` will have a `tool_calls` attribute.
-This attribute includes everything needed to execute the tool, including the tool name and input arguments:
+Importantly, the model does not execute the tool—it only generates a request. A separate executor (such as a runtime or agent) is responsible for handling the tool call and returning the result.
 
-```
-result.tool_calls
-{'name': 'multiply', 'args': {'a': 2, 'b': 3}, 'id': 'xxx', 'type': 'tool_call'}
-```
-
-For more details on usage, see the [how-to guide](../how-tos/tool-calling.ipynb).
-
-## Execute tools
-
-LangGraph offers pre-built components — [`ToolNode`][langgraph.prebuilt.tool_node.ToolNode] and [`create_react_agent`][langgraph.prebuilt.chat_agent_executor.create_react_agent] — that invoke the tools on behalf of the user.
-
-See this [how-to guide](../how-tos/tool-calling.ipynb#use-prebuilt-toolnode) on tool calling.
+See the [tool calling guide](../how-tos/tool-calling.md) for more details.
 
 ## 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.
+LangChain provides prebuilt tool integrations for common external systems including APIs, databases, file systems, and web data.
 
-You can browse the full list of available integrations in the [LangChain integrations directory](https://python.langchain.com/docs/integrations/tools/).
+Browse the [integrations directory](https://python.langchain.com/docs/integrations/tools/) for available tools.
 
-Some commonly used tool categories include:
+Common categories:
 
-- **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
+* **Search**: Bing, SerpAPI, Tavily
+* **Code execution**: Python REPL, Node.js REPL
+* **Databases**: SQL, MongoDB, Redis
+* **Web data**: Scraping and browsing
+* **APIs**: OpenWeatherMap, NewsAPI, etc.
 
-These integrations can be configured and added to your agents using the same `tools` parameter shown in the examples above.
+## Custom tools
+
+You can define custom tools using the `@tool` decorator or plain Python functions. For example:
+
+```python
+from langchain_core.tools import tool
+
+@tool
+def multiply(a: int, b: int) -> int:
+    """Multiply two numbers."""
+    return a * b
+```
+
+See the [tool calling guide](../how-tos/tool-calling.md) for more details.
+
+## Tool execution
+
+While the model determines *when* to call a tool, **execution** of the tool call must be handled by a runtime component.
+
+LangGraph provides prebuilt components for this:
+
+* [`ToolNode`][oolNode]: Executes tools based on AI tool calls.
+* [`create_react_agent`][create_react_agent]: Constructs a full agent that manages tool calling automatically.

docs/docs/how-tos/streaming.md

@@ -1,11 +1,220 @@
 # Stream outputs
 
-## Streaming API
+You can [stream outputs](../concepts/streaming.md) from a LangGraph agent or workflow.
+
+## Supported stream modes
+
+Pass one or more of the following stream modes as a list to the [`stream()`][langgraph.graph.state.CompiledStateGraph.stream] or [`astream()`][langgraph.graph.state.CompiledStateGraph.astream] methods:
+
+| Mode | Description |
+|------|-------------|
+| `values` | Streams the full value of the state after each step of the graph. |
+| `updates` | Streams the updates to the state after each step of the graph. If multiple updates are made in the same step (e.g., multiple nodes are run), those updates are streamed separately. |
+| `custom` | Streams custom data from inside your graph nodes. |
+| `messages` | Streams 2-tuples (LLM token, metadata) from any graph nodes where an LLM is invoked. |
+| `debug` | Streams as much information as possible throughout the execution of the graph.   
+
+## Stream from an agent
+
+### 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"`. 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")
+    ```
+
+### Disable streaming
+
+In some applications you might need to disable streaming of individual tokens for a given model. This is useful in [multi-agent](../agents/multi-agent.md) systems to control which agents stream their output.
+
+See the [Models](../agents/models.md#disable-streaming) guide to learn how to disable streaming.
+
+## Stream from a workflow 
+
+### Basic usage example
 
 LangGraph graphs expose the [`.stream()`][langgraph.pregel.Pregel.stream] (sync) and [`.astream()`][langgraph.pregel.Pregel.astream] (async) methods to yield streamed outputs as iterators.
 
-Basic usage example:
-
 === "Sync"
 
     ```python
@@ -61,18 +270,7 @@ Basic usage example:
       ```output
       {'refine_topic': {'topic': 'ice cream and cats'}}
       {'generate_joke': {'joke': 'This is a joke about ice cream and cats'}}
-      ```
-
-
-### Supported stream modes
-
-| Mode                             | Description                                                                                                                                                                         |
-|----------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| [`values`](#stream-graph-state)  | Streams the full value of the state after each step of the graph.                                                                                                                   |
-| [`updates`](#stream-graph-state) | Streams the updates to the state after each step of the graph. If multiple updates are made in the same step (e.g., multiple nodes are run), those updates are streamed separately. |
-| [`custom`](#stream-custom-data)  | Streams custom data from inside your graph nodes.                                                                                                                                   |
-| [`messages`](#messages)          | Streams 2-tuples (LLM token, metadata) from any graph nodes where an LLM is invoked.                                                                                                        |
-| [`debug`](#debug)                | Streams as much information as possible throughout the execution of the graph.                                                                                                      |
+      ```                                                                                                   |
 
 ### Stream multiple modes
 
@@ -94,7 +292,7 @@ The streamed outputs will be tuples of `(mode, chunk)` where `mode` is the name
         print(chunk)
     ```
 
-## Stream graph state
+### Stream graph state
 
 Use the stream modes `updates` and `values` to stream the state of the graph as it executes.
 
@@ -157,7 +355,7 @@ graph = (
     ```
 
 
-## Subgraphs
+### Stream subgraph outputs
 
 To include outputs from [subgraphs](../concepts/subgraphs.md) in the streamed outputs, you can set `subgraphs=True` in the `.stream()` method of the parent graph. This will stream outputs from both the parent graph and any subgraphs.
 
@@ -233,7 +431,7 @@ for chunk in graph.stream(
 
       **Note** that we are receiving not just the node updates, but we also the namespaces which tell us what graph (or subgraph) we are streaming from.
 
-## Debugging {#debug}
+### Debugging {#debug}
 
 Use the `debug` streaming mode to stream as much information as possible throughout the execution of the graph. The streamed outputs include the name of the node as well as the full state.
 
@@ -247,7 +445,7 @@ for chunk in graph.stream(
 ```
 
 
-## LLM tokens {#messages}
+### LLM tokens {#messages}
 
 Use the `messages` streaming mode to stream Large Language Model (LLM) outputs **token by token** from any part of your graph, including nodes, tools, subgraphs, or tasks.
 
@@ -307,7 +505,7 @@ for message_chunk, metadata in graph.stream( # (2)!
 2. The "messages" stream mode returns an iterator of tuples `(message_chunk, metadata)` where `message_chunk` is the token streamed by the LLM and `metadata` is a dictionary with information about the graph node where the LLM was called and other information.
 
 
-### Filter by LLM invocation
+#### Filter by LLM invocation
 
 You can associate `tags` with LLM invocations to filter the streamed tokens by LLM invocation.
 
@@ -391,7 +589,7 @@ async for msg, metadata in graph.astream(  # (3)!
       4. The `stream_mode` is set to "messages" to stream LLM tokens. The `metadata` contains information about the LLM invocation, including the tags.
 
 
-### Filter by node
+#### Filter by node
 
 To stream tokens only from specific nodes, use `stream_mode="messages"` and filter the outputs by the `langgraph_node` field in the streamed metadata:
 
@@ -464,7 +662,7 @@ for msg, metadata in graph.stream( # (1)!
       1. The "messages" stream mode returns a tuple of `(message_chunk, metadata)` where `message_chunk` is the token streamed by the LLM and `metadata` is a dictionary with information about the graph node where the LLM was called and other information.
       2. Filter the streamed tokens by the `langgraph_node` field in the metadata to only include the tokens from the `write_poem` node.
 
-## Stream custom data
+### Stream custom data
 
 To send **custom user-defined data** from inside a LangGraph node or tool, follow these steps:
 
@@ -541,7 +739,7 @@ To send **custom user-defined data** from inside a LangGraph node or tool, follo
       3. Emit another custom key-value pair.
       4. Set `stream_mode="custom"` to receive the custom data in the stream.
 
-## Use with any LLM
+### Use with any LLM
 
 You can use `stream_mode="custom"` to stream data from **any LLM API**  — even if that API does **not** implement the LangChain chat model interface.
 
@@ -701,7 +899,7 @@ for chunk in graph.stream(
       ```
 
 
-## Disable streaming for specific chat models
+### Disable streaming for specific chat models
 
 If your application mixes models that support streaming with those that do not, you may need to explicitly disable streaming for 
 models that do not support it.
@@ -733,7 +931,7 @@ Set `disable_streaming=True` when initializing the model.
       1. Set `disable_streaming=True` to disable streaming for the chat model.
 
 
-## Async with Python < 3.11 { #async }
+### Async with Python < 3.11 { #async }
 
 In Python versions < 3.11, [asyncio tasks](https://docs.python.org/3/library/asyncio-task.html#asyncio.create_task) do not support the `context` parameter.  
 This limits LangGraph ability to automatically propagate context, and affects LangGraph’s streaming mechanisms in two key ways:

docs/docs/tutorials/deployment.md

@@ -1,22 +0,0 @@
----
-search:
-  boost: 2
----
-
-# Deployment 🚀
-
-There are two free options for deploying LangGraph applications via the LangGraph Server:
-
-- [Local](./langgraph-platform/local-server.md): Deploy for local testing and development. 
-- [Standalone Container (Lite)](../concepts/langgraph_standalone_container.md): A limited version of Standalone Container for deployments unlikely to see more that 1 million node executions per year and that do not need crons and other enterprise features. Standalone Container (Lite) deployment option is free with a LangSmith API key.
-
-## Other deployment options
-
-Additionally, you can deploy to production with [LangGraph Platform](../concepts/langgraph_platform.md):
-
-- [Cloud SaaS](../concepts/langgraph_cloud.md): Connect your GitHub repositories and deploy LangGraph Servers within LangChain's cloud. *We manage everything.*
-- [Self-Hosted Data Plane<sup>(Beta)</sup>](../concepts/langgraph_self_hosted_data_plane.md): Create deployments from the [Control Plane UI](../concepts/langgraph_control_plane.md#control-plane-ui) and deploy LangGraph Servers to **your** cloud. *We manage the [control plane](../concepts/langgraph_control_plane.md). You manage the deployments.*
-- [Self-Hosted Control Plane<sup>(Beta)</sup>](../concepts/langgraph_self_hosted_control_plane.md): Create deployments from a self-hosted [Control Plane UI](../concepts/langgraph_control_plane.md#control-plane-ui) and deploy LangGraph Servers to **your** cloud. *You manage everything.*
-- [Standalone Container](../concepts/langgraph_standalone_container.md): Deploy LangGraph Server Docker images however you like.
-
-For more information, see [Deployment options](../concepts/deployment_options.md).

docs/mkdocs.yml

@@ -89,163 +89,145 @@ plugins:
                 - "!^_"
 
 nav:
-  - Guides:
+  - Get started:
     - index.md
-    - Get started:
-      - Quickstart: agents/agents.md
-      - LangGraph basics:
-        -  concepts/why-langgraph.md
-        -  Build a basic chatbot: tutorials/get-started/1-build-basic-chatbot.md
-        -  tutorials/get-started/2-add-tools.md
-        -  tutorials/get-started/3-add-memory.md
-        -  Add human-in-the-loop: tutorials/get-started/4-human-in-the-loop.md
-        -  tutorials/get-started/5-customize-state.md
-        -  tutorials/get-started/6-time-travel.md
-      - Deployment: tutorials/deployment.md
-    - Prebuilt agents:
-      - Overview: agents/overview.md
-      - 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
-    - LangGraph framework:
-      - Agent architectures:
-        - Overview: concepts/agentic_concepts.md
+    - Quickstarts:
+      - Agent: agents/agents.md
+      - Local server: tutorials/langgraph-platform/local-server.md
+      - Deployment: cloud/quick_start.md
+    - General concepts:
+      - Common patterns:
+        - Agent architectures: concepts/agentic_concepts.md
         - Workflows & agents: tutorials/workflows.md
-      - Graphs:
-        - Overview: concepts/low_level.md
-        - Runtime overview: concepts/pregel.md
-        - Use the Graph API: how-tos/graph-api.ipynb
-      - Streaming:
-          - Overview: concepts/streaming.md
-          - "Stream outputs": how-tos/streaming.md
-      - Persistence:
-        - Overview: concepts/persistence.md
-        - concepts/durable_execution.md
-        - how-tos/persistence.ipynb
-      - Memory:
-        - Overview: concepts/memory.md
-        - Manage memory: how-tos/memory.ipynb
-      - Human-in-the-loop:
-        - Overview: concepts/human_in_the_loop.md
-        - how-tos/human_in_the_loop/add-human-in-the-loop.md
-      - Breakpoints:
-        - Overview: concepts/breakpoints.md
-        - how-tos/human_in_the_loop/breakpoints.ipynb
-      - Time travel:
-        - Overview: concepts/time-travel.md
-        - how-tos/human_in_the_loop/time-travel.ipynb
-      - Tools:
-        - Overview: concepts/tools.md
-        - how-tos/tool-calling.ipynb
-      - Subgraphs:
-        - Overview: concepts/subgraphs.md
-        - how-tos/subgraph.ipynb
-      - Multi-agent:
-        - Overview: concepts/multi_agent.md
-        - how-tos/multi_agent.ipynb
-      - Functional API:
-        - Overview: concepts/functional_api.md
-        - how-tos/use-functional-api.md
-
-    - LangGraph Platform:
-      - Overview: concepts/langgraph_platform.md
-      - Get started:
-        - Quickstart: tutorials/langgraph-platform/local-server.md
-        - Deployment quickstart: cloud/quick_start.md
-      - Components:
-        - Overview: concepts/langgraph_components.md
-        - LangGraph Server:
-          - Overview: concepts/langgraph_server.md
-          - Application structure:
-            - Overview: concepts/application_structure.md
-            - cloud/deployment/setup.md
-            - cloud/deployment/setup_pyproject.md
-            - cloud/deployment/setup_javascript.md
-            - cloud/deployment/custom_docker.md
-        - LangGraph CLI: concepts/langgraph_cli.md
-        - LangGraph Studio:
-          - Overview: concepts/langgraph_studio.md
-          - Quickstart: cloud/how-tos/studio/quick_start.md
-          - cloud/how-tos/invoke_studio.md
-          - cloud/how-tos/studio/manage_assistants.md
-          - cloud/how-tos/threads_studio.md
-          - cloud/how-tos/iterate_graph_studio.md
-          - cloud/how-tos/studio/run_evals.md
-          - cloud/how-tos/clone_traces_studio.md
-          - cloud/how-tos/datasets_studio.md
-        - LangGraph SDK: concepts/sdk.md
-      - Data management:
-        - Add semantic search: cloud/deployment/semantic_search.md
-        - Add TTLs: how-tos/ttl/configure_ttl.md
+      - Agent development: agents/overview.md
+      - Workflow orchestration:
+        - Graphs: concepts/low_level.md
+        - Subgraphs: concepts/subgraphs.md
+        - Runtime: concepts/pregel.md
+        - Functional API: concepts/functional_api.md
+    - Core capabilities:
+      - Streaming: concepts/streaming.md
+      - Persistence: concepts/persistence.md
+      - Durable execution: concepts/durable_execution.md
+      - Memory: concepts/memory.md
+      - Tools: concepts/tools.md
+      - Human-in-the-loop: concepts/human_in_the_loop.md
+      - Breakpoints: concepts/breakpoints.md
+      - Time travel: concepts/time-travel.md
+      - Multi-agent: concepts/multi_agent.md
+    - Platform capabilities:
+      - LangGraph Platform:
+          - Overview: concepts/langgraph_platform.md
+          - Components:
+            - Overview: concepts/langgraph_components.md
+            - LangGraph Server:
+              - Overview: concepts/langgraph_server.md
+              - Data plane: concepts/langgraph_data_plane.md
+              - Control plane: concepts/langgraph_control_plane.md
+            - LangGraph CLI: concepts/langgraph_cli.md
+            - LangGraph Studio: concepts/langgraph_studio.md
+            - LangGraph SDK: concepts/sdk.md
+          - Plans & pricing: concepts/plans.md
+          - Application structure: concepts/application_structure.md
+          - Scalability & resilience: concepts/scalability_and_resilience.md
+      - Authentication & access control: concepts/auth.md
+      - Assistants: concepts/assistants.md
+      - Double-texting: concepts/double_texting.md
+      - Webhooks: cloud/concepts/webhooks.md
+      - Cron jobs: cloud/concepts/cron_jobs.md
+      - Deployment:
+        - Overview: concepts/deployment_options.md
+        - Deployment options:
+          - Cloud SaaS: concepts/langgraph_cloud.md
+          - Self-Hosted Data Plane: concepts/langgraph_self_hosted_data_plane.md
+          - Self-Hosted Control Plane: concepts/langgraph_self_hosted_control_plane.md
+          - Standalone Container: concepts/langgraph_standalone_container.md
+    
+  - Guides:
+    - LangGraph APIs:
+      - Use the Graph API: how-tos/graph-api.ipynb
+      - Use the Functional API: how-tos/use-functional-api.md
+    - Models:
+      - Configure model: agents/models.md
+    - Streaming:
+      - Stream outputs: how-tos/streaming.md
+      - Use Server API: cloud/how-tos/streaming.md
+    - Context:
+      - Use in agent: agents/context.md
+    - Memory:
+      - Basic implementation: agents/memory.md
+      - Persistence: how-tos/persistence.ipynb # MERGE
+      - Custom implementation: how-tos/memory.ipynb
+    - Human-in-the-loop:
+      - Add to agent: agents/human-in-the-loop.md
+      - Add to workflow: how-tos/human_in_the_loop/add-human-in-the-loop.md
+      - Use Server API: cloud/how-tos/add-human-in-the-loop.md
+    - Time travel:
+      - Use Server API: cloud/how-tos/human_in_the_loop_time_travel.md
+    - Breakpoints:
+      - Set breakpoints: how-tos/human_in_the_loop/breakpoints.ipynb
+      - Use Server API: cloud/how-tos/human_in_the_loop_breakpoint.md
+    - Tools:
+      - Call tools: how-tos/tool-calling.md
+    - Subgraphs:
+      - Use subgraphs: how-tos/subgraph.ipynb
+    - Multi-agent:
+      - Prebuilt implementation: agents/multi-agent.md
+      - Custom implementation: how-tos/multi_agent.ipynb
+    - MCP:
+      - Use MCP tools: agents/mcp.md
+      - Server deployment via MCP: concepts/server-mcp.md
+    - Deployment:
+      - Basic deployment: agents/deployment.md
+      - Set up your application:
+        - Use requirements.txt: cloud/deployment/setup.md
+        - Use pyproject.toml: cloud/deployment/setup_pyproject.md
+        - Use JavaScript: cloud/deployment/setup_javascript.md
+        - Use custom Docker: cloud/deployment/custom_docker.md
+      - Deploy to production:
+         - Cloud SaaS: cloud/deployment/cloud.md
+         - Self-Hosted Data Plane: cloud/deployment/self_hosted_data_plane.md
+         - Self-Hosted Control Plane: cloud/deployment/self_hosted_control_plane.md
+         - Standalone Container: cloud/deployment/standalone_container.md
+    - Evaluation:
+      - Basic implementation: agents/evals.md
+    - Platform capabilities:
+      - LangGraph Studio:
+        - Quickstart: cloud/how-tos/studio/quick_start.md
+        - cloud/how-tos/invoke_studio.md
+        - cloud/how-tos/studio/manage_assistants.md
+        - cloud/how-tos/threads_studio.md
+        - cloud/how-tos/iterate_graph_studio.md
+        - cloud/how-tos/studio/run_evals.md
+        - cloud/how-tos/clone_traces_studio.md
+        - cloud/how-tos/datasets_studio.md
       - Authentication & access control:
-        - Overview: concepts/auth.md
         - how-tos/auth/custom_auth.md
         - how-tos/auth/openapi_security.md
       - Assistants:
-        - Overview: concepts/assistants.md
         - cloud/how-tos/configuration_cloud.md
-      - Threads:
-        - Overview: cloud/concepts/threads.md
-        - cloud/how-tos/use_threads.md
-      - Runs:
-        - Overview: cloud/concepts/runs.md
-        - cloud/how-tos/background_run.md
-        - cloud/how-tos/same-thread.md
-        - cloud/how-tos/cron_jobs.md
-        - cloud/how-tos/stateless_runs.md
-        - cloud/how-tos/configurable_headers.md
-      - Streaming:
-        - Overview: cloud/concepts/streaming.md
-        - cloud/how-tos/streaming.md
-      - Human-in-the-loop: cloud/how-tos/add-human-in-the-loop.md
-      - Breakpoints: cloud/how-tos/human_in_the_loop_breakpoint.md
-      - Time travel: cloud/how-tos/human_in_the_loop_time_travel.md
-      - MCP: concepts/server-mcp.md
+        - Threads: cloud/how-tos/use_threads.md
+        - Runs:
+          - cloud/how-tos/background_run.md
+          - cloud/how-tos/same-thread.md
+          - cloud/how-tos/cron_jobs.md
+          - cloud/how-tos/stateless_runs.md
+          - cloud/how-tos/configurable_headers.md
       - Double-texting:
-        - Overview: concepts/double_texting.md
         - cloud/how-tos/interrupt_concurrent.md
         - cloud/how-tos/rollback_concurrent.md
         - cloud/how-tos/reject_concurrent.md
         - cloud/how-tos/enqueue_concurrent.md
-      - Webhooks:
-        - Overview: cloud/concepts/webhooks.md
-        - cloud/how-tos/webhooks.md
-      - Cron jobs:
-        - Overview: cloud/concepts/cron_jobs.md
-        - cloud/how-tos/cron_jobs.md
+      - Webhooks: cloud/how-tos/webhooks.md
+      - Cron jobs: cloud/how-tos/cron_jobs.md
       - Server customization:
         - how-tos/http/custom_lifespan.md
         - how-tos/http/custom_middleware.md
         - how-tos/http/custom_routes.md
-      - Deployment:
-        - Overview: concepts/deployment_options.md
-        - Data plane: concepts/langgraph_data_plane.md
-        - Control plane: concepts/langgraph_control_plane.md
-        - Deployment options:
-          - Cloud SaaS:
-            - Overview: concepts/langgraph_cloud.md
-            - Deploy Cloud SaaS: cloud/deployment/cloud.md
-          - Self-Hosted Data Plane:
-            - Overview: concepts/langgraph_self_hosted_data_plane.md
-            - Deploy Self-Hosted Data Plane: cloud/deployment/self_hosted_data_plane.md
-          - Self-Hosted Control Plane:
-            - Overview: concepts/langgraph_self_hosted_control_plane.md
-            - Deploy Self-Hosted Control Plane: cloud/deployment/self_hosted_control_plane.md
-          - Standalone Container:
-            - Overview: concepts/langgraph_standalone_container.md
-            - Deploy Standalone Container: cloud/deployment/standalone_container.md
-        - Scalability & resilience: concepts/scalability_and_resilience.md
-        - Plans & pricing: concepts/plans.md
-      
+      - Data management:
+        - Add semantic search: cloud/deployment/semantic_search.md
+        - Add TTLs: how-tos/ttl/configure_ttl.md
+
   - Reference:
     - reference/index.md
     - LangGraph:
@@ -274,9 +256,20 @@ nav:
       - Environment variables: cloud/reference/env_var.md
 
   - Examples:
+    - agents/run_agents.md
+    - LangGraph basics:
+      -  concepts/why-langgraph.md
+      -  Build a basic chatbot: tutorials/get-started/1-build-basic-chatbot.md
+      -  tutorials/get-started/2-add-tools.md
+      -  tutorials/get-started/3-add-memory.md
+      -  Add human-in-the-loop: tutorials/get-started/4-human-in-the-loop.md
+      -  tutorials/get-started/5-customize-state.md
+      -  tutorials/get-started/6-time-travel.md
+    - Template applications: concepts/template_applications.md  # TODO: make tutorial
     - Agentic RAG: tutorials/rag/langgraph_agentic_rag.ipynb
     - Agent Supervisor: tutorials/multi_agent/agent_supervisor.ipynb
     - SQL agent: tutorials/sql-agent.ipynb
+    - Prebuilt chat UI: agents/ui.md
     - Graph runs in LangSmith: how-tos/run-id-langsmith.ipynb
     - LangGraph Platform:
       - Authentication:
@@ -291,11 +284,12 @@ nav:
         - Integrate LangGraph into a React app: cloud/how-tos/use_stream_react.md
         - Implement generative UI with LangGraph: cloud/how-tos/generative_ui_react.md
 
-  - Resources:
-    - concepts/faq.md
-    - Template applications: concepts/template_applications.md  # TODO: make tutorial
-    - llms.txt: llms-txt-overview.md
+  - Additional resources:
     - agents/prebuilt.md # NOTE: prebuilt.md is auto-generated by `make build-prebuilt`
+    - LangGraph Academy course: https://academy.langchain.com/courses/intro-to-langgraph
+    - Case studies: adopters.md
+    - concepts/faq.md
+    - llms.txt: llms-txt-overview.md
     - Troubleshooting:
         - Errors:
           - troubleshooting/errors/index.md
@@ -306,9 +300,7 @@ nav:
           - troubleshooting/errors/INVALID_CHAT_HISTORY.md
           - troubleshooting/errors/INVALID_LICENSE.md
         - LangGraph Studio: troubleshooting/studio.md
-    - Learn:
-      - LangGraph Academy course: https://academy.langchain.com/courses/intro-to-langgraph
-      - Case studies: adopters.md
+    
 
 markdown_extensions:
   - abbr

docs/uv.lock

@@ -2590,7 +2590,7 @@ wheels = [
 
 [[package]]
 name = "langgraph"
-version = "0.4.7"
+version = "0.5.0rc1"
 source = { editable = "../libs/langgraph" }
 dependencies = [
     { name = "langchain-core" },
@@ -2641,7 +2641,7 @@ dev = [
 
 [[package]]
 name = "langgraph-checkpoint"
-version = "2.0.26"
+version = "2.1.0"
 source = { editable = "../libs/checkpoint" }
 dependencies = [
     { name = "langchain-core" },
@@ -2660,6 +2660,8 @@ dev = [
     { name = "dataclasses-json" },
     { name = "mypy" },
     { name = "numpy" },
+    { name = "pandas" },
+    { name = "pandas-stubs", specifier = ">=2.2.2.240807" },
     { name = "pytest" },
     { name = "pytest-asyncio" },
     { name = "pytest-mock" },
@@ -2892,7 +2894,7 @@ test = [
 
 [[package]]
 name = "langgraph-prebuilt"
-version = "0.2.2"
+version = "0.5.0rc0"
 source = { editable = "../libs/prebuilt" }
 dependencies = [
     { name = "langchain-core" },