{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# How to return state before hitting recursion limit\n",
    "\n",
    "<div class=\"admonition tip\">\n",
    "    <p class=\"admonition-title\">Prerequisites</p>\n",
    "    <p>\n",
    "        This guide assumes familiarity with the following:\n",
    "        <ul>\n",
    "            <li>\n",
    "                <a href=\"https://langchain-ai.github.io/langgraphjs/concepts/low_level/#graphs\">\n",
    "                    Graphs\n",
    "                </a>\n",
    "            </li>\n",
    "            <li>\n",
    "                <a href=\"https://langchain-ai.github.io/langgraph/concepts/low_level/#recursion-limit\">\n",
    "                    Recursion Limit\n",
    "                </a>\n",
    "            </li>\n",
    "            <li>\n",
    "                <a href=\"https://langchain-ai.github.io/langgraph/concepts/low_level/#nodes\">\n",
    "                    Nodes\n",
    "                </a>\n",
    "            </li>\n",
    "        </ul>\n",
    "    </p>\n",
    "</div> \n",
    "\n",
    "[Setting the graph recursion limit](https://langchain-ai.github.io/langgraph/how-tos/recursion-limit/) can help you control how long your graph will stay running, but if the recursion limit is hit your graph returns an error - which may not be ideal for all use cases. Instead you may wish to return the value of the state *just before* the recursion limit is hit. This how-to will show you how to do this."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup\n",
    "\n",
    "First, let's installed the required packages:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture --no-stderr\n",
    "%pip install -U langgraph"
   ]
  },
  {
   "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>    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Without returning state\n",
    "\n",
    "We are going to define a dummy graph in this example that will always hit the recursion limit. First, we will implement it without returning the state and show that it hits the recursion limit. This graph is based on the ReACT architecture, but instead of actually making decisions and taking actions it just loops forever."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing_extensions import TypedDict\n",
    "from langgraph.graph import StateGraph\n",
    "from langgraph.graph import START, END\n",
    "\n",
    "\n",
    "class State(TypedDict):\n",
    "    value: str\n",
    "    action_result: str\n",
    "\n",
    "\n",
    "def router(state: State):\n",
    "    if state[\"value\"] == \"end\":\n",
    "        return END\n",
    "    else:\n",
    "        return \"action\"\n",
    "\n",
    "\n",
    "def decision_node(state):\n",
    "    return {\"value\": \"keep going!\"}\n",
    "\n",
    "\n",
    "def action_node(state: State):\n",
    "    # Do your action here ...\n",
    "    return {\"action_result\": \"what a great result!\"}\n",
    "\n",
    "\n",
    "workflow = StateGraph(State)\n",
    "workflow.add_node(\"decision\", decision_node)\n",
    "workflow.add_node(\"action\", action_node)\n",
    "workflow.add_edge(START, \"decision\")\n",
    "workflow.add_conditional_edges(\"decision\", router, [\"action\", END])\n",
    "workflow.add_edge(\"action\", \"decision\")\n",
    "app = workflow.compile()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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",
    "display(Image(app.get_graph().draw_mermaid_png()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's verify that our graph will always hit the recursion limit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recursion Error\n"
     ]
    }
   ],
   "source": [
    "from langgraph.errors import GraphRecursionError\n",
    "\n",
    "try:\n",
    "    app.invoke({\"value\": \"hi!\"})\n",
    "except GraphRecursionError:\n",
    "    print(\"Recursion Error\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## With returning state\n",
    "\n",
    "If we wanted to actually return the state, what we are going to do is introduce a new key to our state called `is_last_step` which keeps track of if we are on the last step of our recursion limit. If so, we will bypass all other graph decisions and simply terminate the graph, returning the state to the user without causing an error.\n",
    "\n",
    "We are going to use a `ManagedValue` channel to do this. A `ManagedValue` channel is a state channel that will exist for the duration of our graph run and no longer. Since our `action` node is going to always induce at least 2 extra steps to our graph (since the `action` node ALWAYS calls the `decision` node afterwards), we will use this channel to check if we are within 2 steps of the limit. See the implementation of `IsLastOrSecondToLastStepManager` below.\n",
    "\n",
    "This implementation very closely mirrors the implementation of `isLastStep` (which you can use by calling `from langgraph.managed import IsLastStep` and then decorating state keys with the `isLastStep` type), but in this case we check if we are on the last OR second-to-last step, instead of just the last step.\n",
    "\n",
    "Now, when we run our graph we should receive no errors and instead get the last value of the state before the recursion limit was hit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing_extensions import TypedDict\n",
    "from langgraph.graph import StateGraph\n",
    "from typing import Annotated\n",
    "\n",
    "from langgraph.managed.base import ManagedValue\n",
    "\n",
    "\n",
    "class IsLastOrSecondToLastStepManager(ManagedValue[bool]):\n",
    "    def __call__(self, step: int) -> bool:\n",
    "        limit = self.config.get(\"recursion_limit\", 0)\n",
    "        return step >= limit - 2\n",
    "\n",
    "\n",
    "class State(TypedDict):\n",
    "    value: str\n",
    "    action_result: str\n",
    "    is_last_step: Annotated[bool, IsLastOrSecondToLastStepManager]\n",
    "\n",
    "\n",
    "def router(state: State):\n",
    "    # Force the agent to end if it is on the last step\n",
    "    if state[\"is_last_step\"]:\n",
    "        return END\n",
    "    if state[\"value\"] == \"end\":\n",
    "        return END\n",
    "    else:\n",
    "        return \"action\"\n",
    "\n",
    "\n",
    "def decision_node(state):\n",
    "    return {\"value\": \"keep going!\"}\n",
    "\n",
    "\n",
    "def action_node(state: State):\n",
    "    # Do your action here ...\n",
    "    return {\"action_result\": \"what a great result!\"}\n",
    "\n",
    "\n",
    "workflow = StateGraph(State)\n",
    "workflow.add_node(\"decision\", decision_node)\n",
    "workflow.add_node(\"action\", action_node)\n",
    "workflow.add_edge(START, \"decision\")\n",
    "workflow.add_conditional_edges(\"decision\", router, [\"action\", END])\n",
    "workflow.add_edge(\"action\", \"decision\")\n",
    "app = workflow.compile()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'value': 'keep going!', 'action_result': 'what a great result!'}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "app.invoke({\"value\": \"hi!\"})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perfect! Our code ran with no error, just as we expected!"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}