{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# How to manage state in subgraphs\n",
    "\n",
    "For more complex systems, sub-graphs are a useful design principle. Sub-graphs allow you to create and manage different states in different parts of your graph. This allows you build things like [multi-agent teams](https://langchain-ai.github.io/langgraph/tutorials/multi_agent/hierarchical_agent_teams/), where each team can track its own separate state.\n",
    "\n",
    "In this how-to guide we will cover how to manage the persisted state in subgraphs. This will enable a lot of the human-in-the-loop interaction patterns.\n",
    "\n",
    "## Setup\n",
    "\n",
    "First we need to install the packages required"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture --no-stderr\n",
    "%pip install -U langgraph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we need to set API keys for OpenAI (the LLM we will use):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import getpass\n",
    "import os\n",
    "\n",
    "\n",
    "def _set_env(var: str):\n",
    "    if not os.environ.get(var):\n",
    "        os.environ[var] = getpass.getpass(f\"{var}: \")\n",
    "\n",
    "\n",
    "_set_env(\"OPENAI_API_KEY\")"
   ]
  },
  {
   "cell_type": "markdown",
   "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>    "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define SubGraph\n",
    "\n",
    "First, let's set up our subgraph. For this, we will create a simple graph that can get the weather for a specific city. We will compile this graph with a [breakpoint](https://langchain-ai.github.io/langgraph/how-tos/human_in_the_loop/breakpoints/) before the `weather_node`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from langgraph.graph import StateGraph, END, START, MessagesState\n",
    "from langchain_core.tools import tool\n",
    "from langchain_openai import ChatOpenAI\n",
    "\n",
    "\n",
    "@tool\n",
    "def get_weather(city: str):\n",
    "    \"\"\"Get the weather for a specific city\"\"\"\n",
    "    return f\"It's sunny in {city}!\"\n",
    "\n",
    "\n",
    "raw_model = ChatOpenAI()\n",
    "model = raw_model.with_structured_output(get_weather)\n",
    "\n",
    "\n",
    "class SubGraphState(MessagesState):\n",
    "    city: str\n",
    "\n",
    "\n",
    "def model_node(state: SubGraphState):\n",
    "    result = model.invoke(state[\"messages\"])\n",
    "    return {\"city\": result[\"city\"]}\n",
    "\n",
    "\n",
    "def weather_node(state: SubGraphState):\n",
    "    result = get_weather.invoke({\"city\": state[\"city\"]})\n",
    "    return {\"messages\": [{\"role\": \"assistant\", \"content\": result}]}\n",
    "\n",
    "\n",
    "subgraph = StateGraph(SubGraphState)\n",
    "subgraph.add_node(model_node)\n",
    "subgraph.add_node(weather_node)\n",
    "subgraph.add_edge(START, \"model_node\")\n",
    "subgraph.add_edge(\"model_node\", \"weather_node\")\n",
    "subgraph.add_edge(\"weather_node\", END)\n",
    "subgraph = subgraph.compile(interrupt_before=[\"weather_node\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define Parent Graph\n",
    "\n",
    "We can now setup the overall graph. This graph will first route to the subgraph if it needs to get the weather, otherwise it will route to a normal LLM."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Literal\n",
    "from typing_extensions import TypedDict\n",
    "from langgraph.checkpoint.memory import MemorySaver\n",
    "\n",
    "\n",
    "memory = MemorySaver()\n",
    "\n",
    "\n",
    "class RouterState(MessagesState):\n",
    "    route: Literal[\"weather\", \"other\"]\n",
    "\n",
    "\n",
    "class Router(TypedDict):\n",
    "    route: Literal[\"weather\", \"other\"]\n",
    "\n",
    "\n",
    "router_model = raw_model.with_structured_output(Router)\n",
    "\n",
    "\n",
    "def router_node(state: RouterState):\n",
    "    system_message = \"Classify the incoming query as either about weather or not.\"\n",
    "    messages = [{\"role\": \"system\", \"content\": system_message}] + state[\"messages\"]\n",
    "    route = router_model.invoke(messages)\n",
    "    return {\"route\": route[\"route\"]}\n",
    "\n",
    "\n",
    "def normal_llm_node(state: RouterState):\n",
    "    response = raw_model.invoke(state[\"messages\"])\n",
    "    return {\"messages\": [response]}\n",
    "\n",
    "\n",
    "def route_after_prediction(\n",
    "    state: RouterState,\n",
    ") -> Literal[\"weather_graph\", \"normal_llm_node\"]:\n",
    "    if state[\"route\"] == \"weather\":\n",
    "        return \"weather_graph\"\n",
    "    else:\n",
    "        return \"normal_llm_node\"\n",
    "\n",
    "\n",
    "graph = StateGraph(RouterState)\n",
    "graph.add_node(router_node)\n",
    "graph.add_node(normal_llm_node)\n",
    "graph.add_node(\"weather_graph\", subgraph)\n",
    "graph.add_edge(START, \"router_node\")\n",
    "graph.add_conditional_edges(\"router_node\", route_after_prediction)\n",
    "graph.add_edge(\"normal_llm_node\", END)\n",
    "graph.add_edge(\"weather_graph\", END)\n",
    "graph = graph.compile(checkpointer=memory)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/jpeg": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from IPython.display import Image, display\n",
    "\n",
    "# Setting xray to 1 will show the internal structure of the nested graph\n",
    "display(Image(graph.get_graph(xray=1).draw_mermaid_png()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's test this out with a normal query to make sure it works as intended!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'router_node': {'route': 'other'}}\n",
      "{'normal_llm_node': {'messages': [AIMessage(content='Hello! How can I assist you today?', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 9, 'prompt_tokens': 9, 'total_tokens': 18, 'completion_tokens_details': {'reasoning_tokens': 0}}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-35de4577-2117-40e4-ab3b-cd2ac6e27b4c-0', usage_metadata={'input_tokens': 9, 'output_tokens': 9, 'total_tokens': 18})]}}\n"
     ]
    }
   ],
   "source": [
    "config = {\"configurable\": {\"thread_id\": \"1\"}}\n",
    "inputs = {\"messages\": [{\"role\": \"user\", \"content\": \"hi!\"}]}\n",
    "for update in graph.stream(inputs, config=config, stream_mode=\"updates\"):\n",
    "    print(update)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great! We didn't ask about the weather, so we got a normal response from the LLM.\n",
    "\n",
    "## Resuming from breakpoints\n",
    "\n",
    "Let's now look at what happens with breakpoints. Let's invoke it with a query that should get routed to the weather subgraph where we have the interrupt node."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'router_node': {'route': 'weather'}}\n"
     ]
    }
   ],
   "source": [
    "config = {\"configurable\": {\"thread_id\": \"2\"}}\n",
    "inputs = {\"messages\": [{\"role\": \"user\", \"content\": \"what's the weather in sf\"}]}\n",
    "for update in graph.stream(inputs, config=config, stream_mode=\"updates\"):\n",
    "    print(update)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the graph stream doesn't include subgraph events. If we want to stream subgraph events, we can pass `subgraphs=True` and get back subgraph events like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "((), {'messages': [HumanMessage(content=\"what's the weather in sf\", additional_kwargs={}, response_metadata={}, id='108eb27a-2cbf-48d2-a6e7-6e07e82eafbc')]})\n",
      "((), {'messages': [HumanMessage(content=\"what's the weather in sf\", additional_kwargs={}, response_metadata={}, id='108eb27a-2cbf-48d2-a6e7-6e07e82eafbc')], 'route': 'weather'})\n",
      "(('weather_graph:0c47aeb3-6f4d-5e68-ccf4-42bd48e8ef20',), {'messages': [HumanMessage(content=\"what's the weather in sf\", additional_kwargs={}, response_metadata={}, id='108eb27a-2cbf-48d2-a6e7-6e07e82eafbc')]})\n",
      "(('weather_graph:0c47aeb3-6f4d-5e68-ccf4-42bd48e8ef20',), {'messages': [HumanMessage(content=\"what's the weather in sf\", additional_kwargs={}, response_metadata={}, id='108eb27a-2cbf-48d2-a6e7-6e07e82eafbc')], 'city': 'San Francisco'})\n"
     ]
    }
   ],
   "source": [
    "config = {\"configurable\": {\"thread_id\": \"3\"}}\n",
    "inputs = {\"messages\": [{\"role\": \"user\", \"content\": \"what's the weather in sf\"}]}\n",
    "for update in graph.stream(inputs, config=config, stream_mode=\"values\", subgraphs=True):\n",
    "    print(update)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we get the state now, we can see that it's paused on `weather_graph`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('weather_graph',)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state = graph.get_state(config)\n",
    "state.next"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we look at the pending tasks for our current state, we can see that we have one task named `weather_graph`, which corresponds to the subgraph task."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(PregelTask(id='0c47aeb3-6f4d-5e68-ccf4-42bd48e8ef20', name='weather_graph', path=('__pregel_pull', 'weather_graph'), error=None, interrupts=(), state={'configurable': {'thread_id': '3', 'checkpoint_ns': 'weather_graph:0c47aeb3-6f4d-5e68-ccf4-42bd48e8ef20'}}),)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state.tasks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However since we got the state using the config of the parent graph, we don't have access to the subgraph state. If you look at the `state` value of the `PregelTask` above you will note that it is simply the configuration of the parent graph. If we want to actually populate the subgraph state, we can pass in `subgraphs=True` to `get_state` like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PregelTask(id='0c47aeb3-6f4d-5e68-ccf4-42bd48e8ef20', name='weather_graph', path=('__pregel_pull', 'weather_graph'), error=None, interrupts=(), state=StateSnapshot(values={'messages': [HumanMessage(content=\"what's the weather in sf\", additional_kwargs={}, response_metadata={}, id='108eb27a-2cbf-48d2-a6e7-6e07e82eafbc')], 'city': 'San Francisco'}, next=('weather_node',), config={'configurable': {'thread_id': '3', 'checkpoint_ns': 'weather_graph:0c47aeb3-6f4d-5e68-ccf4-42bd48e8ef20', 'checkpoint_id': '1ef75ee0-d9c3-6242-8001-440e7a3fb19f', 'checkpoint_map': {'': '1ef75ee0-d4e8-6ede-8001-2542067239ef', 'weather_graph:0c47aeb3-6f4d-5e68-ccf4-42bd48e8ef20': '1ef75ee0-d9c3-6242-8001-440e7a3fb19f'}}}, metadata={'source': 'loop', 'writes': {'model_node': {'city': 'San Francisco'}}, 'step': 1, 'parents': {'': '1ef75ee0-d4e8-6ede-8001-2542067239ef'}}, created_at='2024-09-18T18:44:36.278105+00:00', parent_config={'configurable': {'thread_id': '3', 'checkpoint_ns': 'weather_graph:0c47aeb3-6f4d-5e68-ccf4-42bd48e8ef20', 'checkpoint_id': '1ef75ee0-d4ef-6dec-8000-5d5724f3ef73'}}, tasks=(PregelTask(id='26f4384a-41d7-5ca9-cb94-4001de62e8aa', name='weather_node', path=('__pregel_pull', 'weather_node'), error=None, interrupts=(), state=None),)))"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state = graph.get_state(config, subgraphs=True)\n",
    "state.tasks[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we have access to the subgraph state! If you look at the `state` value of the `PregelTask` you can see that it has all the information we need, like the next node (`weather_node`) and the current state values (e.g. `city`).\n",
    "\n",
    "To resume execution, we can just invoke the outer graph as normal:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "((), {'messages': [HumanMessage(content=\"what's the weather in sf\", additional_kwargs={}, response_metadata={}, id='108eb27a-2cbf-48d2-a6e7-6e07e82eafbc')], 'route': 'weather'})\n",
      "(('weather_graph:0c47aeb3-6f4d-5e68-ccf4-42bd48e8ef20',), {'messages': [HumanMessage(content=\"what's the weather in sf\", additional_kwargs={}, response_metadata={}, id='108eb27a-2cbf-48d2-a6e7-6e07e82eafbc')], 'city': 'San Francisco'})\n",
      "(('weather_graph:0c47aeb3-6f4d-5e68-ccf4-42bd48e8ef20',), {'messages': [HumanMessage(content=\"what's the weather in sf\", additional_kwargs={}, response_metadata={}, id='108eb27a-2cbf-48d2-a6e7-6e07e82eafbc'), AIMessage(content=\"It's sunny in San Francisco!\", additional_kwargs={}, response_metadata={}, id='c996ce37-438c-44f4-9e60-5aed8bcdae8a')], 'city': 'San Francisco'})\n",
      "((), {'messages': [HumanMessage(content=\"what's the weather in sf\", additional_kwargs={}, response_metadata={}, id='108eb27a-2cbf-48d2-a6e7-6e07e82eafbc'), AIMessage(content=\"It's sunny in San Francisco!\", additional_kwargs={}, response_metadata={}, id='c996ce37-438c-44f4-9e60-5aed8bcdae8a')], 'route': 'weather'})\n"
     ]
    }
   ],
   "source": [
    "for update in graph.stream(None, config=config, stream_mode=\"values\", subgraphs=True):\n",
    "    print(update)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Resuming from specific subgraph node\n",
    "\n",
    "In the example above, we were replaying from the outer graph - which automatically replayed the subgraph from whatever state it was in previously (paused before the `weather_node` in our case), but it is also possible to replay from inside a subgraph. In order to do so, we need to get the configuration from the exact subgraph state that we want to replay from.\n",
    "\n",
    "We can do this by exploring the state history of the subgraph, and selecting the state before `model_node` - which we can do by filtering on the `.next` parameter.\n",
    "\n",
    "To get the state history of the subgraph, we need to first pass in  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "parent_graph_state_before_subgraph = next(\n",
    "    h for h in graph.get_state_history(config) if h.next == (\"weather_graph\",)\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "subgraph_state_before_model_node = next(\n",
    "    h\n",
    "    for h in graph.get_state_history(parent_graph_state_before_subgraph.tasks[0].state)\n",
    "    if h.next == (\"model_node\",)\n",
    ")\n",
    "\n",
    "# This pattern can be extended no matter how many levels deep - image model node was another subgraph in this case\n",
    "# subsubgraph_stat_history = next(h for h in graph.get_state_history(subgraph_state_before_model_node.tasks[0].state) if h.next == ('my_subsubgraph_node',))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can confirm that we have gotten the correct state by comparing the `.next` parameter of the `subgraph_state_before_model_node`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('model_node',)"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "subgraph_state_before_model_node.next"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perfect! We have gotten the correct state snaphshot, and we can now resume from the `model_node` inside of our subgraph:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "((), {'messages': [HumanMessage(content=\"what's the weather in sf\", additional_kwargs={}, response_metadata={}, id='108eb27a-2cbf-48d2-a6e7-6e07e82eafbc')], 'route': 'weather'})\n",
      "(('weather_graph:0c47aeb3-6f4d-5e68-ccf4-42bd48e8ef20',), {'messages': [HumanMessage(content=\"what's the weather in sf\", additional_kwargs={}, response_metadata={}, id='108eb27a-2cbf-48d2-a6e7-6e07e82eafbc')]})\n",
      "(('weather_graph:0c47aeb3-6f4d-5e68-ccf4-42bd48e8ef20',), {'messages': [HumanMessage(content=\"what's the weather in sf\", additional_kwargs={}, response_metadata={}, id='108eb27a-2cbf-48d2-a6e7-6e07e82eafbc')], 'city': 'San Francisco'})\n"
     ]
    }
   ],
   "source": [
    "for value in graph.stream(\n",
    "    None,\n",
    "    config=subgraph_state_before_model_node.config,\n",
    "    stream_mode=\"values\",\n",
    "    subgraphs=True,\n",
    "):\n",
    "    print(value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great, this subsection has shown how you can replay from any node, no matter how deeply nested it is inside your graph - a powerful tool for testing how deterministic your agent is."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modifying state\n",
    "\n",
    "### Update the state of a subgraph\n",
    "\n",
    "What if we want to modify the state of a subgraph? We can do this similarly to how we [update the state of normal graphs](https://langchain-ai.github.io/langgraph/how-tos/human_in_the_loop/time-travel/), just being careful to pass in the config of the subgraph to `update_state`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'router_node': {'route': 'weather'}}\n"
     ]
    }
   ],
   "source": [
    "config = {\"configurable\": {\"thread_id\": \"4\"}}\n",
    "inputs = {\"messages\": [{\"role\": \"user\", \"content\": \"what's the weather in sf\"}]}\n",
    "for update in graph.stream(inputs, config=config, stream_mode=\"updates\"):\n",
    "    print(update)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[HumanMessage(content=\"what's the weather in sf\", additional_kwargs={}, response_metadata={}, id='05ee2159-3b25-4d6c-97d6-82beda3cabd4')]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "state = graph.get_state(config, subgraphs=True)\n",
    "state.values[\"messages\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to update the state of the **inner** graph, we need to pass the config for the **inner** graph, which we can get by accessing calling `state.tasks[0].state.config` - since we interrupted inside the subgraph, the state of the task is just the state of the subgraph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'configurable': {'thread_id': '4',\n",
       "  'checkpoint_ns': 'weather_graph:67f32ef7-aee0-8a20-0eb0-eeea0fd6de6e',\n",
       "  'checkpoint_id': '1ef75e5a-0b00-6bc0-8002-5726e210fef4',\n",
       "  'checkpoint_map': {'': '1ef75e59-1b13-6ffe-8001-0844ae748fd5',\n",
       "   'weather_graph:67f32ef7-aee0-8a20-0eb0-eeea0fd6de6e': '1ef75e5a-0b00-6bc0-8002-5726e210fef4'}}}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "graph.update_state(state.tasks[0].state.config, {\"city\": \"la\"})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now resume streaming the outer graph (which will resume the subgraph!) and check that we updated our search to use LA instead of SF."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(('weather_graph:9e512e8e-bac5-5412-babe-fe5c12a47cc2',), {'weather_node': {'messages': [{'role': 'assistant', 'content': \"It's sunny in la!\"}]}})\n",
      "((), {'weather_graph': {'messages': [HumanMessage(content=\"what's the weather in sf\", id='35e331c6-eb47-483c-a63c-585877b12f5d'), AIMessage(content=\"It's sunny in la!\", id='c3d6b224-9642-4b21-94d5-eef8dc3f2cc9')]}})\n"
     ]
    }
   ],
   "source": [
    "for update in graph.stream(None, config=config, stream_mode=\"updates\", subgraphs=True):\n",
    "    print(update)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fantastic! The AI responded with \"It's sunny in LA!\" as we expected.\n",
    "\n",
    "### Acting as a subgraph node\n",
    "\n",
    "Another way we could update the state is by acting as the `weather_node` ourselves instead of editing the state before `weather_node` is ran as we did above. We can do this by passing the subgraph config and also the `as_node` argument, which allows us to update the state as if we are the node we specify. Thus by setting an interrupt before the `weather_node` and then using the update state function as the `weather_node`, the graph itself never calls `weather_node` directly but instead we decide what the output of `weather_node` should be."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "((), {'router_node': {'route': 'weather'}})\n",
      "(('weather_graph:c7eb1fc7-efab-b0e3-12ed-8586f37bc7a2',), {'model_node': {'city': 'San Francisco'}})\n",
      "interrupted!\n",
      "((), {'weather_graph': {'messages': [HumanMessage(content=\"what's the weather in sf\", additional_kwargs={}, response_metadata={}, id='ad694c4e-8aac-4e1f-b5ca-790c60c1775b'), AIMessage(content='rainy', additional_kwargs={}, response_metadata={}, id='98a73aaf-3524-482a-9d07-971407df0389')]}})\n",
      "[HumanMessage(content=\"what's the weather in sf\", additional_kwargs={}, response_metadata={}, id='ad694c4e-8aac-4e1f-b5ca-790c60c1775b'), AIMessage(content='rainy', additional_kwargs={}, response_metadata={}, id='98a73aaf-3524-482a-9d07-971407df0389')]\n"
     ]
    }
   ],
   "source": [
    "config = {\"configurable\": {\"thread_id\": \"14\"}}\n",
    "inputs = {\"messages\": [{\"role\": \"user\", \"content\": \"what's the weather in sf\"}]}\n",
    "for update in graph.stream(\n",
    "    inputs, config=config, stream_mode=\"updates\", subgraphs=True\n",
    "):\n",
    "    print(update)\n",
    "# Graph execution should stop before the weather node\n",
    "print(\"interrupted!\")\n",
    "state = graph.get_state(config, subgraphs=True)\n",
    "# We update the state by passing in the message we want returned from the weather node, and make sure to use as_node\n",
    "graph.update_state(\n",
    "    state.tasks[0].state.config,\n",
    "    {\"messages\": [{\"role\": \"assistant\", \"content\": \"rainy\"}]},\n",
    "    as_node=\"weather_node\",\n",
    ")\n",
    "for update in graph.stream(None, config=config, stream_mode=\"updates\", subgraphs=True):\n",
    "    print(update)\n",
    "print(graph.get_state(config).values[\"messages\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perfect! The AI responded with the message we passed in ourselves.\n",
    "\n",
    "### Acting as the entire subgraph\n",
    "\n",
    "Lastly, we could also update the graph just acting as the **entire** subgraph. This is similar to the case above but instead of acting as just the `weather_node` we are acting as the entire subgraph. This is done by passing in the normal graph config as well as the `as_node` argument, where we specify the we are acting as the entire subgraph node."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "((), {'router_node': {'route': 'weather'}})\n",
      "(('weather_graph:53ab3fb1-23e8-5de0-acc6-9fb904fd4dc4',), {'model_node': {'city': 'San Francisco'}})\n",
      "interrupted!\n",
      "[HumanMessage(content=\"what's the weather in sf\", id='64b1b683-778b-4623-b783-4a8f81322ec8'), AIMessage(content='rainy', id='c1d1a2f3-c117-41e9-8c1f-8fb0a02a3b70')]\n"
     ]
    }
   ],
   "source": [
    "config = {\"configurable\": {\"thread_id\": \"8\"}}\n",
    "inputs = {\"messages\": [{\"role\": \"user\", \"content\": \"what's the weather in sf\"}]}\n",
    "for update in graph.stream(\n",
    "    inputs, config=config, stream_mode=\"updates\", subgraphs=True\n",
    "):\n",
    "    print(update)\n",
    "# Graph execution should stop before the weather node\n",
    "print(\"interrupted!\")\n",
    "# We update the state by passing in the message we want returned from the weather graph, making sure to use as_node\n",
    "# Note that we don't need to pass in the subgraph config, since we aren't updating the state inside the subgraph\n",
    "graph.update_state(\n",
    "    config,\n",
    "    {\"messages\": [{\"role\": \"assistant\", \"content\": \"rainy\"}]},\n",
    "    as_node=\"weather_graph\",\n",
    ")\n",
    "for update in graph.stream(None, config=config, stream_mode=\"updates\"):\n",
    "    print(update)\n",
    "print(graph.get_state(config).values[\"messages\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, the AI responded with \"rainy\" as we expected.\n",
    "\n",
    "## Double nested subgraphs\n",
    "\n",
    "This same functionality continues to work no matter the level of nesting. Here is an example of doing the same things with a double nested subgraph (although any level of nesting will work). We add another router on top of our already defined graphs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Literal\n",
    "from typing_extensions import TypedDict\n",
    "from langgraph.checkpoint.memory import MemorySaver\n",
    "\n",
    "\n",
    "memory = MemorySaver()\n",
    "\n",
    "\n",
    "class RouterState(MessagesState):\n",
    "    route: Literal[\"weather\", \"other\"]\n",
    "\n",
    "\n",
    "class Router(TypedDict):\n",
    "    route: Literal[\"weather\", \"other\"]\n",
    "\n",
    "\n",
    "router_model = raw_model.with_structured_output(Router)\n",
    "\n",
    "\n",
    "def router_node(state: RouterState):\n",
    "    system_message = \"Classify the incoming query as either about weather or not.\"\n",
    "    messages = [{\"role\": \"system\", \"content\": system_message}] + state[\"messages\"]\n",
    "    route = router_model.invoke(messages)\n",
    "    return {\"route\": route[\"route\"]}\n",
    "\n",
    "\n",
    "def normal_llm_node(state: RouterState):\n",
    "    response = raw_model.invoke(state[\"messages\"])\n",
    "    return {\"messages\": [response]}\n",
    "\n",
    "\n",
    "def route_after_prediction(\n",
    "    state: RouterState,\n",
    ") -> Literal[\"weather_graph\", \"normal_llm_node\"]:\n",
    "    if state[\"route\"] == \"weather\":\n",
    "        return \"weather_graph\"\n",
    "    else:\n",
    "        return \"normal_llm_node\"\n",
    "\n",
    "\n",
    "graph = StateGraph(RouterState)\n",
    "graph.add_node(router_node)\n",
    "graph.add_node(normal_llm_node)\n",
    "graph.add_node(\"weather_graph\", subgraph)\n",
    "graph.add_edge(START, \"router_node\")\n",
    "graph.add_conditional_edges(\"router_node\", route_after_prediction)\n",
    "graph.add_edge(\"normal_llm_node\", END)\n",
    "graph.add_edge(\"weather_graph\", END)\n",
    "graph = graph.compile()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "from langgraph.checkpoint.memory import MemorySaver\n",
    "\n",
    "memory = MemorySaver()\n",
    "\n",
    "\n",
    "class GrandfatherState(MessagesState):\n",
    "    to_continue: bool\n",
    "\n",
    "\n",
    "def router_node(state: GrandfatherState):\n",
    "    # Dummy logic that will always continue\n",
    "    return {\"to_continue\": True}\n",
    "\n",
    "\n",
    "def route_after_prediction(state: GrandfatherState):\n",
    "    if state[\"to_continue\"]:\n",
    "        return \"graph\"\n",
    "    else:\n",
    "        return END\n",
    "\n",
    "\n",
    "grandparent_graph = StateGraph(GrandfatherState)\n",
    "grandparent_graph.add_node(router_node)\n",
    "grandparent_graph.add_node(\"graph\", graph)\n",
    "grandparent_graph.add_edge(START, \"router_node\")\n",
    "grandparent_graph.add_conditional_edges(\n",
    "    \"router_node\", route_after_prediction, [\"graph\", END]\n",
    ")\n",
    "grandparent_graph.add_edge(\"graph\", END)\n",
    "grandparent_graph = grandparent_graph.compile(checkpointer=MemorySaver())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/jpeg": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from IPython.display import Image, display\n",
    "\n",
    "# Setting xray to 1 will show the internal structure of the nested graph\n",
    "display(Image(grandparent_graph.get_graph(xray=2).draw_mermaid_png()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we run until the interrupt, we can now see that there are snapshots of the state of all three graphs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "((), {'router_node': {'to_continue': True}})\n",
      "(('graph:e18ecd45-5dfb-53b0-bcb7-db793924e9a8',), {'router_node': {'route': 'weather'}})\n",
      "(('graph:e18ecd45-5dfb-53b0-bcb7-db793924e9a8', 'weather_graph:12bd3069-de24-5bc6-b4f1-f39527605781'), {'model_node': {'city': 'San Francisco'}})\n"
     ]
    }
   ],
   "source": [
    "config = {\"configurable\": {\"thread_id\": \"2\"}}\n",
    "inputs = {\"messages\": [{\"role\": \"user\", \"content\": \"what's the weather in sf\"}]}\n",
    "for update in grandparent_graph.stream(\n",
    "    inputs, config=config, stream_mode=\"updates\", subgraphs=True\n",
    "):\n",
    "    print(update)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Grandparent State:\n",
      "{'messages': [HumanMessage(content=\"what's the weather in sf\", id='3bb28060-3d30-49a7-9f84-c90b6ada7848')], 'to_continue': True}\n",
      "---------------\n",
      "Parent Graph State:\n",
      "{'messages': [HumanMessage(content=\"what's the weather in sf\", id='3bb28060-3d30-49a7-9f84-c90b6ada7848')], 'route': 'weather'}\n",
      "---------------\n",
      "Subgraph State:\n",
      "{'messages': [HumanMessage(content=\"what's the weather in sf\", id='3bb28060-3d30-49a7-9f84-c90b6ada7848')], 'city': 'San Francisco'}\n"
     ]
    }
   ],
   "source": [
    "state = grandparent_graph.get_state(config, subgraphs=True)\n",
    "print(\"Grandparent State:\")\n",
    "print(state.values)\n",
    "print(\"---------------\")\n",
    "print(\"Parent Graph State:\")\n",
    "print(state.tasks[0].state.values)\n",
    "print(\"---------------\")\n",
    "print(\"Subgraph State:\")\n",
    "print(state.tasks[0].state.tasks[0].state.values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now continue, acting as the node three levels down"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(('graph:e18ecd45-5dfb-53b0-bcb7-db793924e9a8',), {'weather_graph': {'messages': [HumanMessage(content=\"what's the weather in sf\", id='3bb28060-3d30-49a7-9f84-c90b6ada7848'), AIMessage(content='rainy', id='be926b59-c647-4355-88fd-a429b9e2b420')]}})\n",
      "((), {'graph': {'messages': [HumanMessage(content=\"what's the weather in sf\", id='3bb28060-3d30-49a7-9f84-c90b6ada7848'), AIMessage(content='rainy', id='be926b59-c647-4355-88fd-a429b9e2b420')]}})\n",
      "[HumanMessage(content=\"what's the weather in sf\", id='3bb28060-3d30-49a7-9f84-c90b6ada7848'), AIMessage(content='rainy', id='be926b59-c647-4355-88fd-a429b9e2b420')]\n"
     ]
    }
   ],
   "source": [
    "grandparent_graph_state = state\n",
    "parent_graph_state = grandparent_graph_state.tasks[0].state\n",
    "subgraph_state = parent_graph_state.tasks[0].state\n",
    "grandparent_graph.update_state(\n",
    "    subgraph_state.config,\n",
    "    {\"messages\": [{\"role\": \"assistant\", \"content\": \"rainy\"}]},\n",
    "    as_node=\"weather_node\",\n",
    ")\n",
    "for update in grandparent_graph.stream(\n",
    "    None, config=config, stream_mode=\"updates\", subgraphs=True\n",
    "):\n",
    "    print(update)\n",
    "print(grandparent_graph.get_state(config).values[\"messages\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As in the cases above, we can see that the AI responds with \"rainy\" as we expect.\n",
    "\n",
    "We can explore the state history to see how the state of the grandparent graph was updated at each step."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "StateSnapshot(values={'messages': [HumanMessage(content=\"what's the weather in sf\", id='5ff89e4d-8255-4d23-8b55-01633c112720'), AIMessage(content='rainy', id='7c80f847-248d-4b8f-8238-633ed757b353')], 'to_continue': True}, next=(), config={'configurable': {'thread_id': '2', 'checkpoint_ns': '', 'checkpoint_id': '1ef66f40-7a2c-6f9e-8002-a37a61b26709'}}, metadata={'source': 'loop', 'writes': {'graph': {'messages': [HumanMessage(content=\"what's the weather in sf\", id='5ff89e4d-8255-4d23-8b55-01633c112720'), AIMessage(content='rainy', id='7c80f847-248d-4b8f-8238-633ed757b353')]}}, 'step': 2, 'parents': {}}, created_at='2024-08-30T17:19:35.793847+00:00', parent_config={'configurable': {'thread_id': '2', 'checkpoint_ns': '', 'checkpoint_id': '1ef66f3f-f312-6338-8001-766acddc781e'}}, tasks=())\n",
      "-----\n",
      "StateSnapshot(values={'messages': [HumanMessage(content=\"what's the weather in sf\", id='5ff89e4d-8255-4d23-8b55-01633c112720')], 'to_continue': True}, next=('graph',), config={'configurable': {'thread_id': '2', 'checkpoint_ns': '', 'checkpoint_id': '1ef66f3f-f312-6338-8001-766acddc781e'}}, metadata={'source': 'loop', 'writes': {'router_node': {'to_continue': True}}, 'step': 1, 'parents': {}}, created_at='2024-08-30T17:19:21.627097+00:00', parent_config={'configurable': {'thread_id': '2', 'checkpoint_ns': '', 'checkpoint_id': '1ef66f3f-f303-61d0-8000-1945c8a74e9e'}}, tasks=(PregelTask(id='b59fe96f-fdce-5afe-aa58-bd2876a0d592', name='graph', error=None, interrupts=(), state={'configurable': {'thread_id': '2', 'checkpoint_ns': 'graph:b59fe96f-fdce-5afe-aa58-bd2876a0d592'}}),))\n",
      "-----\n",
      "StateSnapshot(values={'messages': [HumanMessage(content=\"what's the weather in sf\", id='5ff89e4d-8255-4d23-8b55-01633c112720')]}, next=('router_node',), config={'configurable': {'thread_id': '2', 'checkpoint_ns': '', 'checkpoint_id': '1ef66f3f-f303-61d0-8000-1945c8a74e9e'}}, metadata={'source': 'loop', 'writes': None, 'step': 0, 'parents': {}}, created_at='2024-08-30T17:19:21.620923+00:00', parent_config={'configurable': {'thread_id': '2', 'checkpoint_ns': '', 'checkpoint_id': '1ef66f3f-f2f9-6d6a-bfff-c8b76e5b2462'}}, tasks=(PregelTask(id='e3d4a97a-f4ca-5260-801e-e65b02907825', name='router_node', error=None, interrupts=(), state=None),))\n",
      "-----\n",
      "StateSnapshot(values={'messages': []}, next=('__start__',), config={'configurable': {'thread_id': '2', 'checkpoint_ns': '', 'checkpoint_id': '1ef66f3f-f2f9-6d6a-bfff-c8b76e5b2462'}}, metadata={'source': 'input', 'writes': {'messages': [{'role': 'user', 'content': \"what's the weather in sf\"}]}, 'step': -1, 'parents': {}}, created_at='2024-08-30T17:19:21.617127+00:00', parent_config=None, tasks=(PregelTask(id='f0538638-b794-58fc-a406-980d2fea28a1', name='__start__', error=None, interrupts=(), state=None),))\n",
      "-----\n"
     ]
    }
   ],
   "source": [
    "for state in grandparent_graph.get_state_history(config):\n",
    "    print(state)\n",
    "    print(\"-----\")"
   ]
  }
 ],
 "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": 4
}