x

* docs: Time travel and breakpoints

* fix links

* fix

* edits

* Fix link

* Remove circular redirects

* revert llms.txt

---------

Co-authored-by: Eugene Yurtsev <eyurtsev@gmail.com>

docs/_scripts/notebook_hooks.py

@@ -100,9 +100,9 @@ REDIRECT_MAP = {
     "how-tos/create-react-agent-system-prompt.ipynb": "agents/context.md#prompts",
     "how-tos/create-react-agent-structured-output.ipynb": "agents/agents.md#structured-output",
     # Time-travel
-    "how-tos/human_in_the_loop/edit-graph-state.ipynb": "how-tos/human_in_the_loop/time-travel.ipynb",
+    "how-tos/human_in_the_loop/edit-graph-state.ipynb": "how-tos/human_in_the_loop/time-travel.md",
     # breakpoints
-    "how-tos/human_in_the_loop/dynamic_breakpoints.ipynb": "how-tos/human_in_the_loop/breakpoints.ipynb",
+    "how-tos/human_in_the_loop/dynamic_breakpoints.ipynb": "how-tos/human_in_the_loop/breakpoints.md",
     # misc
     "prebuilt.md": "agents/prebuilt.md",
     "reference/prebuilt.md": "reference/agents.md",

docs/docs/cloud/how-tos/add-human-in-the-loop.md

@@ -1,4 +1,4 @@
-# Human-in-the-loop in LangGraph Server
+# Human-in-the-loop using Server API
 
 To review, edit, and approve tool calls in an agent or workflow, use LangGraph's [human-in-the-loop](../../concepts/human_in_the_loop.md) features.
 

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

@@ -1,10 +1,16 @@
-# Breakpoints
+# Set breakpoints using Server API
 
 [Breakpoints](../../concepts/breakpoints.md) pause graph execution at defined points and let you step through each stage. They use LangGraph's [**persistence layer**](../../concepts/persistence.md), which saves the graph state after each step.
 
-With breakpoints, you can inspect the graph's state and node inputs at any point. Execution pauses **indefinitely** until you resume, as the checkpointer preserves the state.
+With breakpoints, you can inspect the graph's state and node inputs at any point. Execution pauses indefinitely until you resume, as the checkpointer preserves the state.
 
-## Set breakpoints
+!!! tip
+
+    For conceptual information on breakpoints, see [Breakpoints](../../concepts/breakpoints.md).
+
+## Set static breakpoints
+
+Static breakpoints are triggered either before or after a node executes. You can set static breakpoints by specifying `interrupt_before` and `interrupt_after` at compile time or run time.
 
 === "Compile time"
 
@@ -78,10 +84,9 @@ With breakpoints, you can inspect the graph's state and node inputs at any point
         }"
         ```
 
-!!! tip
-
-    This example shows how to add **static** breakpoints. See [this guide](../../how-tos/human_in_the_loop/breakpoints.ipynb) for more options for how to add breakpoints.
+## Example
 
+This example shows how to add **static** breakpoints. See [Use breakpoints](../../how-tos/human_in_the_loop/breakpoints.md) for more options on adding breakpoints.
 
 === "Python"
 
@@ -177,8 +182,4 @@ With breakpoints, you can inspect the graph's state and node inputs at any point
     --data "{
       \"assistant_id\": \"agent\"
     }"
-    ```
-
-## Learn more
-
-- [**LangGraph breakpoints guide**](../../how-tos/human_in_the_loop/breakpoints.ipynb): learn more about adding breakpoints in LangGraph.
+    ```

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

@@ -1,10 +1,8 @@
-# Time travel
+# Time travel using Server API
 
-LangGraph provides [**time travel**](../../concepts/time-travel.md) functionality to **resume execution from a prior checkpoint** — either replaying the same state or modifying it to explore alternatives. In all cases, resuming past execution produces a **new fork** in the history.
+LangGraph provides the [**time travel**](../../concepts/time-travel.md) functionality to resume execution from a prior checkpoint, either replaying the same state or modifying it to explore alternatives. In all cases, resuming past execution produces a new fork in the history.
 
-## Use time travel
-
-To use time-travel in LangGraph:
+To time travel using the LangGraph Server API (via the LangGraph SDK):
 
 1. **Run the graph** with initial inputs using [LangGraph SDK](https://langchain-ai.github.io/langgraph/cloud/reference/sdk/python_sdk_ref/)'s [`client.runs.wait`][langgraph_sdk.client.RunsClient.wait] or [`client.runs.stream`][langgraph_sdk.client.RunsClient.stream] APIs.
 2. **Identify a checkpoint in an existing thread**: Use [`client.threads.get_history`][langgraph_sdk.client.ThreadsClient.get_history] method to retrieve the execution history for a specific `thread_id` and locate the desired `checkpoint_id`.
@@ -12,7 +10,7 @@ To use time-travel in LangGraph:
 3. **(Optional) modify the graph state**: Use the [`client.threads.update_state`][langgraph_sdk.client.ThreadsClient.update_state] method to modify the graph’s state at the checkpoint and resume execution from alternative state.
 4. **Resume execution from the checkpoint**: Use the [`client.runs.wait`][langgraph_sdk.client.RunsClient.wait] or [`client.runs.stream`][langgraph_sdk.client.RunsClient.stream] APIs with an input of `None` and the appropriate `thread_id` and `checkpoint_id`.
 
-## Example
+## Use time travel in a workflow
 
 ??? example "Example graph"
 
@@ -237,4 +235,4 @@ To use time-travel in LangGraph:
 
 ## Learn more
 
-- [**LangGraph time travel guide**](../../how-tos/human_in_the_loop/time-travel.ipynb): learn more about using time travel in LangGraph.
+- [**LangGraph time travel guide**](../../how-tos/human_in_the_loop/time-travel.md): learn more about using time travel in LangGraph.

docs/docs/concepts/breakpoints.md

@@ -5,10 +5,14 @@ search:
 
 # Breakpoints
 
-Breakpoints pause graph execution at defined points and let you step through each stage. They use LangGraph's [**persistence layer**](./persistence.md), which saves the graph state after each step.
+[Breakpoints](../how-tos/human_in_the_loop/breakpoints.md) pause graph execution at defined points and let you step through each stage. They use LangGraph's [**persistence layer**](./persistence.md), which saves the graph state after each step.
 
 With breakpoints, you can inspect the graph's state and node inputs at any point. Execution pauses **indefinitely** until you resume, as the checkpointer preserves the state.
 
 <figure markdown="1">
 ![image](img/breakpoints.png){: style="max-height:400px"}
 <figcaption>An example graph consisting of 3 sequential steps with a breakpoint before step_3. </figcaption> </figure>
+
+!!! tip
+
+    For information on how to use breakpoints, see [Set breakpoints](../how-tos/human_in_the_loop/breakpoints.md) and [Set breakpoints using Server API](../cloud/how-tos/human_in_the_loop_breakpoint.md).

docs/docs/concepts/human_in_the_loop.md

@@ -17,6 +17,10 @@ To review, edit, and approve tool calls in an agent or workflow, [use LangGraph'
 ![image](../concepts/img/human_in_the_loop/tool-call-review.png){: style="max-height:400px"}
 </figure>
 
+!!! tip
+
+    For information on how to use human-in-the-loop, see [Enable human intervention](../how-tos/human_in_the_loop/add-human-in-the-loop.md) and [Human-in-the-loop using Server API](../cloud/how-tos/add-human-in-the-loop.md).
+
 ## Key capabilities
 
 * **Persistent execution state**: LangGraph allows you to pause execution **indefinitely** — for minutes, hours, or even days—until human input is received. This is possible because LangGraph checkpoints the graph state after each step, which allows the system to persist execution context and later resume the workflow, continuing from where it left off. This supports asynchronous human review or input without time constraints.

docs/docs/concepts/persistence.md

@@ -33,7 +33,7 @@ The state of a thread at a particular point in time is called a checkpoint. Chec
 - `metadata`: Metadata associated with this checkpoint.
 - `values`: Values of the state channels at this point in time.
 - `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.
