remove dupe

Author: lnhsingh

src/oss/add-human-in-the-loop.mdx

@@ -1665,169 +1665,6 @@ You can use [LangGraph Studio](/langgraph-platform/langgraph-studio) to debug yo
 LangGraph Studio is free with [locally deployed applications](/oss/local-server) using `langgraph dev`.
 :::
 
-## Debug with interrupts
-
-To debug and test a graph, use [static interrupts](/oss/human-in-the-loop#key-capabilities) (also known as static breakpoints) to step through the graph execution one node at a time or to pause the graph execution at specific nodes. Static interrupts are triggered at defined points either before or after a node executes. You can set static interrupts by specifying `interrupt_before` and `interrupt_after` at compile time or run time.
-
-<Warning>
-  Static interrupts are **not** recommended for human-in-the-loop workflows. Use [dynamic interrupts](#pause-using-interrupt) instead.
-</Warning>
-
-<Tabs>
-  <Tab title="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.
-
-  </Tab>
-  <Tab title="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.
-    </Note>
-
-  </Tab>
-</Tabs>
-
-<Accordion title="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)
-  ```
-
-</Accordion>
-
-### Use static interrupts in LangGraph Studio
-
-You can use [LangGraph Studio](/langgraph-platform/langgraph-studio) to debug your graph. You can set static breakpoints in the UI and then run the graph. You can also use the UI to inspect the graph state at any point in the execution.
-
-![image](/oss/images/static-interrupt.png)
-
-LangGraph Studio is free with [locally deployed applications](/langgraph-platform/local-server) using `langgraph dev`.
-
 ## Considerations
 
 When using human-in-the-loop, there are some considerations to keep in mind.