\n",
@@ -335,13 +308,13 @@
},
{
"cell_type": "code",
- "execution_count": 2,
+ "execution_count": 7,
"id": "f5319e01",
"metadata": {},
"outputs": [
{
"data": {
- "image/jpeg": "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",
+ "image/png": "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",
"text/plain": [
"
"
]
@@ -375,10 +348,8 @@
"\n",
"# Set up the model\n",
"from langchain_anthropic import ChatAnthropic\n",
- "from langchain_openai import ChatOpenAI\n",
"\n",
- "model = ChatAnthropic(model=\"claude-3-5-sonnet-20240620\")\n",
- "model = ChatOpenAI(model=\"gpt-4o\")\n",
+ "model = ChatAnthropic(model=\"claude-3-5-sonnet-latest\")\n",
"\n",
"from pydantic import BaseModel\n",
"\n",
@@ -404,7 +375,7 @@
" last_message = messages[-1]\n",
" # If there is no function call, then we finish\n",
" if not last_message.tool_calls:\n",
- " return \"end\"\n",
+ " return END\n",
" # If tool call is asking Human, we return that node\n",
" # You could also add logic here to let some system know that there's something that requires Human input\n",
" # For example, send a slack message, etc\n",
@@ -412,7 +383,7 @@
" return \"ask_human\"\n",
" # Otherwise if there is, we continue\n",
" else:\n",
- " return \"continue\"\n",
+ " return \"action\"\n",
"\n",
"\n",
"# Define the function that calls the model\n",
@@ -425,7 +396,10 @@
"\n",
"# We define a fake node to ask the human\n",
"def ask_human(state):\n",
- " pass\n",
+ " tool_call_id = state[\"messages\"][-1].tool_calls[0][\"id\"]\n",
+ " location = interrupt(\"Please provide your location:\")\n",
+ " tool_message = [{\"tool_call_id\": tool_call_id, \"type\": \"tool\", \"content\": location}]\n",
+ " return {\"messages\": tool_message}\n",
"\n",
"\n",
"# Build the graph\n",
@@ -451,20 +425,6 @@
" \"agent\",\n",
" # Next, we pass in the function that will determine which node is called next.\n",
" should_continue,\n",
- " # Finally we pass in a mapping.\n",
- " # The keys are strings, and the values are other nodes.\n",
- " # END is a special node marking that the graph should finish.\n",
- " # What will happen is we will call `should_continue`, and then the output of that\n",
- " # will be matched against the keys in this mapping.\n",
- " # Based on which one it matches, that node will then be called.\n",
- " {\n",
- " # If `tools`, then we call the tool node.\n",
- " \"continue\": \"action\",\n",
- " # We may ask the human\n",
- " \"ask_human\": \"ask_human\",\n",
- " # Otherwise we finish.\n",
- " \"end\": END,\n",
- " },\n",
")\n",
"\n",
"# We now add a normal edge from `tools` to `agent`.\n",
@@ -483,7 +443,7 @@
"# This compiles it into a LangChain Runnable,\n",
"# meaning you can use it as you would any other runnable\n",
"# We add a breakpoint BEFORE the `ask_human` node so it never executes\n",
- "app = workflow.compile(checkpointer=memory, interrupt_before=[\"ask_human\"])\n",
+ "app = workflow.compile(checkpointer=memory)\n",
"\n",
"display(Image(app.get_graph().draw_mermaid_png()))"
]
@@ -502,7 +462,7 @@
},
{
"cell_type": "code",
- "execution_count": 48,
+ "execution_count": 8,
"id": "cfd140f0-a5a6-4697-8115-322242f197b5",
"metadata": {},
"outputs": [
@@ -514,75 +474,51 @@
"\n",
"Use the search tool to ask the user where they are, then look up the weather there\n",
"==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+ "\n",
+ "[{'text': \"I'll help you with that. Let me first ask the user about their location.\", 'type': 'text'}, {'id': 'toolu_01KNvb7RCVu8yKYUuQQSKN1x', 'input': {'question': 'Where are you located?'}, 'name': 'AskHuman', 'type': 'tool_use'}]\n",
"Tool Calls:\n",
- " AskHuman (call_LDo62KBPQKZWxPI5IHxPBF0w)\n",
- " Call ID: call_LDo62KBPQKZWxPI5IHxPBF0w\n",
+ " AskHuman (toolu_01KNvb7RCVu8yKYUuQQSKN1x)\n",
+ " Call ID: toolu_01KNvb7RCVu8yKYUuQQSKN1x\n",
" Args:\n",
- " question: Can you tell me where you are located?\n"
+ " question: Where are you located?\n"
]
}
],
"source": [
- "from langchain_core.messages import HumanMessage\n",
- "\n",
"config = {\"configurable\": {\"thread_id\": \"2\"}}\n",
- "input_message = HumanMessage(\n",
- " content=\"Use the search tool to ask the user where they are, then look up the weather there\"\n",
- ")\n",
- "for event in app.stream({\"messages\": [input_message]}, config, stream_mode=\"values\"):\n",
+ "for event in app.stream(\n",
+ " {\n",
+ " \"messages\": [\n",
+ " (\n",
+ " \"user\",\n",
+ " \"Use the search tool to ask the user where they are, then look up the weather there\",\n",
+ " )\n",
+ " ]\n",
+ " },\n",
+ " config,\n",
+ " stream_mode=\"values\",\n",
+ "):\n",
" event[\"messages\"][-1].pretty_print()"
]
},
- {
- "cell_type": "markdown",
- "id": "cc168c90-a374-4280-a9a6-8bc232dbb006",
- "metadata": {},
- "source": [
- "We now want to update this thread with a response from the user. We then can kick off another run. \n",
- "\n",
- "Because we are treating this as a tool call, we will need to update the state as if it is a response from a tool call. In order to do this, we will need to check the state to get the ID of the tool call."
- ]
- },
{
"cell_type": "code",
- "execution_count": 50,
- "id": "63598092-d565-4170-9773-e092d345f8c1",
+ "execution_count": 9,
+ "id": "924a30ea-94c0-468e-90fe-47eb9c08584d",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
- "('agent',)"
+ "('ask_human',)"
]
},
- "execution_count": 50,
+ "execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
- "tool_call_id = app.get_state(config).values[\"messages\"][-1].tool_calls[0][\"id\"]\n",
- "\n",
- "# We now create the tool call with the id and the response we want\n",
- "tool_message = [\n",
- " {\"tool_call_id\": tool_call_id, \"type\": \"tool\", \"content\": \"san francisco\"}\n",
- "]\n",
- "\n",
- "# # This is equivalent to the below, either one works\n",
- "# from langchain_core.messages import ToolMessage\n",
- "# tool_message = [ToolMessage(tool_call_id=tool_call_id, content=\"san francisco\")]\n",
- "\n",
- "# We now update the state\n",
- "# Notice that we are also specifying `as_node=\"ask_human\"`\n",
- "# This will apply this update as this node,\n",
- "# which will make it so that afterwards it continues as normal\n",
- "app.update_state(config, {\"messages\": tool_message}, as_node=\"ask_human\")\n",
- "\n",
- "# We can check the state\n",
- "# We can see that the state currently has the `agent` node next\n",
- "# This is based on how we define our graph,\n",
- "# where after the `ask_human` node goes (which we just triggered)\n",
- "# there is an edge to the `agent` node\n",
"app.get_state(config).next"
]
},
@@ -591,12 +527,12 @@
"id": "6a30c9fb-2a40-45cc-87ba-406c11c9f0cf",
"metadata": {},
"source": [
- "We can now tell the agent to continue. We can just pass in `None` as the input to the graph, since no additional input is needed"
+ "You can see that our graph got interrupted inside the `ask_human` node, which is now waiting for a `location` to be provided. We can provide this value by invoking the graph with a `Command(resume=\"\")` input:"
]
},
{
"cell_type": "code",
- "execution_count": 51,
+ "execution_count": 10,
"id": "a9f599b5-1a55-406b-a76b-f52b3ca06975",
"metadata": {},
"outputs": [
@@ -605,23 +541,36 @@
"output_type": "stream",
"text": [
"==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+ "\n",
+ "[{'text': \"I'll help you with that. Let me first ask the user about their location.\", 'type': 'text'}, {'id': 'toolu_01KNvb7RCVu8yKYUuQQSKN1x', 'input': {'question': 'Where are you located?'}, 'name': 'AskHuman', 'type': 'tool_use'}]\n",
+ "Tool Calls:\n",
+ " AskHuman (toolu_01KNvb7RCVu8yKYUuQQSKN1x)\n",
+ " Call ID: toolu_01KNvb7RCVu8yKYUuQQSKN1x\n",
+ " Args:\n",
+ " question: Where are you located?\n",
+ "=================================\u001b[1m Tool Message \u001b[0m=================================\n",
+ "\n",
+ "san francisco\n",
+ "==================================\u001b[1m Ai Message \u001b[0m==================================\n",
+ "\n",
+ "[{'text': \"Now I'll search for the weather in San Francisco.\", 'type': 'text'}, {'id': 'toolu_01Y5C4rU9WcxBqFLYSMGjV1F', 'input': {'query': 'current weather in san francisco'}, 'name': 'search', 'type': 'tool_use'}]\n",
"Tool Calls:\n",
- " search (call_LJlkCFfHvAS2taKHTaMmORE5)\n",
- " Call ID: call_LJlkCFfHvAS2taKHTaMmORE5\n",
+ " search (toolu_01Y5C4rU9WcxBqFLYSMGjV1F)\n",
+ " Call ID: toolu_01Y5C4rU9WcxBqFLYSMGjV1F\n",
" Args:\n",
- " query: current weather in San Francisco\n",
+ " query: current weather in san francisco\n",
"=================================\u001b[1m Tool Message \u001b[0m=================================\n",
"Name: search\n",
"\n",
- "[\"I looked up: current weather in San Francisco. Result: It's sunny in San Francisco, but you better look out if you're a Gemini \\ud83d\\ude08.\"]\n",
+ "I looked up: current weather in san francisco. Result: It's sunny in San Francisco, but you better look out if you're a Gemini 😈.\n",
"==================================\u001b[1m Ai Message \u001b[0m==================================\n",
"\n",
- "The current weather in San Francisco is sunny. Enjoy the good weather! 🌞\n"
+ "Based on the search results, it's currently sunny in San Francisco. Note that this is the current weather at the time of our conversation, and conditions can change throughout the day.\n"
]
}
],
"source": [
- "for event in app.stream(None, config, stream_mode=\"values\"):\n",
+ "for event in app.stream(Command(resume=\"san francisco\"), config, stream_mode=\"values\"):\n",
" event[\"messages\"][-1].pretty_print()"
]
}
@@ -642,7 +591,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.11.8"
+ "version": "3.11.4"
}
},
"nbformat": 4,
diff --git a/docs/docs/how-tos/index.md b/docs/docs/how-tos/index.md
index d93488d94..24083d328 100644
--- a/docs/docs/how-tos/index.md
+++ b/docs/docs/how-tos/index.md
@@ -48,12 +48,24 @@ LangGraph makes it easy to manage conversation [memory](../concepts/memory.md) i
[Human-in-the-loop](../concepts/human_in_the_loop.md) functionality allows
you to involve humans in the decision-making process of your graph. These how-to guides show how to implement human-in-the-loop workflows in your graph.
-- [How to add breakpoints](human_in_the_loop/breakpoints.ipynb)
-- [How to add dynamic breakpoints](human_in_the_loop/dynamic_breakpoints.ipynb)
-- [How to edit graph state](human_in_the_loop/edit-graph-state.ipynb)
-- [How to wait for user input](human_in_the_loop/wait-user-input.ipynb)
+
+Key workflows:
+
+- [How to wait for user input](human_in_the_loop/wait-user-input.ipynb): A basic example that shows how to implement a human-in-the-loop workflow in your graph using the `interrupt` function.
+- [How to review tool calls](human_in_the_loop/review-tool-calls.ipynb): Incorporate human-in-the-loop for reviewing/editing/accepting tool call requests before they executed using the `interrupt` function.
+
+
+Other methods:
+
+- [How to add static breakpoints](human_in_the_loop/breakpoints.ipynb): Use for debugging purposes. For [**human-in-the-loop**](../concepts/human_in_the_loop.md) workflows, we recommend the [`interrupt` function][langgraph.types.interrupt] instead.
+- [How to edit graph state](human_in_the_loop/edit-graph-state.ipynb): Edit graph state using `graph.update_state` method. Use this if implementing a **human-in-the-loop** workflow via **static breakpoints**.
+- [How to add dynamic breakpoints with `NodeInterrupt`](human_in_the_loop/dynamic_breakpoints.ipynb): **Not recommended**: Use the [`interrupt` function](../concepts/human_in_the_loop.md) instead.
+
+### Time Travel
+
+[Time travel](../concepts/time-travel.md) allows you to replay past actions in your LangGraph application to explore alternative paths and debug issues. These how-to guides show how to use time travel in your graph.
+
- [How to view and update past graph state](human_in_the_loop/time-travel.ipynb)
-- [How to review tool calls](human_in_the_loop/review-tool-calls.ipynb)
### Streaming
@@ -94,7 +106,10 @@ These how-to guides show common patterns for tool calling with LangGraph:
### Multi-agent
+[Multi-agent systems](../concepts/multi_agent.md) are useful to break down complex LLM applications into multiple agents, each responsible for a different part of the application. These how-to guides show how to implement multi-agent systems in LangGraph:
+
- [How to build a multi-agent network](multi-agent-network.ipynb)
+- [How to add multi-turn conversation in a multi-agent application](multi-agent-multi-turn-convo.ipynb)
See the [multi-agent tutorials](../tutorials/index.md#multi-agent-systems) for implementations of other multi-agent architectures.
diff --git a/docs/docs/how-tos/multi-agent-multi-turn-convo.ipynb b/docs/docs/how-tos/multi-agent-multi-turn-convo.ipynb
new file mode 100644
index 000000000..411eb4216
--- /dev/null
+++ b/docs/docs/how-tos/multi-agent-multi-turn-convo.ipynb
@@ -0,0 +1,384 @@
+{
+ "cells": [
+ {
+ "attachments": {},
+ "cell_type": "markdown",
+ "id": "a2b182eb-1e31-43c8-85b1-706508dfa370",
+ "metadata": {},
+ "source": [
+ "# How to add multi-turn conversation in a multi-agent application\n",
+ "\n",
+ "!!! info \"Prerequisites\"\n",
+ " This guide assumes familiarity with the following:\n",
+ "\n",
+ " - [Node](../../concepts/low_level/#nodes)\n",
+ " - [Command](../../concepts/low_level/#command)\n",
+ " - [Multi-agent systems](../../concepts/multi_agent)\n",
+ " - [Human-in-the-loop](../../concepts/human_in_the_loop)\n",
+ "\n",
+ "\n",
+ "In this how-to guide, we’ll build an application that allows an end-user to engage in a *multi-turn conversation* with one or more agents. We'll create a node that uses an [`interrupt`](../../reference/types/#langgraph.types.interrupt) to collect user input and routes back to the **active** agent.\n",
+ "\n",
+ "The agents will be implemented as nodes in a graph that executes agent steps and determines the next action: \n",
+ "\n",
+ "1. **Wait for user input** to continue the conversation, or \n",
+ "2. **Route to another agent** (or back to itself, such as in a loop) via a [**handoff**](../../concepts/multi_agent/#handoffs).\n",
+ "\n",
+ "```python\n",
+ "def human(state: MessagesState) -> Command[Literal[\"agent\", \"another_agent\"]]:\n",
+ " \"\"\"A node for collecting user input.\"\"\"\n",
+ " user_input = interrupt(value=\"Ready for user input.\")\n",
+ "\n",
+ " # Determine the active agent.\n",
+ " active_agent = ...\n",
+ "\n",
+ " ...\n",
+ " return Command(\n",
+ " update={\n",
+ " \"messages\": [{\n",
+ " \"role\": \"human\",\n",
+ " \"content\": user_input,\n",
+ " }]\n",
+ " },\n",
+ " goto=active_agent,\n",
+ "\n",
+ "def agent(state) -> Command[Literal[\"agent\", \"another_agent\", \"human\"]]:\n",
+ " # The condition for routing/halting can be anything, e.g. LLM tool call / structured output, etc.\n",
+ " goto = get_next_agent(...) # 'agent' / 'another_agent'\n",
+ " if goto:\n",
+ " return Command(goto=goto, update={\"my_state_key\": \"my_state_value\"})\n",
+ " else:\n",
+ " return Command(goto=\"human\") # Go to human node\n",
+ " )\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "faaa4444-cd06-4813-b9ca-c9700fe12cb7",
+ "metadata": {},
+ "source": [
+ "## Setup\n",
+ "\n",
+ "First, let's install the required packages"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "05038da0-31df-4066-a1a4-c4ccb5db4d3a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "%%capture --no-stderr\n",
+ "%pip install -U langgraph langchain-openai"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 106,
+ "id": "0bcff5d4-130e-426d-9285-40d0f72c7cd3",
+ "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",
+ "id": "c3ec6e48-85dc-4905-ba50-985e5d4788e6",
+ "metadata": {},
+ "source": [
+ "\n",
+ "
Set up LangSmith for LangGraph development
\n",
+ "
\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 here. \n",
+ "
\n",
+ "
"
+ ]
+ },
+ {
+ "attachments": {},
+ "cell_type": "markdown",
+ "id": "6696b398-559d-4250-bb76-ebb7c97ce5f3",
+ "metadata": {},
+ "source": [
+ "## Travel Recommendations Example\n",
+ "\n",
+ "In this example, we will build a team of travel assistant agents that can communicate with each other via handoffs.\n",
+ "\n",
+ "We will create 3 agents:\n",
+ "\n",
+ "* `travel_advisor`: can help with general travel destination recommendations. Can ask `sightseeing_advisor` and `hotel_advisor` for help.\n",
+ "* `sightseeing_advisor`: can help with sightseeing recommendations. Can ask `travel_advisor` and `hotel_advisor` for help.\n",
+ "* `hotel_advisor`: can help with hotel recommendations. Can ask `sightseeing_advisor` and `hotel_advisor` for help.\n",
+ "\n",
+ "This is a fully-connected network - every agent can talk to any other agent. \n",
+ "\n",
+ "To implement the handoffs between the agents we'll be using LLMs with structured output. Each agent's LLM will return an output with both its text response (`response`) as well as which agent to route to next (`goto`). If the agent has enough information to respond to the user, the `goto` will be set to `human` to route back and collect information from a human.\n",
+ "\n",
+ "Now, let's define our agent nodes and graph!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 110,
+ "id": "aa4bdbff-9461-46cc-aee9-8a22d3c3d9ec",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from typing_extensions import TypedDict, Literal\n",
+ "\n",
+ "from langchain_openai import ChatOpenAI\n",
+ "from langchain_core.messages import HumanMessage\n",
+ "from langgraph.graph import MessagesState, StateGraph, START, END\n",
+ "from langgraph.types import Command, interrupt\n",
+ "from langgraph.checkpoint.memory import MemorySaver\n",
+ "from langgraph.prebuilt import create_react_agent\n",
+ "\n",
+ "model = ChatOpenAI(model=\"gpt-4o\")\n",
+ "\n",
+ "\n",
+ "def make_agent_node(*, name: str, destinations: list[str], system_prompt: str):\n",
+ " def agent_node(state: MessagesState) -> Command[Literal[*destinations, \"human\"]]:\n",
+ " # define schema for the structured output:\n",
+ " # - model's text response (`response`)\n",
+ " # - name of the node to go to next (or 'finish')\n",
+ " class Response(TypedDict):\n",
+ " response: str\n",
+ " goto: Literal[*destinations, \"finish\"]\n",
+ "\n",
+ " messages = [{\"role\": \"system\", \"content\": system_prompt}] + state[\"messages\"]\n",
+ " response = model.with_structured_output(Response).invoke(messages)\n",
+ " goto = response[\"goto\"]\n",
+ " if goto == \"finish\":\n",
+ " # When the agent is done, we should go to the\n",
+ " goto = \"human\"\n",
+ "\n",
+ " # Handoff to another agent or halt\n",
+ " ai_msg = {\"role\": \"ai\", \"content\": response[\"response\"], \"name\": name}\n",
+ " return Command(goto=goto, update={\"messages\": [ai_msg]})\n",
+ "\n",
+ " return agent_node\n",
+ "\n",
+ "\n",
+ "travel_advisor = make_agent_node(\n",
+ " name=\"travel_advisor\",\n",
+ " destinations=[\"sightseeing_advisor\", \"hotel_advisor\", \"human\"],\n",
+ " system_prompt=(\n",
+ " \"You are a general travel expert that can recommend travel destinations (e.g. countries, cities, etc). \"\n",
+ " \"If you need specific sightseeing recommendations, ask 'sightseeing_advisor' for help. \"\n",
+ " \"If you need hotel recommendations, ask 'hotel_advisor' for help. \"\n",
+ " \"If you have enough information to respond to the user, return 'finish'. \"\n",
+ " \"Never mention other agents by name.\"\n",
+ " ),\n",
+ ")\n",
+ "sightseeing_advisor = make_agent_node(\n",
+ " name=\"sightseeing_advisor\",\n",
+ " destinations=[\"travel_advisor\", \"hotel_advisor\", \"human\"],\n",
+ " system_prompt=(\n",
+ " \"You are a travel expert that can provide specific sightseeing recommendations for a given destination. \"\n",
+ " \"If you need general travel help, go to 'travel_advisor' for help. \"\n",
+ " \"If you need hotel recommendations, go to 'hotel_advisor' for help. \"\n",
+ " \"If you have enough information to respond to the user, return 'finish'. \"\n",
+ " \"Never mention other agents by name.\"\n",
+ " ),\n",
+ ")\n",
+ "hotel_advisor = make_agent_node(\n",
+ " name=\"hotel_advisor\",\n",
+ " destinations=[\"travel_advisor\", \"sightseeing_advisor\", \"human\"],\n",
+ " system_prompt=(\n",
+ " \"You are a travel expert that can provide hotel recommendations for a given destination. \"\n",
+ " \"If you need general travel help, ask 'travel_advisor' for help. \"\n",
+ " \"If you need specific sightseeing recommendations, ask 'sightseeing_advisor' for help. \"\n",
+ " \"If you have enough information to respond to the user, return 'finish'. \"\n",
+ " \"Never mention other agents by name.\"\n",
+ " ),\n",
+ ")\n",
+ "\n",
+ "\n",
+ "def human_node(\n",
+ " state: MessagesState,\n",
+ ") -> Command[\n",
+ " Literal[\"hotel_advisor\", \"sightseeing_advisor\", \"travel_advisor\", \"human\"]\n",
+ "]:\n",
+ " \"\"\"A node for collecting user input.\"\"\"\n",
+ " user_input = interrupt(value=\"Ready for user input.\")\n",
+ "\n",
+ " active_agent = None\n",
+ "\n",
+ " # This will look up the active agent.\n",
+ " for message in state[\"messages\"][::-1]:\n",
+ " if message.name:\n",
+ " active_agent = message.name\n",
+ " break\n",
+ " else:\n",
+ " raise AssertionError(\"Could not determine the active agent.\")\n",
+ "\n",
+ " return Command(\n",
+ " update={\n",
+ " \"messages\": [\n",
+ " {\n",
+ " \"role\": \"human\",\n",
+ " \"content\": user_input,\n",
+ " }\n",
+ " ]\n",
+ " },\n",
+ " goto=active_agent,\n",
+ " )\n",
+ "\n",
+ "\n",
+ "builder = StateGraph(MessagesState)\n",
+ "builder.add_node(\"travel_advisor\", travel_advisor)\n",
+ "builder.add_node(\"sightseeing_advisor\", sightseeing_advisor)\n",
+ "builder.add_node(\"hotel_advisor\", hotel_advisor)\n",
+ "\n",
+ "# This adds a node to collect human input, which will route\n",
+ "# back to the active agent.\n",
+ "builder.add_node(\"human\", human_node)\n",
+ "\n",
+ "# We'll always start with a general travel advisor.\n",
+ "builder.add_edge(START, \"travel_advisor\")\n",
+ "\n",
+ "\n",
+ "checkpointer = MemorySaver()\n",
+ "graph = builder.compile(checkpointer=checkpointer)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 111,
+ "id": "d77921f6-599d-443f-8b15-56b1adafd3a8",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "from IPython.display import display, Image\n",
+ "\n",
+ "display(Image(graph.get_graph().draw_mermaid_png()))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "af856e1b-41fc-4041-8cbf-3818a60088e0",
+ "metadata": {},
+ "source": [
+ "### Test multi-turn conversation\n",
+ "\n",
+ "Let's test a multi turn conversation with this application."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 112,
+ "id": "161e0cf1-d13a-4026-8f89-bdab67d1ad4d",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "--- Conversation Turn 1 ---\n",
+ "\n",
+ "User: {'messages': [{'role': 'user', 'content': 'i wanna go somewhere warm in the caribbean'}]}\n",
+ "\n",
+ "travel_advisor: The Caribbean is full of warm and beautiful destinations. Some popular options include Jamaica, the Bahamas, the Dominican Republic, and Aruba. Each of these places offers stunning beaches, vibrant culture, and plenty of activities to enjoy. Would you like recommendations on sightseeing or accommodations in any specific location?\n",
+ "\n",
+ "--- Conversation Turn 2 ---\n",
+ "\n",
+ "User: Command(resume='could you recommend a nice hotel in one of the areas and tell me which area it is.')\n",
+ "\n",
+ "travel_advisor: I'll get a hotel recommendation for you.\n",
+ "hotel_advisor: I recommend the \"Half Moon Resort\" located in Montego Bay, Jamaica. It's a luxurious resort known for its beautiful private beaches, excellent service, and a variety of amenities including golf, spas, and fine dining. Montego Bay is a vibrant area offering plenty of activities, from snorkeling and diving to exploring local culture and nightlife.\n",
+ "\n",
+ "--- Conversation Turn 3 ---\n",
+ "\n",
+ "User: Command(resume='could you recommend something to do near the hotel?')\n",
+ "\n",
+ "hotel_advisor: I recommend visiting the Rose Hall Great House, a historic plantation house located near Montego Bay. It's known for its intriguing history and beautiful architecture, offering guided tours that include tales of the White Witch of Rose Hall. Additionally, you could explore Dunn's River Falls, a stunning natural waterfall that you can climb, located a bit further but well worth the trip. For a more relaxing day, you might enjoy a catamaran cruise along the coast, which often includes snorkeling stops and beautiful sunset views.\n"
+ ]
+ }
+ ],
+ "source": [
+ "import uuid\n",
+ "\n",
+ "thread_config = {\"configurable\": {\"thread_id\": uuid.uuid4()}}\n",
+ "\n",
+ "inputs = [\n",
+ " # 1st round of conversation,\n",
+ " {\n",
+ " \"messages\": [\n",
+ " {\"role\": \"user\", \"content\": \"i wanna go somewhere warm in the caribbean\"}\n",
+ " ]\n",
+ " },\n",
+ " # Since we're using `interrupt`, we'll need to resume using the Command primitive.\n",
+ " # 2nd round of conversation,\n",
+ " Command(\n",
+ " resume=\"could you recommend a nice hotel in one of the areas and tell me which area it is.\"\n",
+ " ),\n",
+ " # 3rd round of conversation,\n",
+ " Command(resume=\"could you recommend something to do near the hotel?\"),\n",
+ "]\n",
+ "\n",
+ "for idx, user_input in enumerate(inputs):\n",
+ " print()\n",
+ " print(f\"--- Conversation Turn {idx + 1} ---\")\n",
+ " print()\n",
+ " print(f\"User: {user_input}\")\n",
+ " print()\n",
+ " for update in graph.stream(\n",
+ " user_input,\n",
+ " config=thread_config,\n",
+ " stream_mode=\"updates\",\n",
+ " ):\n",
+ " for node_id, value in update.items():\n",
+ " if isinstance(value, dict) and value.get(\"messages\", []):\n",
+ " last_message = value[\"messages\"][-1]\n",
+ " if last_message[\"role\"] != \"ai\":\n",
+ " continue\n",
+ " print(f\"{last_message['name']}: {last_message['content']}\")"
+ ]
+ }
+ ],
+ "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": 5
+}
diff --git a/libs/langgraph/langgraph/types.py b/libs/langgraph/langgraph/types.py
index 2086552f9..850f8ff41 100644
--- a/libs/langgraph/langgraph/types.py
+++ b/libs/langgraph/langgraph/types.py
@@ -347,6 +347,99 @@ class PregelScratchpad(TypedDict, total=False):
def interrupt(value: Any) -> Any:
+ """Interrupt the graph with a resumable exception from within a node.
+
+ The `interrupt` function enables human-in-the-loop workflows by pausing graph
+ execution and surfacing a value to the client. This value can communicate context
+ or request input required to resume execution.
+
+ In a given node, the first invocation of this function raises a `GraphInterrupt`
+ exception, halting execution. The provided `value` is included with the exception
+ and sent to the client executing the graph.
+
+ A client resuming the graph must use the [`Command`][langgraph.types.Command]
+ primitive to specify a value for the interrupt and continue execution.
+ The graph resumes from the start of the node, **re-executing** all logic.
+
+ If a node contains multiple `interrupt` calls, LangGraph matches resume values
+ to interrupts based on their order in the node. This list of resume values
+ is scoped to the specific task executing the node and is not shared across tasks.
+
+ To use an `interrupt`, you must enable a checkpointer, as the feature relies
+ on persisting the graph state.
+
+ Example:
+ ```python
+ import uuid
+ from typing import TypedDict, Optional
+
+ from langgraph.checkpoint.memory import MemorySaver
+ from langgraph.constants import START
+ from langgraph.graph import StateGraph
+ from langgraph.types import interrupt
+
+
+ class State(TypedDict):
+ \"\"\"The graph state.\"\"\"
+
+ foo: str
+ human_value: Optional[str]
+ \"\"\"Human value will be updated using an interrupt.\"\"\"
+
+
+ def node(state: State):
+ answer = interrupt(
+ # This value will be sent to the client
+ # as part of the interrupt information.
+ \"what is your age?\"
+ )
+ print(f\"> Received an input from the interrupt: {answer}\")
+ return {\"human_value\": answer}
+
+
+ builder = StateGraph(State)
+ builder.add_node(\"node\", node)
+ builder.add_edge(START, \"node\")
+
+ # A checkpointer must be enabled for interrupts to work!
+ checkpointer = MemorySaver()
+ graph = builder.compile(checkpointer=checkpointer)
+
+ config = {
+ \"configurable\": {
+ \"thread_id\": uuid.uuid4(),
+ }
+ }
+
+ for chunk in graph.stream({\"foo\": \"abc\"}, config):
+ print(chunk)
+ ```
+
+ ```pycon
+ {'__interrupt__': (Interrupt(value='what is your age?', resumable=True, ns=['node:62e598fa-8653-9d6d-2046-a70203020e37'], when='during'),)}
+ ```
+
+ ```python
+ command = Command(resume=\"some input from a human!!!\")
+
+ for chunk in graph.stream(Command(resume=\"some input from a human!!!\"), config):
+ print(chunk)
+ ```
+
+ ```pycon
+ Received an input from the interrupt: some input from a human!!!
+ {'node': {'human_value': 'some input from a human!!!'}}
+ ```
+
+ Args:
+ value: The value to surface to the client when the graph is interrupted.
+
+ Returns:
+ Any: On subsequent invocations within the same node (same task to be precise), returns the value provided during the first invocation
+
+ Raises:
+ GraphInterrupt: On the first invocation within the node, halts execution and surfaces the provided value to the client.
+ """
from langgraph.constants import (
CONFIG_KEY_CHECKPOINT_NS,
CONFIG_KEY_SCRATCHPAD,