{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ee54cde3-7e4d-43f4-b921-e7141ea0f19e",
   "metadata": {},
   "source": [
    "# How to add dynamic breakpoints"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "607849c6-4b8c-4e06-ad9c-758bb5a08e86",
   "metadata": {},
   "source": [
    "Human-in-the-loop (HIL) interactions are crucial for [agentic systems](https://langchain-ai.github.io/langgraph/concepts/agentic_concepts/#human-in-the-loop). [Breakpoints](https://langchain-ai.github.io/langgraph/concepts/low_level/#breakpoints) are a common HIL interaction pattern, allowing the graph to stop at specific steps and seek human approval before proceeding (e.g., for sensitive actions).\n",
    "\n",
    "In LangGraph you can add breakpoints before / after a node is executed. But oftentimes it may be helpful to **dynamically** interrupt the graph from inside a given node based on some condition. When doing so, it may also be helpful to include information about **why** that interrupt was raised.\n",
    "\n",
    "This guide shows how you can dynamically interrupt the graph using `NodeInterrupt` -- a special exception that can be raised from inside a node. Let's see it in action!\n",
    "\n",
    "## Setup\n",
    "\n",
    "First, let's install the required packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2013d058-c245-498e-ba05-5af99b9b8a1b",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture --no-stderr\n",
    "%pip install -U langgraph"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9f9574b",
   "metadata": {},
   "source": [
    "<div class=\"admonition tip\">\n",
    "    <p class=\"admonition-title\">Set up <a href=\"https://smith.langchain.com\">LangSmith</a> for LangGraph development</p>\n",
    "    <p style=\"padding-top: 5px;\">\n",
    "        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>. \n",
    "    </p>\n",
    "</div>    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9aa244f-1dd9-450e-9526-b1a28b30f84f",
   "metadata": {},
   "source": [
    "## Define the graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "9a14c8b2-5c25-4201-93ea-e5358ee99bcb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/jpeg": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from typing import TypedDict\n",
    "from IPython.display import Image, display\n",
    "\n",
    "from langgraph.graph import StateGraph, START, END\n",
    "from langgraph.checkpoint.memory import MemorySaver\n",
    "from langgraph.errors import NodeInterrupt\n",
    "\n",
    "\n",
    "class State(TypedDict):\n",
    "    input: str\n",
    "\n",
    "\n",
    "def step_1(state: State) -> State:\n",
    "    print(\"---Step 1---\")\n",
    "    return state\n",
    "\n",
    "\n",
    "def step_2(state: State) -> State:\n",
    "    # Let's optionally raise a NodeInterrupt\n",
    "    # if the length of the input is longer than 5 characters\n",
    "    if len(state['input']) > 5:\n",
    "        raise NodeInterrupt(f\"Received input that is longer than 5 characters: {state['input']}\")\n",
    "    \n",
    "    print(\"---Step 2---\")\n",
    "    return state\n",
    "\n",
    "def step_3(state: State) -> State:\n",
    "    print(\"---Step 3---\")\n",
    "    return state\n",
    "\n",
    "\n",
    "builder = StateGraph(State)\n",
    "builder.add_node(\"step_1\", step_1)\n",
    "builder.add_node(\"step_2\", step_2)\n",
    "builder.add_node(\"step_3\", step_3)\n",
    "builder.add_edge(START, \"step_1\")\n",
    "builder.add_edge(\"step_1\", \"step_2\")\n",
    "builder.add_edge(\"step_2\", \"step_3\")\n",
    "builder.add_edge(\"step_3\", END)\n",
    "\n",
    "# Set up memory\n",
    "memory = MemorySaver()\n",
    "\n",
    "# Compile the graph with memory\n",
    "graph = builder.compile(checkpointer=memory)\n",
    "\n",
    "# View\n",
    "display(Image(graph.get_graph().draw_mermaid_png()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad5521e1-0e58-42c5-9282-ff96f24ee6f6",
   "metadata": {},
   "source": [
    "## Run the graph with dynamic interrupt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83692c63-5c65-4562-9c65-5ad1935e339f",
   "metadata": {},
   "source": [
    "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b2d281f1-3349-4378-8918-7665fa7a7457",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'input': 'hello'}\n",
      "---Step 1---\n",
      "{'input': 'hello'}\n",
      "---Step 2---\n",
      "{'input': 'hello'}\n",
      "---Step 3---\n",
      "{'input': 'hello'}\n"
     ]
    }
   ],
   "source": [
    "initial_input = {\"input\": \"hello\"}\n",
    "thread_config = {\"configurable\": {\"thread_id\": \"1\"}}\n",
    "\n",
    "for event in graph.stream(initial_input, thread_config, stream_mode=\"values\"):\n",
    "    print(event)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b66b926-47eb-401b-b37b-d80269d7214c",
   "metadata": {},
   "source": [
    "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "4eac1455-e7ef-4a32-8c14-0d5789409689",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "()\n",
      "()\n"
     ]
    }
   ],
   "source": [
    "state = graph.get_state(thread_config)\n",
    "print(state.next)\n",
    "print(state.tasks)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "f8e03817-2135-4fb3-b881-fd6d2c378ccf",
   "metadata": {},
   "source": [
    "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c06192ad-13a4-4d2e-8e30-f1c08578fe77",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'input': 'hello world'}\n",
      "---Step 1---\n",
      "{'input': 'hello world'}\n"
     ]
    }
   ],
   "source": [
    "initial_input = {\"input\": \"hello world\"}\n",
    "thread_config = {\"configurable\": {\"thread_id\": \"2\"}}\n",
    "\n",
    "# Run the graph until the first interruption\n",
    "for event in graph.stream(initial_input, thread_config, stream_mode=\"values\"):\n",
    "    print(event)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "173fd4f1-db97-44bb-a9e5-435ed042e3a3",
   "metadata": {},
   "source": [
    "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "2058593c-178e-4a23-a4c4-860d4a9c2198",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('step_2',)\n",
      "(PregelTask(id='365d4518-bcff-5abd-8ef5-8a0de7f510b0', name='step_2', error=None, interrupts=(Interrupt(value='Received input that is longer than 5 characters: hello world', when='during'),)),)\n"
     ]
    }
   ],
   "source": [
    "state = graph.get_state(thread_config)\n",
    "print(state.next)\n",
    "print(state.tasks)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc36d1be-ae2e-49c8-a17f-2b27be09618a",
   "metadata": {},
   "source": [
    "If we try to resume the graph from the breakpoint, we will simply interrupt again as our inputs & graph state haven't changed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "872e7a69-9784-4f81-90c6-6b6af2fa6480",
   "metadata": {},
   "outputs": [],
   "source": [
    "# NOTE: to resume the graph from a dynamic interrupt we use the same syntax as with regular interrupts -- we pass None as the input\n",
    "for event in graph.stream(None, thread_config, stream_mode=\"values\"):\n",
    "    print(event)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3275f899-7039-4029-8814-0bb5c33fabfe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('step_2',)\n",
      "(PregelTask(id='365d4518-bcff-5abd-8ef5-8a0de7f510b0', name='step_2', error=None, interrupts=(Interrupt(value='Received input that is longer than 5 characters: hello world', when='during'),)),)\n"
     ]
    }
   ],
   "source": [
    "state = graph.get_state(thread_config)\n",
    "print(state.next)\n",
    "print(state.tasks)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5862dea-2af2-48cb-9889-979b6c6af6aa",
   "metadata": {},
   "source": [
    "## Update the graph state"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8724ef6-877a-44b9-b96a-ae81efa2d9e4",
   "metadata": {},
   "source": [
    "To get around it, we can do several things. \n",
    "\n",
    "First, we could simply run the graph on a different thread with a shorter input, like we did in the beginning. Alternatively, if we want to resume the graph execution from the breakpoint, we can update the state to have an input that's shorter than 5 characters (the condition for our interrupt)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "2ba8dc8d-b90e-45f5-92cd-2192fc66f270",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---Step 2---\n",
      "{'input': 'foo'}\n",
      "---Step 3---\n",
      "{'input': 'foo'}\n",
      "()\n",
      "{'input': 'foo'}\n"
     ]
    }
   ],
   "source": [
    "# NOTE: this update will be applied as of the last successful node before the interrupt, i.e. `step_1`, right before the node with an interrupt\n",
    "graph.update_state(config=thread_config, values={\"input\": \"foo\"})\n",
    "for event in graph.stream(None, thread_config, stream_mode=\"values\"):\n",
    "    print(event)\n",
    "\n",
    "state = graph.get_state(thread_config)\n",
    "print(state.next)\n",
    "print(state.values)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f16980e-aef4-45c9-85eb-955568a93c5b",
   "metadata": {},
   "source": [
    "You can also update the state **as node `step_2`** (interrupted node) which would skip over that node altogether"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "9a48e564-d979-4ac2-b815-c667345a9f07",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'input': 'hello world'}\n",
      "---Step 1---\n",
      "{'input': 'hello world'}\n"
     ]
    }
   ],
   "source": [
    "initial_input = {\"input\": \"hello world\"}\n",
    "thread_config = {\"configurable\": {\"thread_id\": \"3\"}}\n",
    "\n",
    "# Run the graph until the first interruption\n",
    "for event in graph.stream(initial_input, thread_config, stream_mode=\"values\"):\n",
    "    print(event)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "17f973ab-00ce-4f16-a452-641e76625fde",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---Step 3---\n",
      "{'input': 'hello world'}\n",
      "()\n",
      "{'input': 'hello world'}\n"
     ]
    }
   ],
   "source": [
    "# NOTE: this update will skip the node `step_2` altogether\n",
    "graph.update_state(config=thread_config, values=None, as_node=\"step_2\")\n",
    "for event in graph.stream(None, thread_config, stream_mode=\"values\"):\n",
    "    print(event)\n",
    "\n",
    "state = graph.get_state(thread_config)\n",
    "print(state.next)\n",
    "print(state.values)"
   ]
  }
 ],
 "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
}