+- `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.md#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.
 
@@ -174,7 +174,7 @@ config = {"configurable": {"thread_id": "1", "checkpoint_id": "0c62ca34-ac19-445
 graph.invoke(None, config=config)
 ```
 
-Importantly, LangGraph knows whether a particular step has been executed previously. If it has, LangGraph simply *re-plays* that particular step in the graph and does not re-execute the step, but only for the steps _before_ the provided `checkpoint_id`. All of the steps _after_ `checkpoint_id` will be executed (i.e., a new fork), even if they have been executed previously. See this [how to guide on time-travel to learn more about replaying](../how-tos/human_in_the_loop/time-travel.ipynb).
+Importantly, LangGraph knows whether a particular step has been executed previously. If it has, LangGraph simply *re-plays* that particular step in the graph and does not re-execute the step, but only for the steps _before_ the provided `checkpoint_id`. All of the steps _after_ `checkpoint_id` will be executed (i.e., a new fork), even if they have been executed previously. See this [how to guide on time-travel to learn more about replaying](../how-tos/human_in_the_loop/time-travel.md).
 
 ![Replay](img/persistence/re_play.png)
 
@@ -224,7 +224,7 @@ The `foo` key (channel) is completely changed (because there is no reducer speci
 
 #### `as_node`
 
-The final thing you can optionally specify when calling `update_state` is `as_node`. If you provided it, the update will be applied as if it came from node `as_node`. If `as_node` is not provided, it will be set to the last node that updated the state, if not ambiguous. The reason this matters is that the next steps to execute depend on the last node to have given an update, so this can be used to control which node executes next. See this [how to guide on time-travel to learn more about forking state](../how-tos/human_in_the_loop/time-travel.ipynb).
+The final thing you can optionally specify when calling `update_state` is `as_node`. If you provided it, the update will be applied as if it came from node `as_node`. If `as_node` is not provided, it will be set to the last node that updated the state, if not ambiguous. The reason this matters is that the next steps to execute depend on the last node to have given an update, so this can be used to control which node executes next. See this [how to guide on time-travel to learn more about forking state](../how-tos/human_in_the_loop/time-travel.md).
 
 ![Update](img/persistence/checkpoints_full_story.jpg)
 
@@ -525,7 +525,7 @@ When running on LangGraph Platform, encryption is automatically enabled whenever
 
 ### Human-in-the-loop
 
-First, checkpointers facilitate [human-in-the-loop workflows](agentic_concepts.md#human-in-the-loop) workflows by allowing humans to inspect, interrupt, and approve graph steps. Checkpointers are needed for these workflows as the human has to be able to view the state of a graph at any point in time, and the graph has to be to resume execution after the human has made any updates to the state. See [these how-to guides](../how-tos/human_in_the_loop/breakpoints.ipynb) for concrete examples.
+First, checkpointers facilitate [human-in-the-loop workflows](agentic_concepts.md#human-in-the-loop) workflows by allowing humans to inspect, interrupt, and approve graph steps. Checkpointers are needed for these workflows as the human has to be able to view the state of a graph at any point in time, and the graph has to be to resume execution after the human has made any updates to the state. See [these how-to guides](../how-tos/human_in_the_loop/breakpoints.md) for concrete examples.
 
 ### Memory
 

docs/docs/concepts/time-travel.md

@@ -7,9 +7,12 @@ search:
 
 When working with non-deterministic systems that make model-based decisions (e.g., agents powered by LLMs), it can be useful to examine their decision-making process in detail:
 
-1. 🤔 **Understand Reasoning**: Analyze the steps that led to a successful result.
-2. 🐞 **Debug Mistakes**: Identify where and why errors occurred.
-3. 🔍 **Explore Alternatives**: Test different paths to uncover better solutions.
+1. 🤔 **Understand reasoning**: Analyze the steps that led to a successful result.
+2. 🐞 **Debug mistakes**: Identify where and why errors occurred.
+3. 🔍 **Explore alternatives**: Test different paths to uncover better solutions.
 
+LangGraph provides [time travel functionality](../how-tos/human_in_the_loop/time-travel.md) to support these use cases. Specifically, you can resume execution from a prior checkpoint — either replaying the same state or modifying it to explore alternatives. In all cases, resuming past execution produces a new fork in the history.
 
-LangGraph provides **time travel** functionality to support these use cases. Specifically, you can **resume execution from a prior checkpoint** — either replaying the same state or modifying it to explore alternatives. In all cases, resuming past execution produces a **new fork** in the history.
+!!! tip
+
+    For information on how to use time travel, see [Use time travel](../how-tos/human_in_the_loop/time-travel.md) and [Time travel using Server API](../cloud/how-tos/human_in_the_loop_time_travel.md).

docs/docs/how-tos/human_in_the_loop/add-human-in-the-loop.md

@@ -883,7 +883,7 @@ def node_in_parent_graph(state: State):
 
 ### Using multiple interrupts
 
-Using multiple interrupts within a **single** node can be helpful for patterns like [validating human input](../how-tos/human_in_the_loop/add-human-in-the-loop.md#validate-human-input). However, using multiple interrupts in the same node can lead to unexpected behavior if not handled carefully.
+Using multiple interrupts within a **single** node can be helpful for patterns like [validating human input](#validate-human-input). However, using multiple interrupts in the same node can lead to unexpected behavior if not handled carefully.
 
 When a node contains multiple interrupt calls, LangGraph keeps a list of resume values specific to the task executing the node. Whenever execution resumes, it starts at the beginning of the node. For each interrupt encountered, LangGraph checks if a matching value exists in the task's resume list. Matching is **strictly index-based**, so the order of interrupt calls within the node is critical.
 

docs/docs/how-tos/human_in_the_loop/breakpoints.md

@@ -0,0 +1,342 @@
+# Set breakpoints
+
+There are two places where you can set breakpoints:
+
+1. **Before** or **after** a node executes by setting breakpoints at **compile time** or **run time**. We call these [**static breakpoints**](#static-breakpoints).
+2. **Inside** a node using the `NodeInterrupt` exception. We call these [**dynamic breakpoints**](#dynamic-breakpoints).
+
+To use breakpoints, you will need to:
+
+1. [**Specify a checkpointer**](../../concepts/persistence.md#checkpoints) to save the graph state after each step.
+2. **Set breakpoints** to specify where execution should pause.
+3. **Run the graph** with a [**thread ID**](../../concepts/persistence.md#threads) to pause execution at the breakpoint.
+4. **Resume execution** using `invoke`/`ainvoke`/`stream`/`astream` passing a `None` as the argument for the inputs.
+
+!!! tip
+
+    For a conceptual overview of breakpoints, see [Breakpoints](../../concepts/breakpoints.md).
+
+## Static breakpoints
+
+Static breakpoints are triggered either before or after a node executes. You can set static breakpoints by specifying `interrupt_before` and `interrupt_after` at compile time or run time.
+
+Static breakpoints can be especially useful for debugging if you want to step through the graph execution one
+node at a time or if you want to pause the graph execution at specific nodes.
+
+=== "Compile time"
+
+    ```python
+    # highlight-next-line
+    graph = graph_builder.compile( # (1)!
+        # highlight-next-line
+        interrupt_before=["node_a"], # (2)!
+        # highlight-next-line
+        interrupt_after=["node_b", "node_c"], # (3)!
+        checkpointer=checkpointer, # (4)!
+    )
+
+    config = {
+        "configurable": {
+            "thread_id": "some_thread"
+        }
+    }
+
+    # Run the graph until the breakpoint
+    graph.invoke(inputs, config=thread_config) # (5)!
+
+    # Resume the graph
+    graph.invoke(None, config=thread_config) # (6)!
+    ```
+
+    1. The breakpoints are set during `compile` time.
+    2. `interrupt_before` specifies the nodes where execution should pause before the node is executed.
+    3. `interrupt_after` specifies the nodes where execution should pause after the node is executed.
+    4. A checkpointer is required to enable breakpoints.
+    5. The graph is run until the first breakpoint is hit.
+    6. The graph is resumed by passing in `None` for the input. This will run the graph until the next breakpoint is hit.
+
+=== "Run time"
+
+    ```python
+    # highlight-next-line
+    graph.invoke( # (1)!
+        inputs, 
+        # highlight-next-line
+        interrupt_before=["node_a"], # (2)!
+        # highlight-next-line
+        interrupt_after=["node_b", "node_c"] # (3)!
+        config={
+            "configurable": {"thread_id": "some_thread"}
+        }, 
+    )
+
+    config = {
+        "configurable": {
+            "thread_id": "some_thread"
+        }
+    }
+
+    # Run the graph until the breakpoint
+    graph.invoke(inputs, config=config) # (4)!
+
+    # Resume the graph
+    graph.invoke(None, config=config) # (5)!
+    ```
+
+    1. `graph.invoke` is called with the `interrupt_before` and `interrupt_after` parameters. This is a run-time configuration and can be changed for every invocation.
+    2. `interrupt_before` specifies the nodes where execution should pause before the node is executed.
+    3. `interrupt_after` specifies the nodes where execution should pause after the node is executed.
+    4. The graph is run until the first breakpoint is hit.
+    5. The graph is resumed by passing in `None` for the input. This will run the graph until the next breakpoint is hit.
+
+    !!! note
+
+        You cannot set static breakpoints at runtime for **sub-graphs**.
+        If you have a sub-graph, you must set the breakpoints at compilation time.
+
+??? example "Setting static breakpoints"
+
+    ```python
+    from IPython.display import Image, display
+    from typing_extensions import TypedDict
+    
+    from langgraph.checkpoint.memory import InMemorySaver 
+    from langgraph.graph import StateGraph, START, END
+    
+    
+    class State(TypedDict):
+        input: str
+    
+    
+    def step_1(state):
+        print("---Step 1---")
+        pass
+    
+    
+    def step_2(state):
+        print("---Step 2---")
+        pass
+    
+    
+    def step_3(state):
+        print("---Step 3---")
+        pass
+    
+    
+    builder = StateGraph(State)
+    builder.add_node("step_1", step_1)
+    builder.add_node("step_2", step_2)
+    builder.add_node("step_3", step_3)
+    builder.add_edge(START, "step_1")
+    builder.add_edge("step_1", "step_2")
+    builder.add_edge("step_2", "step_3")
+    builder.add_edge("step_3", END)
+    
+    # Set up a checkpointer 
+    checkpointer = InMemorySaver() # (1)!
+    
+    graph = builder.compile(
+        checkpointer=checkpointer, # (2)!
+        interrupt_before=["step_3"] # (3)!
+    )
+    
+    # View
+    display(Image(graph.get_graph().draw_mermaid_png()))
+    
+    
+    # Input
+    initial_input = {"input": "hello world"}
+    
+    # Thread
+    thread = {"configurable": {"thread_id": "1"}}
+    
+    # Run the graph until the first interruption
+    for event in graph.stream(initial_input, thread, stream_mode="values"):
+        print(event)
+        
+    # This will run until the breakpoint
+    # You can get the state of the graph at this point
+    print(graph.get_state(config))
+    
+    # You can continue the graph execution by passing in `None` for the input
+    for event in graph.stream(None, thread, stream_mode="values"):
+        print(event)
+    ```
+
+## Dynamic breakpoints
+
+Use dynamic breakpoints if you need to interrupt the graph from inside a given node based on a condition.
+
+```python
+from langgraph.errors import NodeInterrupt
+
+def step_2(state: State) -> State:
+    # highlight-next-line
+    if len(state["input"]) > 5:
+        # highlight-next-line
+        raise NodeInterrupt( # (1)!
+            f"Received input that is longer than 5 characters: {state['foo']}"
+        )
+    return state
+```
+
+1. raise NodeInterrupt exception based on a some condition. In this example, we create a dynamic breakpoint if the length of the attribute `input` is longer than 5 characters.
+
+<details class="example"><summary>Using dynamic breakpoints</summary>
+
+```python
+from typing_extensions import TypedDict
+from IPython.display import Image, display
+
+from langgraph.graph import StateGraph, START, END
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.errors import NodeInterrupt
+
+
+class State(TypedDict):
+    input: str
+
+
+def step_1(state: State) -> State:
+    print("---Step 1---")
+    return state
+
+
+def step_2(state: State) -> State:
+    # Let's optionally raise a NodeInterrupt
+    # if the length of the input is longer than 5 characters
+    if len(state["input"]) > 5:
+        raise NodeInterrupt(
+            f"Received input that is longer than 5 characters: {state['input']}"
+        )
+    print("---Step 2---")
+    return state
+
+
+def step_3(state: State) -> State:
+    print("---Step 3---")
+    return state
+
+
+builder = StateGraph(State)
+builder.add_node("step_1", step_1)
+builder.add_node("step_2", step_2)
+builder.add_node("step_3", step_3)
+builder.add_edge(START, "step_1")
+builder.add_edge("step_1", "step_2")
+builder.add_edge("step_2", "step_3")
+builder.add_edge("step_3", END)
+
+# Set up memory
+memory = MemorySaver()
+
+# Compile the graph with memory
+graph = builder.compile(checkpointer=memory)
+
+# View
+display(Image(graph.get_graph().draw_mermaid_png()))
+```
+
+First, let's run the graph with an input that <= 5 characters long. This should safely ignore the interrupt condition we defined and return the original input at the end of the graph execution.
+
+```python
+initial_input = {"input": "hello"}
+thread_config = {"configurable": {"thread_id": "1"}}
+
+for event in graph.stream(initial_input, thread_config, stream_mode="values"):
+    print(event)
+```
+
+If we inspect the graph at this point, we can see that there are no more tasks left to run and that the graph indeed finished execution.
+
+```python
+state = graph.get_state(thread_config)
+print(state.next)
+print(state.tasks)
+```
+
+Now, let's run the graph with an input that's longer than 5 characters. This should trigger the dynamic interrupt we defined via raising a `NodeInterrupt` error inside the `step_2` node.
+
+```python
+initial_input = {"input": "hello world"}
+thread_config = {"configurable": {"thread_id": "2"}}
+
+# Run the graph until the first interruption
+for event in graph.stream(initial_input, thread_config, stream_mode="values"):
+    print(event)
+```
+
+We can see that the graph now stopped while executing `step_2`. If we inspect the graph state at this point, we can see the information on what node is set to execute next (`step_2`), as well as what node raised the interrupt (also `step_2`), and additional information about the interrupt.
+
+```python
+state = graph.get_state(thread_config)
+print(state.next)
+print(state.tasks)
+```
+
+If we try to resume the graph from the breakpoint, we will simply interrupt again as our inputs & graph state haven't changed.
+
+```python
+# NOTE: to resume the graph from a dynamic interrupt we use the same syntax as with regular interrupts -- we pass None as the input
+for event in graph.stream(None, thread_config, stream_mode="values"):
+    print(event)
+```
+
+```python
+state = graph.get_state(thread_config)
+print(state.next)
+print(state.tasks)
+```
+
+</details>
+
+## Use with subgraphs
+
+To add breakpoints to subgraph either:
+
+* Define [static breakpoints](#static-breakpoints) by specifying them when **compiling** the subgraph.
+* Define [dynamic breakpoints](#dynamic-breakpoints).
+
+<details class="example"><summary>Add breakpoints to subgraphs</summary>
+
+```python
+from typing_extensions import TypedDict
+
+from langgraph.graph import START, StateGraph
+from langgraph.checkpoint.memory import InMemorySaver
+from langgraph.types import interrupt
+
+
+class State(TypedDict):
+    foo: str
+
+
+def subgraph_node_1(state: State):
+    return {"foo": state["foo"]}
+
+
+subgraph_builder = StateGraph(State)
+subgraph_builder.add_node(subgraph_node_1)
+subgraph_builder.add_edge(START, "subgraph_node_1")
+
+subgraph = subgraph_builder.compile(interrupt_before=["subgraph_node_1"])
+
+builder = StateGraph(State)
+builder.add_node("node_1", subgraph)  # directly include subgraph as a node
+builder.add_edge(START, "node_1")
+
+checkpointer = InMemorySaver()
+graph = builder.compile(checkpointer=checkpointer)
+
+config = {"configurable": {"thread_id": "1"}}
+
+graph.invoke({"foo": ""}, config)
+
+# Fetch state including subgraph state.
+print(graph.get_state(config, subgraphs=True).tasks[0].state)
+
+# resume the subgraph
+graph.invoke(None, config)
+```
+
+</details> 

docs/docs/how-tos/human_in_the_loop/time-travel.md

@@ -0,0 +1,190 @@
+# Use time-travel
+
+To use [time-travel](../../concepts/time-travel.md) in LangGraph:
+
+1. [Run the graph](#1-run-the-graph) with initial inputs using [`invoke`][langgraph.graph.state.CompiledStateGraph.invoke] or [`stream`][langgraph.graph.state.CompiledStateGraph.stream] methods.
+2. [Identify a checkpoint in an existing thread](#2-identify-a-checkpoint): Use the [`get_state_history()`][langgraph.graph.state.CompiledStateGraph.get_state_history] method to retrieve the execution history for a specific `thread_id` and locate the desired `checkpoint_id`.  
+   Alternatively, set a [breakpoint](../../concepts/breakpoints.md) before the node(s) where you want execution to pause. You can then find the most recent checkpoint recorded up to that breakpoint.
+3. [Update the graph state (optional)](#3-update-the-state-optional): Use the [`update_state`][langgraph.graph.state.CompiledStateGraph.update_state] method to modify the graph's state at the checkpoint and resume execution from alternative state.
+4. [Resume execution from the checkpoint](#4-resume-execution-from-the-checkpoint): Use the `invoke` or `stream` methods with an input of `None` and a configuration containing the appropriate `thread_id` and `checkpoint_id`.
+
+!!! tip
+
+    For a conceptual overview of time-travel, see [Time travel](../../concepts/time-travel.md).
+
+## In a workflow
+
+This example builds a simple LangGraph workflow that generates a joke topic and writes a joke using an LLM. It demonstrates how to run the graph, retrieve past execution checkpoints, optionally modify the state, and resume execution from a chosen checkpoint to explore alternate outcomes.
+
+### Setup
+
+First we need to install the packages required
+
+```python
+%%capture --no-stderr
+%pip install --quiet -U langgraph langchain_anthropic
+```
+
+Next, we need to set API keys for Anthropic (the LLM we will use)
+
+```python
+import getpass
+import os
+
+
+def _set_env(var: str):
+    if not os.environ.get(var):
+        os.environ[var] = getpass.getpass(f"{var}: ")
+
+
+_set_env("ANTHROPIC_API_KEY")
+```
+
+<div class="admonition tip">
+    <p class="admonition-title">Set up <a href="https://smith.langchain.com">LangSmith</a> for LangGraph development</p>
+    <p style="padding-top: 5px;">
+        Sign up for LangSmith to quickly spot issues and improve the performance of your LangGraph projects. LangSmith lets you use trace data to debug, test, and monitor your LLM apps built with LangGraph — read more about how to get started <a href="https://docs.smith.langchain.com">here</a>. 
+    </p>
+</div>
+
+```python
+import uuid
+
+from typing_extensions import TypedDict, NotRequired
+from langgraph.graph import StateGraph, START, END
+from langchain.chat_models import init_chat_model
+from langgraph.checkpoint.memory import InMemorySaver
+
+
+class State(TypedDict):
+    topic: NotRequired[str]
+    joke: NotRequired[str]
+
+
+llm = init_chat_model(
+    "anthropic:claude-3-7-sonnet-latest",
+    temperature=0,
+)
+
+
+def generate_topic(state: State):
+    """LLM call to generate a topic for the joke"""
+    msg = llm.invoke("Give me a funny topic for a joke")
+    return {"topic": msg.content}
+
+
+def write_joke(state: State):
+    """LLM call to write a joke based on the topic"""
+    msg = llm.invoke(f"Write a short joke about {state['topic']}")
+    return {"joke": msg.content}
+
+
+# Build workflow
+workflow = StateGraph(State)
+
+# Add nodes
+workflow.add_node("generate_topic", generate_topic)
+workflow.add_node("write_joke", write_joke)
+
+# Add edges to connect nodes
+workflow.add_edge(START, "generate_topic")
+workflow.add_edge("generate_topic", "write_joke")
+workflow.add_edge("write_joke", END)
+
+# Compile
+checkpointer = InMemorySaver()
+graph = workflow.compile(checkpointer=checkpointer)
+graph
+```
+
+### 1. Run the graph
+
+```python
+config = {
+    "configurable": {
+        "thread_id": uuid.uuid4(),
+    }
+}
+state = graph.invoke({}, config)
+
+print(state["topic"])
+print()
+print(state["joke"])
+```
+
+**Output:**
+```
+How about "The Secret Life of Socks in the Dryer"? You know, exploring the mysterious phenomenon of how socks go into the laundry as pairs but come out as singles. Where do they go? Are they starting new lives elsewhere? Is there a sock paradise we don't know about? There's a lot of comedic potential in the everyday mystery that unites us all!
+
+# The Secret Life of Socks in the Dryer
+
+I finally discovered where all my missing socks go after the dryer. Turns out they're not missing at all—they've just eloped with someone else's socks from the laundromat to start new lives together.
+
+My blue argyle is now living in Bermuda with a red polka dot, posting vacation photos on Sockstagram and sending me lint as alimony.
+```
+
+### 2. Identify a checkpoint
+
+```python
+# The states are returned in reverse chronological order.
+states = list(graph.get_state_history(config))
+
+for state in states:
+    print(state.next)
+    print(state.config["configurable"]["checkpoint_id"])
+    print()
+```
+
+**Output:**
+```
+()
+1f02ac4a-ec9f-6524-8002-8f7b0bbeed0e
+
+('write_joke',)
+1f02ac4a-ce2a-6494-8001-cb2e2d651227
+
+('generate_topic',)
+1f02ac4a-a4e0-630d-8000-b73c254ba748
+
+('__start__',)
+1f02ac4a-a4dd-665e-bfff-e6c8c44315d9
+```
+
+```python
+# This is the state before last (states are listed in chronological order)
+selected_state = states[1]
+print(selected_state.next)
+print(selected_state.values)
+```
+
+**Output:**
+```
+('write_joke',)
+{'topic': 'How about "The Secret Life of Socks in the Dryer"? You know, exploring the mysterious phenomenon of how socks go into the laundry as pairs but come out as singles. Where do they go? Are they starting new lives elsewhere? Is there a sock paradise we don\\'t know about? There\\'s a lot of comedic potential in the everyday mystery that unites us all!'}
+```
+
+### 3. Update the state (optional)
+
+`update_state` will create a new checkpoint. The new checkpoint will be associated with the same thread, but a new checkpoint ID.
+
+```python
+new_config = graph.update_state(selected_state.config, values={"topic": "chickens"})
+print(new_config)
+```
+
+**Output:**
+```
+{'configurable': {'thread_id': 'c62e2e03-c27b-4cb6-8cea-ea9bfedae006', 'checkpoint_ns': '', 'checkpoint_id': '1f02ac4a-ecee-600b-8002-a1d21df32e4c'}}
+```
+
+### 4. Resume execution from the checkpoint
+
+```python
+graph.invoke(None, new_config)
+```
+
+**Output:**
+```python
+{'topic': 'chickens',
+ 'joke': 'Why did the chicken join a band?\n\nBecause it had excellent drumsticks!'}
+``` 

docs/docs/tutorials/rag/langgraph_adaptive_rag.ipynb

@@ -336,7 +336,8 @@
     "rag_chain = prompt | llm | StrOutputParser()\n",
     "\n",
     "# Run\n",
-    "generation = rag_chain.invoke({\"context\": docs, \"question\": question})\n",
+    "docs_txt = format_docs(docs)\n",
+    "generation = rag_chain.invoke({\"context\": docs_txt, \"question\": question})\n",
     "print(generation)"
    ]
   },
@@ -625,7 +626,8 @@
     "    documents = state[\"documents\"]\n",
     "\n",
     "    # RAG generation\n",
-    "    generation = rag_chain.invoke({\"context\": documents, \"question\": question})\n",
+    "    docs_txt = format_docs(documents)\n",
+    "    generation = rag_chain.invoke({\"context\": docs_txt, \"question\": question})\n",
     "    return {\"documents\": documents, \"question\": question, \"generation\": generation}\n",
     "\n",
     "\n",

docs/mkdocs.yml

@@ -89,7 +89,7 @@ plugins:
                 - "!^_"
 
 nav:
-  - Get started:
+  - Guides:
     - index.md
     - Quickstarts:
       - Agent: agents/agents.md
@@ -114,15 +114,23 @@ nav:
         - Runtime: concepts/pregel.md
         - Functional API: concepts/functional_api.md
     - Core capabilities:
-      - Streaming: concepts/streaming.md
+      - Streaming:
+        - Overview: concepts/streaming.md
+        - Stream outputs: how-tos/streaming.md
       - Persistence: concepts/persistence.md
       - Durable execution: concepts/durable_execution.md
       - Memory: concepts/memory.md
-      - Tools: concepts/tools.md
+      - Tools:
+        - Overview: concepts/tools.md
+        - Call tools: how-tos/tool-calling.md
       - Human-in-the-loop: concepts/human_in_the_loop.md
       - Breakpoints: concepts/breakpoints.md
-      - Time travel: concepts/time-travel.md
+      - Time travel:
+        - Overview: concepts/time-travel.md
+        - Use time-travel: how-tos/human_in_the_loop/time-travel.md
       - Multi-agent: concepts/multi_agent.md
+      - MCP:
+          - Use MCP: agents/mcp.md
     - Platform capabilities:
       - LangGraph Platform:
           - Overview: concepts/langgraph_platform.md
@@ -150,28 +158,28 @@ nav:
           - 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
-    
+      - Use the API:
+        - Use RemoteGraph: how-tos/use-remote-graph.md
+        - Human in the loop: cloud/how-tos/add-human-in-the-loop.md
+        - Breakpoints: cloud/how-tos/human_in_the_loop_breakpoint.md
+        - Timetravel: cloud/how-tos/human_in_the_loop_time_travel.md
+        - Streaming: cloud/how-tos/streaming.md
+        - MCP: concepts/server-mcp.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:
       - Add context: agents/context.md
     - Memory:
       - Add memory: how-tos/memory/add-memory.md
     - Human-in-the-loop:
       - 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
+      - Set breakpoints: how-tos/human_in_the_loop/breakpoints.md
     - Tools:
       - Call tools: how-tos/tool-calling.md
     - Subgraphs:
@@ -179,9 +187,6 @@ nav:
     - Multi-agent:
       - Prebuilt implementation: agents/multi-agent.md
       - Custom implementation: how-tos/multi_agent.ipynb
-    - MCP:
-      - Use MCP: agents/mcp.md
-      - Server API: concepts/server-mcp.md
     - Evaluation:
         - Basic implementation: agents/evals.md
     - Deployment:
@@ -191,7 +196,7 @@ nav:
         - Use pyproject.toml: cloud/deployment/setup_pyproject.md
         - Use JavaScript: cloud/deployment/setup_javascript.md
         - Use custom Docker: cloud/deployment/custom_docker.md
-        - Rebuild graph at runtime: cloud/deployment/graph_rebuild.md
+        - Rebuild graph at rutime: cloud/deployment/graph_rebuild.md
       - Deploy to production:
          - Cloud SaaS: cloud/deployment/cloud.md
          - Self-Hosted Data Plane: cloud/deployment/self_hosted_data_plane.md
@@ -274,7 +279,6 @@ nav:
         - tutorials/auth/getting_started.md
         - tutorials/auth/resource_auth.md
         - tutorials/auth/add_auth_server.md
-      - Use RemoteGraph: how-tos/use-remote-graph.md
       - Deploy CrewAI, AutoGen, and other frameworks: how-tos/autogen-langgraph-platform.ipynb
         # combine with how-tos/autogen-integration.ipynb
       - Front-end and generative UI:

examples/human_in_the_loop/breakpoints.ipynb

@@ -1,33 +1 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "ac22b8de",
-   "metadata": {},
-   "source": [
-    "This file has been moved to https://github.com/langchain-ai/langgraph/blob/main/docs/docs/how-tos/human_in_the_loop/breakpoints.ipynb"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.11.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
+