\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",
- " search (call_LJlkCFfHvAS2taKHTaMmORE5)\n",
- " Call ID: call_LJlkCFfHvAS2taKHTaMmORE5\n",
+ " AskHuman (toolu_01KNvb7RCVu8yKYUuQQSKN1x)\n",
+ " Call ID: toolu_01KNvb7RCVu8yKYUuQQSKN1x\n",
" Args:\n",
- " query: current weather in San Francisco\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 (toolu_01Y5C4rU9WcxBqFLYSMGjV1F)\n",
+ " Call ID: toolu_01Y5C4rU9WcxBqFLYSMGjV1F\n",
+ " Args:\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 8256a9adb..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
@@ -81,6 +93,7 @@ These how-to guides show common patterns for tool calling with LangGraph:
- [How to handle tool calling errors](tool-calling-errors.ipynb)
- [How to pass runtime values to tools](pass-run-time-values-to-tools.ipynb)
- [How to pass config to tools](pass-config-to-tools.ipynb)
+- [How to update graph state from tools](update-state-from-tools.ipynb)
- [How to handle large numbers of tools](many-tools.ipynb)
### Subgraphs
@@ -91,6 +104,15 @@ These how-to guides show common patterns for tool calling with LangGraph:
- [How to view and update state in subgraphs](subgraphs-manage-state.ipynb)
- [How to transform inputs and outputs of a subgraph](subgraph-transform-state.ipynb)
+### 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.
+
### State Management
- [How to use Pydantic model as state](state-model.ipynb)
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": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAIjCAIAAACFxVs1AAAAAXNSR0IArs4c6QAAIABJREFUeJzs3WdcE8nfAPBJaEG6RIogoCIqXURFsJ4iqCDYu6JyngUEEU/v7B3LKSAqKqfYC56ioMJRxF4QRUAFpIl0CCEQ0pN9XqwPxx9DhJBkkzDfjy9kszvzo+SX2dkpOARBAARBEBbwWAcAQVD3BRMQBEGYgQkIgiDMwAQEQRBmYAKCIAgzMAFBEIQZRawDgCSH1sQjVzObGznNFC6Xw+NysA6oA/B4oKiM76GpoKapqKOnrKalgHVEkCjh4DgguUepYxdkUotymhEEKCnhemgpqGkqqmkpclg8rEP7OQVFHJ3KbW7k0ho5PC7gsHl9rdXM7TV09JSwDg0SAZiA5BmTxnsRV0dv5uroKfe1VjMwI2AdUVfVfGMWZVMbatmKSjhnT2IPDdggkm0wAcmtzMeU9ESSsyfRaqQm1rGIXu6bpudxdUPG6ThM0MY6Fkh4MAHJp4ToKgMzVftxWlgHIl7Zzygln5s9f+2NdSCQkOBTMDkUE1pmbq8u99kHAGAzSsvGRfvSvq9YBwIJCbaA5M3Vg6WjvIgmg3pgHYjkVJUwEi9WLd1uhnUgUKfBBCRXEi9V9bVSs3DQwDoQSSv+2PzxZaOHryHWgUCdAxOQ/Mh6SuFykCHju2mnbPYzCpuFOPzSTb99GQX7gOQEl4M8u1vXbbMP2h/0LqWe0SwDg5ugFjAByYkXcSQXT12so8CYsyfxRVwd1lFAnQATkDygNfIaSWy7sRJq/uTk5DCZTKwuF8DSSZPJ4FHq2OIoHBIHmIDkQWF2k5q2hKb1xcXF+fj40Ol0TC7/KS1dpcIsqpgKh0QOJiB5UJzT3NdKTTJ1Cd14QR93iKnt06KvtVpRdrNYq4BECM6Gl3lcDqBTuaaDRT/wh8FghISEPHnyBAAwZMiQ4ODgt2/fhoSEAAAmTpwIANixY4enp2d1dfXJkyefP39OpVJNTU2XLVvm7u4OAGhoaJg4cWJAQEBeXl5aWtqgQYO8vLx+vFy0MRv2JeDxOHoTVxVOE5MFMAHJPEodi8MWy1iK8+fPx8fHr1q1ikgkxsfHq6qquri4LFq06PLly6Ghoerq6iYmJgAADofz8ePHWbNmaWtrp6ambt26tU+fPlZWVmghf//99+zZsyMjIxUUFPT19X+8XOR4PKShjg0TkEyACUjmNTdyxbRKTkVFhaqqqo+Pj6Kiore3N3rQ2NgYAGBtba2t/b3P28jIKCYmBofDAQC8vLwmTpyYlpbWkoBsbGzWrl3bUuaPl4ucmpZic6MsrHUEwT4gOdDcyFHTFMsHyeTJkxkMhr+/f0FBgeAz8/Pzg4KC3N3dp0+fzuVySSRSy0vDhw8XR2wCqGkq0Bq5Eq4UEg5MQLIPAUoqYvk9Ojs7h4WFkUikefPm7d27l8Ph36xIT09funQpi8XasWPHoUOHtLS0eLz/RgOqqqqKIzYBlJTxcHi/rIC3YDJPVV2hkSSukS/Ozs5OTk7Xrl07duyYoaHhihUr0OOtZ/BERUUZGxuHhoYqKip2MOOIdQJQYz2b2FtFfOVDIgRbQDJPTVORJp4uDxaLBQDA4/ELFy7s1atXbm5uS36pra1tOa2hocHCwgLNPiwWi0ajtW4BtfHj5SLX3MjtoQl7oGUDbAHJPHUdRTH1AV2/fv3x48dTpkypra2tra21tLQEANjZ2SkoKBw5cmTatGlMJnPmzJmOjo5xcXF3797V0tK6cuVKY2NjYWFhe22cHy8XediEHngNHbhitGyALSCZR+iBZzF5lcUMkZdsbGzMYrGOHTsWGxs7b968xYsXowe3bNny9evXI0eOJCUlAQBWr149cuTIw4cPHzp0aMSIEQcPHqyrq3v79m17Zba5XLRIlayGWramLvxklQ1wOQ55kJFCZtJ4zt1+MioA4G0SmcPmOU2BPwrZAD8o5EFfa/U3D0kCTqDT6ZMnT+b7krGxcVlZ2Y/Hx44du2vXLtHFyF9ERMStW7d+PK6iosJ30oaxsfHly5cFFEiuZtmN0RFpjJAYwRaQnEi8UNXPVn3AEHW+ryIIUllZyfclHI7/34CqqqqOjtjfyRQKpbmZz9QtFoulrKz843FFRUU9Pb32Siv5RMt+3gDXqJchMAHJiaZ6zu2Ism6+LvLVg6XuSw16GvDJXJB0gp3QckKjp+KgYZr5GU1YB4KZoqxmU0s1mH1kC0xA8mPE5J6ZjxtqSsW73oV0IlezXj6og2tCyhyYgOTKnKA+t8LLuJxud1t99VDp/N9NsY4C6jTYByRveFzk3I6Smf5GOvrd4makqZ5z46/SZTv7KijhsI4F6jSYgOQQwgNXD3119ujV11rOtyf8lk9LvV6zYJOJmKbjQuIGE5DcenK7rrac4eJJNDAjYB2L6NV8Y76Iq9PWUx43qxfWsUDCgwlInlUUMV7E1en1UdE3JfSzVldSkfmbFC4bKcppri5llBfQXTyJxhaSXusDEi2YgORfySda/rum4myqmZUaQU2hh4ZCD03FHuoKXK4M/OoVFPD0Zg6tkUtr4jDpvIJMaj9rtQEOGv1sJLQIPyRWMAF1I2Vf6PVVLFoTh9bEBQAw6SLeRPTNmzeOjo54vCi7YxSV8HgF0ENDQU1Tsae+MmzyyBmYgCCRcXZ2fvTokYoKXAwM6ij47ACCIMzABARBEGZgAoJExsrKCt2cB4I6CCYgSGQ+fvwIuxShToEJCBIZHR0d2AKCOgUmIEhkyGQybAFBnQITECQyxsbGsAUEdQpMQJDIlJWVwRYQ1CkwAUEiY2dnh3UIkIyBCQgSmQ8fPmAdAiRjYAKCIAgzMAFBIqOrqws7oaFOgQkIEhkSiQQ7oaFOgQkIEhk9PT3YAoI6BSYgSGRqampgCwjqFJiAIAjCDExAkMhYWFjAWzCoU2ACgkQmPz8f3oJBnQITEARBmIEJCBIZGxsbrEOAZAxMQJDIZGdnYx0CJGNgAoIgCDMwAUEiA2fDQ50FExAkMnA2PNRZMAFBEIQZmIAgkYHb8kCdBRMQJDJwWx6os2ACgiAIMzABQSID9wWDOgsmIEhk4L5gUGfBBASJzMCBA2ELCOoUmIAgkcnLy4MtIKhTYAKCIAgzMAFBImNoaAhvwaBOgQkIEpnKykp4CwZ1CkxAkMjY2tpiHQIkY2ACgkQmKysL6xAgGQMTECQy9vb2WIcAyRiYgCCRyczMxDoESMbABASJjKmpKXwKBnUKDj62gLpo8uTJSkpKOByupqZGV1cXj8dzudw+ffpERkZiHRok7RSxDgCSeYqKihUVFej/q6qqAABaWlpLly7FOi5IBsBbMKirftyNZ8CAASNHjsQoHEiWwAQEddXs2bMNDQ1bvtTU1FyyZAmmEUEyAyYgqKuGDBkyYMAAtDMRQZBBgwY5OztjHRQkG2ACgkRgyZIlRCIR7f1ZuHAh1uFAMgMmIEgE7O3tLS0tAQAWFhYuLi5YhwPJDPgUTOrQmrh15SwWk4t1IJ0zZezy+m/Knr/MKfhAxTqWzlFWxuv2VlHTUsA6kO4IjgOSIkwaL+V6dWUxw2SQGoPOwzqc7qKHusLXT1R9U8K42XpqmjANSRRMQNKCTuXejigf5W3Q01AZ61i6o4Ya1pNbVd5rjWAOkiTYByQtroSUTlpiBLMPVrT1lKeu7HNxTwnWgXQvsAUkFTIfNdDpwNpFG+tAuru8dAqPyx3u1hPrQLoL2AKSCpVfGera8IEA9tR1lCqLGVhH0Y3ABCQVOEyeZk9484U9jZ7KPA7WQXQnMAFJBRqVy+PBe2HsITykuYmNdRTdCExAEARhBiYgCIIwAxMQBEGYgQkIgiDMwAQEQRBmYAKCIAgzMAFBEIQZmIAgCMIMTEAQBGEGJiAIgjADExAEQZiBCUhWcbnc7GzJ7cUeFn5wxqxJIixw9tzJR4/tF3xOyMGdq1YvFmGlkLSBCUhWHf5rz9HQn7yBZV0PNbUePdSwjgISI7gGjaxiMZkCXkUQBIfDSTAcsVjnt1Ek5cjHT0MuwQQkk0IO7XyUlgQAGD/BEQBw9co9Q4Pey1bM6WvW38ys/+0715lMRsyNhOLigkuXo7JzMgEAgwZarVoVONBiMJPJnD138ojhzlv+3IuWlpmZsX7Dbwf2hTo5jaqsqjh58mjGu9fKyioWAwYtX75m0EDLjgeWnZ35Y43oS1wu9+Kls/H37zAYdHt7RyaDAQAQEExoeEh1dZW1td3xsL8BAFevRcfevdnU1GhuPtBn6W9DHYYDAD59zok8HZqX94lAUHUeOWb16vWaGproDePjJynBQVtPRh4rL/925vSVAeYDxfB7gLoKJiCZtGjB8tqa6srK8j827wYA6PYkosfT018ymIz9e4/R6DR1dfWqqgomi7l4kS8ej797N2bzH+uuXYkjEAiTXKfef3CHRqP16NEDAJCU/EBf32D4cGcSqc5/3XIjoz5+a4NxONy//94PCPSNPHmpb9/+HQysvRrRpBAXf3uy+zQ7W4c36S+aqE0AABUVlfaC2RC09ezZ42ixGe/enI2KmDDBfcQw5zfpL+g0GgCgpKRoQ/AqM7P+v2/cQWkgn4+OrKmp+uvIKfSS5mbq3+dPBgZsZjDo5v0txPN7gLoKJiCZZGxsoqWlXU8m2djYtz6uoKi4bct+VVVV9MuJEye7uk5B/z9woGXQhlXZOZnDHJ08PWb8c/va06epbm4eTCbzydOUuXOW4PH4S5ejdLR7/nX4lKKiIgDAdeKURUu84x/c8V8b3MHA2qsx/0tuXPztRQuXr1i+BgDg5uaR+SEDPa29YIY5OsXEXKYz6GheAwBM95pjZWXbUv7lK3/j8fhDByM01DUAABoamvtDtn/48M7OzgEAwGKxgoO2Dh5sLaIfOSQWMAHJlcGDrVuyDwAAh8M9ffboZszlr1+L0fYFuZ4EADA17WtjY5+c8tDNzeP5i8cMBmPKZC8AwOvXz2tqq6d4jG4pgc1m19ZUdzyA9mp8+jQVADBr1n+7NuPx3x+AtBdMa04jRmloaO4/sM3fb6OT0yj0YOaHjCFDhqHZBwAwbNhIAEBe/ic0AREIBJh9pB9MQHJFlaDa+suLl6LOR0fOnDF/pa8/qb5u1+7NPOT7foeeU2eEHNpJItUlJT8Y5TKuZ09dAEA9mTRy5OiVvv6tC1FTU+94AO3VWF1Tpa6urqWpxfcqvsG0pqtLjAg/d+LU0T+2BFpb223feqBXL73mZqq2lk7LORoamgCAurra7z8K1R4dDxvCCnwML8MEb6nEZDKvXjs/dYq339oNNjb2loNtWr86ZswENTX123eup6e/nDZtFnpQQ0OTQmkwMTFr/U9Xl9jBeATUqK2lQ6VSWSwW3wv5BtOGiYnZwQPhfx05VVxccPDQTgAAkajX2EhpOYFMrgcAqP9/gwiSCTABySoCQbW+nsTjtbuDM4NBZzKZFv//EIrS2AAAaDlfRUXF1XXKtesXjIz6DLF3RA86OAzPyfmQl/+5pRA6nY7+R0lJmU6ncTiCtowQUCN6MCU1ge+FfINpA01eDkOGOTmNzv+SCwCwsrLN/JDBYHzfRefJkxQAQJtOMUjKwVswWWVn6/Aw4d7RY/ttrO01NDSdnce0OUFLS7tfP/Pbd6737KnbTKVeuHgGj8cXFRW0nOA5dcbt29c9PWa0HFm6ZOWrV882/r52zuxFOjo937x5weVx9+7+CwAwwHwgg8HYuXvT6lXrjXob8w1JQI3jx7leuhx19Nj+4uLCAeYDP37KarlXai+Y1j7nfty1e5O31xxV1R5v3rxARwYsWrA8NTVx0x/+nh4za2qqLlw8M8Te0d5uaNd+rpBEwRaQrHJ1nTLde07a46QzUcc/fsrie862LftVCaq79/xxI+bS6tXrFy9akZgYx2Z/33bGzKyf49ARkyZ5tJxv1Ns4IvyclZXtlavnTpz8q4FCnjhhMvrShAnuc2Yvys39WFJcKCCq9mpUUFA4eOC4o6PTvbhbkWfC8Hi8ltb/bAP7YzCtKSspm5r0vXr1fFRUhK3tkOAN29BHgYdCIths9qHDu27cvOQ6ccruXUfggEPZArdmlgo3/vo2fLIe0UgF60C6O0odO+1mxaI/TLEOpLuAt2BQ51Cp1PkL+bdTflsZ4DF1usQjgmQYTEBQ5/To0ePM6at8X9LU4P+UHYLaAxMQ1Dl4PN7QoDfWUUByAnZCQxCEGZiAIAjCDExAEARhBiYgCIIwAxMQBEGYgQkIgiDMwAQEQRBm4Dgg7NXW1rZM6YakR3l5eXFxcWFhYV5eXkFBQX19fXJyMtZByRuYgLBBo9FycnKGDx+em5sbGBg4y+ko1hFB3zU30zZs2FBZWUmj0ahUKplMRo/36tUL69DkELwFk6h3794BACgUipubW1paGgDAzMwsISFBQwMuoyUteDzeq1ev8vLyysrKGhoacP8vIYH/YkZQV8AEJHafP3+m0WgAABcXl3PnzgEA1NTUnj59+vvvv6NLFwMAtPWU4aIE0gDhIabmur/++qu29v+sFsLj8XJycgQs/wYJByYgsSgpKamrqwMA+Pj47Nu3D/3Dff78eUREBAAA3XOiNUIPPKkcdgNhj1TJVFLB+fj4BAQE6Or+tzS1iopKcnLyiBEjqqqqAADFxcWYhik/4HpAIkMikRgMhpGR0Y4dO3JycsLCwoyNjel0euttKvhKSEj4lscwIzo7eehJKliIv7f/1vUZQDC3V0c/MPbs2YN+kBgYGMTHxwMAGAwGgUD49ddfv3379uDBAx6PR6fT4R200GAC6hIajVZUVGRtbX3z5s2UlJQ1a9bY2dlRKBQtrZ8sTMHlcp8+fTpu3LgvX75cuHBh7ty5lCJDFhMMc+voCvCQyL1PreeyuePn/NfZ/OnTp82bN5eVlaGdd63V1tYSiUQmk+nu7j58+PBDhw617K0IdRxMQMLIzc0dNGhQfn7+ihUrli9fvmzZsoaGhja9BnxxuVw2m00gEJydnadNm7Z58+bWr76IJ9EaeURjQi8jAg7eHEsKwgN1FYz6ShYOzxs3q+2jrtra2kWLFiUmJgoo4cuXLwMGDCgpKVm4cOGyZct8fX2pVKq6eie2M+q2YALqqJKSEjMzs48fPy5fvnz69OmbN2/u7Cfe8ePHL126lJiYqKOj0945RdnNhR+oLCaPVMF/B5uOoFKpSkqKKioEoUsQB2pTEw6P69QuY8Ih19fzEF7L4tA4HA4HcACHAwDw/ZAg9lZWVMb3tVYbMKSrsTEYjPz8fFtb29jY2Ojo6N27d9va2vJ4vJZdGKE2YAISpKGhQV1dHY/HT5482cLC4vjx42QyWUND48de5Pbk5uaeO3fOzc1twoQJ7969c3BwEGvAXC43MzMzNzd34cKFHThdonx9fT99+jR16tQtW7aItaIHDx6Eh4ejfTctu6fhcDgEQTIyMsRadWvfvn3jcDh9+/bdvHlzQ0NDcHCwubm5xGqXFTAB8cHhcBQVFVevXv3ly5f4+HgVFRUSiUQkdqJ3Jjk5ua6ubt68effu3VNTU5swYYI44wVo6tm2bduOHTsUFBQ6nh8lac6cOYWFhQoKCi4uLseOHRNrXdu3b09ISGj91FzC2aeN9PR0dXX1wYMHb9u2TUVFJSgoCPYWoWDL8Dt0MsTx48ddXFzQ/wcFBSUnJxMIBBwO18Hs8/btWwBATk5OcnKyjY0NAGDatGkSyD4AgD179owdO1ZFRUU6sw+a1nE4HI/He/r06ZIlS8Ra19atW01MTFof6dTnh8gNGzZs8ODBAIANGzZYW1s3NzcDAAIDAy9fvtzNWwAwAYH09PS5c+c+e/YMHSuYkpKCdh8OGDCggyVwOBwajebk5PTixQsAgLW1dUhIiJWVlZgDBwCAqqoqdGzRzp073dzcJFCjcKhUaut32sePH728vMrLy8VUnbKycmBgYM+ePdEvcTjcxo0bAQBNTU1iqrGDtLW1vb290VkdPj4+dXV16GazR48ezczMxDY2THTTBFRXV7d58+Y9e/agY5H37ds3ceJEAICDgwM6NLmDzpw5M3bsWDabraio+OzZs3Xr1okzaj4OHDjg4cF/kxyp0tTUxOVyW77E4XDl5eWrVq0SX42jRo0aO3Ys2vtrZGSE/n79/f2vXuW/pYfk2dvbBwYGKikpAQBMTEzi4uLQ1Hz//n0mk4l1dBLSjRIQh8O5ePHirl27AACNjY0TJkxAn4Lb2Nh0qnewvr7+1KlTBQUF6Eyu+/fvq6qqKisrS/LeJycn59q1awCAsLAwMzMzidUrtObm5pYdWVEIgrROSeKwZcsWU1NTJSWl2NhY9Eh0dLSysjIA4P3792KturNmzZq1bds2AICent7r16/RKTvv3r2rrKzEOjQxQ+RdZmZmZGQkgiDV1dWhoaG5ubnClcNisd6+fYsgyNmzZ8+ePctisUQdaUcVFRUtWbKksbERqwCEkJmZOWnSpKFDhzo4ODg7OzMYDGzjSU1NnTZtGp1OxzYMwVJTU6dOnfrixQsEQSorK7EORyzkNgG9fPmSy+Uymcxly5Zdu3ati6V9+/ZtxIgRDx48EFF0Qvr48SOCIGVlZdiGIZwxY8a4u7sjCBITE7N//36sw0G+fftWW1uL/gfrWARBP2l27do1a9YsNGB5Im8JCG2YuLm5rVmzhsfjdbG0S5cuLVmyBEEQMpksogCFl5qa6uPjg3UUonHw4EGsQ/iPl5dX1z+iJKCwsLCurg5BED8/v9OnT3M4HKwjEgH5SUDoE3T04wJ95iK0jIwMNOOcPHlSGpq+zc3NCIKkpaVhHYjciouLQ9/hWAfSIaWlpZGRkeif6OXLl6XhT1Rosj0QsaCg4Pr1615eXjY2NmlpaU5OTp16hsXXli1bampqwsPDfzqLXTKeP38eExMTGhqKdSCiVF5enp+fP378eKwD+R83btzIyclBn43KisjIyIcPH969e5dOp+NwuK7//Usa1hlQGLm5uVlZWWgL5fbt21wut4sFNjc3h4eHP378GEGQ8vJyEYUpGnv27ME6BNHj8XhDhw7FOgo+7t+/TyaTKRQK1oF0WmNjo4uLS1hYGNaBdI4sJaCmpia0C3P+/Pn5+fkiKRNtvkZFRZ0/f77rfUaihd4XyKtHjx5VVFRgHQV/RUVFBw4cwDoKYbx58wZ9AhMWFkYikbAO5+dk4xasvr5+x44d/fv3DwwMrK+vbxnh2hXNzc2bNm2ytrYW63A44SAI4urqevHixd69e2MdSzcVExODw+FmzZqFdSDC4HA4V65cYbPZvr6+nz9/RmeBSCmsM6AgRUVFZ86cQRDky5cvz58/F1Wxr169QhCkpKQEHWEhbRobGxsaGqThuZtYFRcX37t3D+soBEFb3I8ePcI6kC5JTEx0cnLKy8vDOhD+pHQkdENDAwBg27ZtBgYGAABzc3NnZ2eRlLxjx44rV64AAExNTUeOHCmSMkUoPz//2bNnWlpaHVneTKYhCHLhwgWsoxAEnRKYkpKC7l8ioyZNmvT48WN08v3evXsfP36MdUT/C+sM2FZqaqqLi4vIe4Kzs7PRx9hfvnwRbcmiNW/ePKxDkBAOhyPlLaAW0tlSFkJ2dvbGjRsRBJGeAY3SkoBev34dExOD9p/RaDTRFv7+/fulS5dKzw8dkkX+/v5YhyAyFRUVjo6O0jCyTCpuwTIyMs6fP29nZwcAcHJyEuEAnBMnTgAAevfuHR0dje2KMILR6fQ1a9ZgHYWkHTt2rM0MVWm2fv16uRmNZWho+Pr1azU1NQBAfHx8WVkZZqFgmPyuXr26dOnSlpG+Irds2TK0VSX90Kd7WEchadI5FEgAtFtazmRlZXl5eZWUlGBSOzYJCJ1Oefz48YaGBpEXXllZ+fDhQwRB2Gy2yAuHRIXNZv/zzz9YR9FpTU1NctlPhz513bNnj4R7KiR9C5aVlTVs2DB08JGfn99P98/qrNra2hUrVtjb2/PdgFQKFRUV3bp1C+soMKCoqDhjxgyso+g0dXX106dPR0ZGYh2IiKFPXYcPH75v3z50JJFk6pXcQMTHjx+PHTv2/fv3dnZ24tilpL6+nsFg4PF49Mm9rJg3b97evXu74X4JmZmZhYWFM2fOxDoQiA90RbTly5eLuyJJtIAYDMaUKVNqa2sBAEOGDBFH9ikoKJg7dy6RSJSt7NPU1BQaGtoNsw8AIDY2Fl2cUEYlJCTITZ/0j5YvX06n09FNFsRKvC2ggoICTU1NFRUVBoOhr68vvorQ5pX4yodETlSrF2AoNja2d+/ew4cPxzoQcWGz2UpKSn/88ce2bdvEtY+Q+LqXHj16NHfuXCaTKb4qEARZs2aNWMsXq9mzZ8vEjEGoO3v58mVAQICYChfLLVhWVhbarXX9+nWxNrO3b9+Obrcii2g0WmVlpUgm1sqc48ePp6enYx2FCNTV1aHbHMgxJycn9GbzwoULIu+cFv0t2MmTJ3E43OrVq0VbbBtFRUU9e/bU0tJq2QJc5qDTEdBdWbqV8vLy1atX37t3D+tAROPixYssFsvX1xfrQMSuuLj44MGDon0CKMoERKFQtLS0kpKSXF1dRVUmX5WVladOndq9e7dYa4EgiC8RLvEhsluwe/fuJSUlAQDEnX0AAI8ePZKP7DNx4kQajYZ1FBLFZDILCwuxjkLE6uvr0W6HbgKPxwcHB4umKJGUQqVS379/L4HVm5hMZklJyYIFC8RdkWQMHjw4JycH6ygkavny5TI0/6uDevbsefTo0ezsbKwDkZCBAwdOnTq1tLS060WJ4Bbs0aNHI0eOlMDzVDabPXr06FevXom7IkhMPnz4QKVSXVxcsA5E9CorKz9+/IhuAN1NsNns5OTkyZMnd6WQriaghQsX/vXXX5IZ/vfq1St7e3uZHjnSBofDqa+v19PTwzoQCBIGi8VydXXtyiJnXboF43K5LYsWihuFQpGz7IPOh4qMjLx79y7WgUhCYGAaoXmDAAAgAElEQVQglss+iN/Tp0+vX7+OdRQSpaysfP/+/a6UIHwCSklJYTKZgwYN6kr1HZSUlHTgwAE5yz6owMDA7tANdOnSpenTpxsbG2MdiBiNHDny2LFjWEchaerq6lQqNTY2VrjLhbwF8/HxCQ4Otra2Fq7WTuHxeOHh4YGBgRKoC4K6or6+XkVFBV3oq1t59uzZrVu3hJgcJ0wCampqUlFRkemZhNLm1KlTs2fPluY1G4VWUVERExMTEBCAdSCQeDEYDABAZ29TOn0LlpOTU1paKrHs8+XLlyNHjkimLgzNnj170aJFWEcheugQ4W6VfaRtv2mJIRAI2dnZdXV1nbqqcwkoPT09IiLCysqqk7EJb9++fW5ubhKrDitEIvHhw4c8Hg/rQERMWVn5wYMHWEchUfb29k+ePME6CmzY2Nh4e3t36pLO3YLl5+dbWFh0PjCoQ7KyslgslqOjI9aBiMaVK1cmTJggWys0QV1UU1NDJpMHDhzYwfM70QIik8kmJibCBiaM0tJS9Maym7C1tX3y5Am6b6Ks2717t6WlZTfMPlwuF91Ws3vS09PrePYBHV8P6Pnz535+fmJaE4SvnJycxYsXS7JGKUGhUOh0esuXkyZNCgsLwzQiqHPGjRtHoVCwjgIzubm5HX/ndrQFlJOTs3//fiGzolDy8vKCgoIkWaOU0NTUfP36dW5uLgDA29u7rq7u5cuXWAfVCfHx8ZmZmVhHgSU3N7eioiKso8DMwIEDXVxcOrjek+QWpYc65dSpU7GxsSQSCV3a7ciRI+hWH1Lu9OnTJiYmXZwfBHUfHWoBbd++XcKrRhQUFHTbRwmo+/fvo9kH7X1LTU3FOqKfYzKZv/32G8w+TU1N8j3ppCOePHlSXl7+09N+noBiY2OVlJTEtSR1OyIjI7lcriRrlCoeHh5VVVWtj0hgf4IuOnfu3KNHj7COQiqQSKRuNfSJLwUFhYMHD/70tJ9v3Tds2LCpU6eKKKqOGj58eLcd0LVs2TJ0C+CW1WZxOFxNTU1mZqbU3oWlpaUNHz5cMlNzpJ+ZmZmEP7ClkIuLC5lMbm5uFjwxBfYBSaMHDx6kpqZ++/atpqamqakJfVi5cOFC6eyVZ7FYeDxeJvahhaTNTxLQgQMHBgwYIIGlDltLTk5WUlKS5D5fbBZCa5TQXrQdRyaTc3JyXr9+XV5eTiKR1NXVT548iXVQbUVGRpqZmbm7u2MdiCBaREmv/F9WVqajo9MNZ6W2Vl5efvPmzfXr1ws45ycJaN68eVFRUerq6mIIr12rVq1asWLFsGHDJFDX59eNH55QGmpZqupS/AGOIDyEx+Mh0tbKQBAeADgp35hEXUexsohuOlht6ESd3v0ktKLL3r17ra2tOzsvQf5MmTLl/PnzAjYllcZbsKdPn7q4uIhjB+c20v8l11aw7Mf21OjZ7fbG6W4otewX96pHTO5pOlgSvTN37tzhcrkSvnWQQhUVFQQCQcDmd4ISUF1dHR6Pl9ed814/rG9s4DpN6YV1IJDkJF4od5ygbWbVre+MpIqgVsbGjRslP5zh7du3Z8+eFXct5Bp2XQULZp/uZsKC3u/TKBKoiEKhFBcXS6AiKVdXV7dq1SoBJ7SbgLhcLoFAsLW1FU9g7Xr//r0ERgDVVTCl79YTEjtFJVwjidVIEvu+QF+/fpWPreu6iEgkFhYW1tfXt3dCu52aCgoKp06dEltg7Zo0aZKWlpa4a6E2cHoZy+EK09BPGZn3INeyNHXF2+tnYGAg3wtgd9yNGzcEjIpqNwFVVlbSaLT+/fuLLTD+TE1NJVALm8FjdaN1PqD/NDdxeeIfY6+np7dnzx6xVyMLBHcit3sLdvHixYyMDPGEJEhgYKCABhsEyQpM3j5S6MGDB2FhYe292m4C0tLSGjJkiNiiatfLly81NTUlXy8EiZa/vz+TycQ6CuwRiUR0bRm+2r0FE9x3LSZcLvfSpUvSNtwOgoQwfPhwNputoqKCdSAYc3R0FLB7YLstoJSUFLGF1C4FBQW45jQkH0JDQyU8hUA64fF4Afc0/BNQfX19SEiIOKPir7CwcO/evZKvF4JErrCwEN6CoaZMmUKn0/m+xD8BsdlsDw8PMUfFR3V1dXV1teTrhSCR27ZtW0lJCdZRSAUFBQUymcz3Jf69Lfr6+pisqGRpafn7779Lvl4IEjkLCwvYm4m6ceNGe31h/H9AtbW15eXlkl/+SltbW1tbW8KVQpA47Ny5E+sQpIWAgYj8b8EyMjJu3bolzpD4S01NvXjxouTrhSCRKykpkfBK6lLrzz//bG9nF/4JiEgkSmY5njaqq6tramokXy8EiVxISMjHjx+xjkIq8Hg8KpXK9yX+t2COjo6YbBA8adIkDkfqViaEICGYm5urqqpiHYVU2L17d3vLe/E/WlRUlJeXJ+ao+NDV1RWweJoUCjm4c9XqxYLP8fQadyoylO9LXC43O1sse/gVFRVM8xr/7HmaOArviPsPYsdPcCSR6gScg3mQYhUcHAxX6UcpKyu31x/PPwE9fvw4KSlJzFHxcffuXUz6noTWQ02tRw/hV7c6/Neeo6Fi2W9WUVFRXV1DUUGqn8LIRJBC+/btW3v3Hd3N4cOH4+Li+L7E/3ffr18/Nlvsa6b8qKamRra2A1vnt7G9l8rKSo2NTQRfzhLbQDUTE7OrV+519ioKpQGHx2tqSGgunnBB/qj1FkbS4+jRozNmzBg9ejTWgWCPy+W2NyaTfwKS5I4UrU2bNk0K/5JQV69Fx9692dTUaG4+0Gfpb0Mdhs9b4FFdXWVtbXc87G8AAIlUdzzicEbGa0UlpaFDRzx5knL61OW+ffsDAKjUpn0Htj1/nqalqT1v3lKvabMAACGHdj5KSwIAjJ/gCAC4euWeoUHvV6+enYk6XlFRZmDQe5rnrBnT5wIAGAxG1N8nUlITWCxmH2PTOXMW/zJ+EhrV+8y3Z6MiCgvzdXR6DrEf5rtira4uMSEx7uChXQCAw4dOOA4d8aUgz3/d8pD94WeijhcW5uvrG/726zoXl++/4sTE+CvXztfUVPU164/D4w30DbdvO9DeD4HFYl28dDY1NbGmtlpXlzjJdarP0t8UFBTQV78U5B2POJyX90m3J7FPn+/Lqly/cfH0mfCL0f+0HFkf9BudTvP2ntM6yG/fvh4LPfA5N0dDQ9NpxKjAgM14PJ7D4ZyPjkz8N55CaTA17euz9LdRLuMAAGmPk3ft3rxn15EbMZdycz8umO+zzAeDqYuC9enTB07FQG3YsKG99zX/W7DCwsKCggIxR8WHvr6+np6e5Ov9qYx3b85GRdjaOgQF/mmgb0in0QAAG4K2DjAfiJ7A5XL/3BL48VNWQMDm+fOWPn6cbG83FM0+AICHCfcUFRTXB/5p1rd/aFhIVtZ7AMCiBcsdhgwzNOgdHhoVHhql25NIo9F27t6krKS8IWir88gxJFIt+gRhy9b1L18+Wbhg2frAP83NB+7Z++eDh3fRqH7f5Gdm2i94w7Y5sxZlZb0LCl7FYDCG2A9b+at/6/iZTOauPZtnzVwQevSMgb7h3v1bKJQGAMCz52khh3ba2Tps/XOfkrLy5885s2YuEPBzUFBQyMh4PdJ5zOpV6x2GDL985dw/t6+hL5WWlqwPWkmqq/3V12/27EX5X75PgHZ381RUVExOeYh+WV1dlfkhw9NzZpsgD/+1p6i4YO2aDbNmLqitq0H7LI/8tffGzUseU6dv+XOvgUHvbduD0R8dKuz4QY8p0w8djPCYOkNEv2dRCgoKwmQ9CSmkpKTUXh8Q/6PoTFRzc3MxB9ZWbGwsgiDTp0+XcL0/VVVVAQCY7jXHysrW1XUKenCYo1NMzGU6gw4A+Pw5J/9L7o7tIePGTkTfjQ8T7rFYLGVlZQDAJNepm37fAQAYPWr8nLmT0x4n2doOMTY20dLSrieTbGy+D/israthMpmjR//iOvG/7dWfPE3Nyn5/7UockdgLADBxgjudTvvn9rUpk72ORxz29Jixzv/72HFHR6ely2alv305etR4O1uHNt+Cv99GtN3k6+v326pFH7LejRn9y927MWZm/TYEbQEADBpkNXvu5Fevn1la2rT3c1BQUDh54kLLp1lFZdmTp6lzZi8CAESeCcPj8CciorW1ddApiKFhIQAAbW2dUS7jkpMfoo2U5JSH6urqE35xJxAIrYOsqqqwGDDIY+p0AABaYGlpSeK/8UsW+/os/Q0AMHbMhEVLpkdfOH30r0j0kunec93cMJgw1EHl5eVaWlqwEQQACA8PNzY2njGDz+cE/wTUv39/TLbrqa2tlXylHeE0YpSGhub+A9v8/TY6OY368YSa2moAQO/e31fhNDY24fF4dDoNTUBaWt+HdxMIhN69jdGTf9Tb0MjKyvbylb8JBFVPjxnota9ePeNwOAsWTWs5jcvlqqmpV1VVfv1aXF7+Lf7+nf+JpIZ/4aqE74+E9fUNAQB1dbVo2C0dVURiLwKB0NTUKPhHQSbXX7x0Nv3tK/RMDXUN9CYxPf3ltGmz0OyDdjC3XOLhMSN445qcnA/W1nb/Jt13dZ1KILRdD9d14pSr16LDjx9avMhXR6cnAOBD1jsAwKhR33foxuFwwxydkpIftFzi4DBccKjYCgsLmzZt2qhRfP5auhsOh9Ne3y7/BDRhwgQxh8Sfp6cnJvX+lK4uMSL83IlTR//YEmhtbbd964Fevf7nVtHIqA8AIDs702LAILRBRCT2ask7reEVFNr7ZeBwuJD94VF/R0SeDo25dfmPTbvt7BzIZJKuLvHokcjWZyooKpLJJADA0iUrx4z+pfVLPXsSBX8vSopKAAAej4tmzLy8T2hLraiogMFgmP//TSVf9fWklasWqqr2WL5sde/exufOnfxW9hUAQKqv43A4hga9+V7lMGSYkVGf5JSHikpKpaUlu3Yc+vEc3xVrdXR6Xr5y7mHCvZW/rpvuPae5mQoA0NH+b0FPTU0tGo3W3NyMftlDVar3XycSiXCHeNSaNWtaOgrb4J+ACgsLEQSR/C2YgYGBhGvsOBMTs4MHwt+9T9++I/jgoZ1HDv/PLskDLQYPc3Q6cza8urqygUJ+/uLx1i37OlJsm5amurp6YMDmOXMWb9u+Yeu2oBvXH2hoaDY0kPX1DdtM5+NxuQAAJpNhYmIm9Dc1f+7SoOBVQcGrhjoMT0p6MGigpdskQTc19+L+IZPrTxyP1tc3AADo6RmgCUhbSwdtHPG9CofDTZ3iff3GRQRBbG2HmJn143vOrJkLJrt7HQvdH378kHl/CyJRDwDQ2EhB7z3R9KeoqPhj60k6wWnVLQT8yvh3QqekpKSmpoozJP7u3bt39+5dydfbESwWC/0wd3Ia3dLD2pq/30ZjY5NvZV+1tXQijp9HO4MEIxBU6+tJPB6v5Qj6tLK3odGM6fOozdSqqgoHh+FcLvde3H/Do9ClVYyNTfT1DR4m3GtZaYXD4XR28IS1td3MGfN5PF5FRdncuUtCj50VPIG7sbFBW1sHzT4AAEpjA5pA1dTUjIz6pD1Obi+Aye7TaLTmuPjb0zz5bxaKfuNqamo+PqsAAPlfcgcPtsbhcK9eP0NPYLFYr14/s7Kybe+zVNrU19czGHDnA4D2Ad2+fZvvS9LVB1RVVSX5Sjvic+7HXbs3eXvNUVXt8ebNi0EDLducwOFw1vgtnT1rkZFRHxwO19TUSKVSf9oBaWfr8DDh3tFj+22s7TU0NIcNG7l02cxxY137mvW/ezdGXU29d2/jPn1M4+JvR54Oq6yqsBgwqKAg/9nzR9HnbhEIhLVrNmzfsXGtv880z1k8Ljfx33hX1ymCH2O1EXPryvv36XPmLMbhcIqKimVlpf37DxBwvr29453Ym+fOn7Kysnv6NPX16+c8Ho9CadDS0l66ZOX+A9v8/Je5u0/D4/EtT8dQaFf0+8y3bW4YW+zcvUldTd1xqBOacQZaDDbqbew2ySP6wmkul9u7t/H9+3fq60l//iEzW03s2bMHjgNCMRiM9j6ZpK4PSAr3qgcAKCspm5r0vXr1PIIgdvZD1/m1bV0rKio6DnW6dDmqZS6bhrpGeNjffG83Wri6TsnL//Rv0v2Xr566u3la29gPsR+WnPKwuZnat6/5/n2haNv18METZ6OOp6YmxsffNjY2meY5C22njB41/sC+0PPRkSdO/qWmpm5rM8T2h4dfgg20sIy5dWXf/q0tRzw9ZgSt/7O988eM/mXJYt87sTdjY2+OdB5zIiL6QMj2O7E3fJb+5jpxMpXadPPmpdNnwsxM+1la2nz79rX1tR4eMwwNjZSU+G/INXiQdeK/8U+ephKJehuCtlhb2wEAAgM2q6mp34m90dTU2Nes//69xxyGYDBHWjgaGhroYwRo3bp17bVb+e8Nj1UfkMS8SahnMoD9eFFue8/lctGfMoIgFZXlvr/OmzN7kRQOkGujJWwWi3X6bHhs7M3Ehy/keCWt1OuVtqM0+8Lt4aWDdI0DSkxMbG5u5jteQMoxmcw1fkv19AzsbB2UlJSzs98zGIz+/aV9gf1//70fde7E+HGTDA2NyGTS06epZmb9zkdHtu5yaqGpoXXlspT20EkhOp0uYABetyIz44BIJFJlZaXk6+06HA43yXVqamri+ehIZWXlvn3Nd2wPaa+/Q3qYmvWzsbZPTnnY2EjR1SW6OI9dtHCFopKShwefvxU8rt09VKAfbdy4cdGiRU5OTlgHgj0BfUD8b8GwUltbS6fTTUx+Moez68RxCwbJBIndggUEBCxevBiTdbWkDYPBUFBQ4Nv9J13jgHr16iXhGiFITATsR9zdyMw4oIyMjFOnTkm+XggSOR6PJ1W3FxgSMA6IfwLq379/v36Cnh+LCZfLzcrKkny9ECRyK1eu/PDhA9ZRSAWZGQdkY2OzYcMGTKqGINFis9nwERhKwDgg6eoDUlVVlePBR1C3cuHCBaxDkBYy0wfE5XJXrFgh+XohCBIfmekDUlBQ+PbtG4lEknzVECRa3t7eZWVlWEchFWSmDwgAcPLkSbiKCiQHOBxOexuidzcy0weEyfwPCBKH+Ph4rEOQFjLTB4QuC93e7SIEyRB0ASlIlvqAAACamprt7WMvQsqqeGVVOLOpO1LTUlRQEPvWT2w2e8yYMeKuRVbIUh/Q6NGjJXAXpqGj9O1Vo6UTnzWbIfn2Lbd5hNv3lfNra2uLioo+f/6cnZ1dWlqqqqp68eJFkdTCYDAMDQ1FUpQcgOsBtUUlc9Ju1Y6dA/9Euhcmnff8bhUwSM/Ozs7NzaXRaI2NjSQSCd2GLCMjA+sAux3pWg8IFRISMnr0aBcXF/FVoa6jaGyh+uRW9ZhZ+uKrBZI2SRfLx83qtdA3jEKhoIuooIM/AACifWLFZrNJJJI0b7IgSQLWA5K6PiA08T19+lTctdiP1e5n3SPlSkVdOZPDgpMG5RmjmVtTyoiN+Dphgb5hP8Lhw4f19fXbbBaso6PT3nZJQsjIyNizR2aWrxY3mVkPCMXj8eh0upqaJBbN/PqJlvm4obKY3t6W9AiCcLlcPF4Bj5fSTes7C0EAj8dTUJCrPvj//r4R0PoPWllZSbOXMo3MMbFUc3TV0dH7viRNaWmpv79/eXn594sQJCMj49OnTyEhIXPnzp06dWoX43nx4sW7d+/8/Py6WI58ELAekJT2ATEYDBUVlfY2tBcHNvN/fg7v3r2j0+kuLi6xsbE6Ojpjx46VWCTiVltb+9tvv8nTWAcKheLv719SUtLmuK6u7p07dxAEKBP4/CFxOJzly5fn5OTg8Xg0AQEAPn78WFlZOXHixIcPH969e9fHxwcuaShW/BPQmTNn0PUEsAgJAACio6OpVKrkP0DKy8uNjIwSEhJiY2MDAwMHDRok4QAkgEqlXr9+3dfXF+tARKmhocHX17d1DmrJKYIFBAS8efMGj8c/f/68zUvp6el0On3MmDEXLlzIyspatWrVgAGC9ixqjUKh4HA4TU3NTn4f8knG+oAAAF5eXjk5OZKskUKhzJ07Nzo6GgAwbty4yMhIucw+6OarcpZ9AADa2tonTpzo06dPyxF0SxxfX9+EhAQBF4aFhXl6euro6Pz40rBhw9CxPAsXLvT09ET7rY8cObJ9+3YqlSo4niNHjjx79qwL35BcEdAHBJDuLSkpac+ePQiC1NfXf/nyBetwJKG5uTk+Ph7rKMSisLDQy8tr6NChQ4cO9fLyQhDk3bt3ERERCIIUFRUlJSV1vYqmpqb4+Pjq6moEQXx8fA4ePMhisX48bfPmzdnZ2V2vTj7Q6XS+PyUEQfgnoIKCAszfjSQS6cOHD2IqPCkpKScnB0GQv//+OysrS0y1SKeamho3NzesoxCXT58+eXh4DB06tM3xhoaGTZs2bdmyBUGQ0tJSkdRVWlp6/fp1KpWKIIifn9+lS5dEUmy3wj8BnT59+vTp0xIPpq2lS5eKNjtUVlYiCLJ9+/bff/+dRCKJsGQZwmAwEhMTsY5CjDIyMlxdXfm+xOFwEAT5559/JkyYkJeXJ8JKs7Ozz58/jyBISUnJ77//fuvWLREWLuvCwsL++ecfvi/xT0DJyckiaa92UVlZWUpKikiKKigomD59ekxMDIIgbDZbJGVCsqu+vh5tB+3fv//ChQtcLldUJfN4vOvXr48fPx69JQwLCysuLhZV4TLq4MGD169f5/uSNI4DEqG0tLTc3NxVq1bl5+erqKiYmppiHRH2uFzuzZs358+fj3UgUqGysvLmzZsLFy4kEon//vvvpEmTul7m+/fvk5OTN27cyGAwbty4AQBYunRpQkICj8ebNGlSN1woWsA4IOntA0JVVlYGBQV19qrq6moymUyn04OCgtC+Hqi1kSNHMhgMrKOQOps3b0a7rpubm0Ve+JcvX7Zu3Yq26BMTE79+/SryKmSRVPcBoaKiom7cuNHx88+fP+/u7k4mk9GNmaAf3b17l06nYx2FNELzcmZm5pIlS4R+BlJQUFBbWyvghJiYGG9vb/QeUEo+6cVKQB8Q/1swNE9PnDhREu0zEbl165aioqK3t/fnz58HDx6MdTiQbMvJySkrK3N3d09LSxswYICRkVHHr505c+Zff/1lZmYm+DQWi6WsrBwQEFBYWHjnzh3+dyhy4dChQ6ampnPnzuXzmsSzoTAaGhru3bvH9yX0k/z27dv79+9vaGiQeGgyKS4urjt88IpEenq6p6dnxwf1MBiMDRs2dKqKyspK9MGIp6fn8ePHhQpTqgkYBySlc8F+FBcXl5GRsXPnzpYjHA7n0KFDTU1NBw4c4PF46JIuUEdERESoqaktW7YM60BkBplM1tHRCQoKmjRpkru7u5hqqa6uTk1NnT9/fkNDw/Xr16dNm9a7d28x1SUlFFq/pVvcunWruLh46NChWITE38CBA0eMGMHj8RQVFcvKynr06FFeXs5isfz9/VsWdoE6iEgkEgiE1hMXIMFUVVUBAAMGDIiPjx8/fnxDQ0N7C62XlZVRKBQtLS0halFXV7exsQEAKCkpZWVlxcXFTZo0qaqqCofDoTNLZFR4eHh5eTnfjhEpnQvGl6qqakZGRmhoqJ+fHx6PNzU1nTlzJtZByaR+/fo5OztjHYXs6dev365duwAATCbTzc3t/fv3P56zc+fOurq6LlakoKDg6+t75MgRAACdTp88eXJMTEwXy8SQPMwFa25ufv36NYIg8+bNe/PmDdbhyLz9+/czmUyso5BhtbW1Dx8+RB+ZtRxks9nobA+R+/z5M4IgFy5ciIiIoNFo4qhCfAT0AfFvARUWFhYUFIg3K3ZGSUmJm5ubtrY2AODatWsWFhZw99QuIpFIPy5AAXUckUhEO4Nyc3OXLVuGbsKjqKi4d+9ecVSHrs0wZ84cVVVV9BeXmZkpjorEgUAgtPeMT0rXA2qRlJTk6upaUlLS5qEmuo1B11eu67a+fv1KpVKtrKywDkQeZGVl6evr4/H4wsJCAwODnz6AF4nQ0NCUlJQ7d+5I/9Bq2VsPCLV///709HQAwI+/URsbm9evXzc0NGAUmswzNTWF2UdUbG1t9fX1VVRU1q5dK7HhPIGBgeho4bKysiNHjjQ1NUmmXiHI2JrQ6JK6zs7OX758EbwGHYlEIpPJUjVcQIaEhYW5ubnJ67prkldWVpafn89gMKZMmSLhqq9du1ZRUbFhwwYSiaSrqyvh2n9KwFwwqesDYrFY3t7eaKvypytg6urqEonEX375RZrTv9QaPHjwhQsXsI5CfhgbG//yyy9o9tm9e7ckq54/f/6GDRsAAImJicHBwT9dsFHCZKYPqLa2lsfjsVisTg1RoVAob968cXV1FWdo8qm+vl5HRweOouq6qqqqU6dOoQ/pAQBv377Nycnx8fGRfCRpaWna2tr29vZlZWXGxsaSD+BHMtAHxOPxli9fjsPh9PX1OztATktLC80+Pj4+sFeoU9TV1dHHN1AXRUVFDRkypOVLR0dHT09PTCIZN26cvb09AGDr1q2nT5/GJIY2pL0PiMvlPnjwwMTExM7Orivl5OTkJCcnBwYGii40+Tdu3Lj4+Hh1dXWsA5Fh6AowP+6DmpGRkZmZuWLFCoziAo8fPx47duz79+9bJ0fJk+o+oH/++YfD4Xh6enYx+wAArK2t0exz4MABuCdBBx0+fDgxMRHrKGQbg8Hgu6/G0KFDaTTay5cvsQgKAADQ/ewQBHF3d+/6+GyhCegD4p+AUlJSUlNTxRwVAAC8evUqLy9PtNtyAwBWr14dExPT1NQkws125dWwYcPgjJauKCsrmzdvXnt/w/7+/iNHjpR4UP/DwcHh8uXLVVVVWAUQHh7e3kaYGPcBqaqq/vnnnyIvVltbOywsTEVFhUwmHzhwAHZzCNbU1HT48GGso5BVjx49CgkJEXBCQUEB5o+liESitbU1AGDEiBES3nFPSvuALl++bG1tjU3HdAcAACAASURBVPaWidWtW7dKSkqCg4O5XK6CgoK4q5NRsbGx2dnZ27ZtwzoQORQQEDB79uxRo0ZhHch3V69eXbBggSRrlLq94a9evWppaSmB7NPazp07iUTi2rVr4VNnSFS2bt26ZcsWdLGO9kRHR9vY2EjV4jYAgE2bNu3cuVNw5BIgXeOAxC06Onr8+PGmpqZ1dXVEIhHrcKTOv//+O2rUqB49emAdiGzYu3evlZXV9OnTsQ5EGNXV1Zs2bUL3Ihc3KRoHlJycfPnyZXGU3BE+Pj7ozjwLFy6MiIjAKgypNX78+F9++QXrKGTG1q1bO5J90tLSJBJO5+jr66PZJysrS9x1SUsfUEFBwY0bN7Zs2SKxGgVIS0sbN27cq1evOByO9NyfY47FYtXV1cn9SqBdhCDIo0ePOpKso6OjqVSqn5+fROISRkxMjJ6eHvrAXkykZRyQubm5lGQfdAAe2taLiYl58OAB1uFIC2VlZRUVlTdv3mAdiFRbvHhxB3O0srKylHdlzJ49u6ioSKxVSMVcsNu3bw8aNMjS0lKEZYoKlUpVV1f39fU1NzffuHEjfFj25MmTO3fuHDt2DOtApFFpaamqqmqvXr2wDkSUysvLVVVVe/bsKY7Cse8Devbs2ZMnT6Qz+6BTotDpPP3796fRaDQa7e7du1gHhaUxY8aEhIRgPnpFCtXV1eHx+I5knxcvXhw9elQiQYmAkZHRli1bxNTyxX5NaBKJJEP7lHI4nF27di1cuBBBkMbGRqzDwdLRo0exDkGKPH36NCAgoCNnVlZWHjt2TPwRidjz58/FseA0xvuCkclkBEHE1LoTH3SvsczMzL179wYHBzs5OWEdEQZevXr16dOn5cuXYx0I9hgMRllZWUfeFJWVlYaGhhIJSsTQTUD5zmsTE0nMBXNzcxNumyRsoTsd2tvbHz58mE6nAwDu378fHx8vDesHSIyTkxPcwAd9OFhUVNSR7JObmysli2AIAYfDPXv2jO9egV2B5VywZ8+eHTx4UKa7dfv27Tt+/HgAgJ2d3du3b+/cuQMA+Pz5M9ZxSQi6ZuuqVauwDgQzlZWVM2bM6GAPZlJSksjfwJLk6enp4uJSXFwswjKlZRyQPImOjo6Kirpw4UL//v2xjkUS6urqoqKiNm/ejHUgktbU1FRdXd2Rts/ly5cXLVokkaBkDGZzwfLy8oqKiiZPntzFcqQTnU5vamrS09MLCAjQ09Nbv359d5jEkJOTg86r7g7ev3+Pw+E6Mmlx0aJF69evl7YJX0JLSEigUChz584Vd0Xi7QMKCwuTub7njlNVVdXT00O3Dxo8eHB9fT16uyvfa6ElJCSkpKRgHYUkUKnUEydO/DT7FBYWAgCOHTsmN9kHAODu7h4dHY3+SXcdNn1ADAZjyZIlI0aM6GI50k9NTW3GjBnoAuCWlpYxMTFUKpXD4SQnJ8vfimjBwcE1NTWtj4waNWrhwoXYRSQW9fX1VCo1KipKwDk0Gm3x4sXoalNyNi4RAPDw4UNRtR6wHwfUDXG53E2bNs2cORNdMLi2thbriETsjz/+QBDEzc1t6NChv/zyy6tXr7COSGR27drVkd/Xv//++/HjR4lEhI3s7Gw2m931crDZGz4kJCQ3N7eLhcguPB4fEhJy69Yt9KNy4cKF6OTj6upqrEMTjcWLF48aNQpdaZhCoVy7dg3riEQjKyvLzs5OwGotZWVlaGezq6ur1A7uF4mXL18KbgN2EAZrQjMYjLi4OLjrJsrMzCwxMdHd3R3tQ3F3d8/Pz0e3A8E6NOFt27aNwWC0fPnly5cvX75gGlFXVVdXP3v2zMzMzMvLS8BpP12DVW4sWLBAJFt+YtAHhCBIN59O9SN025alS5deunRJQ0MDAPDnn3/6+fm16VKRFW2mUFdVVcn0b5xKpS5btszJyUlTU5PvCQ8fPgwICECbflKy4Z+4qampbdy4sevlwHFA0uvVq1dGRkZ9+vRZtWqVubl5cHAw1hF1iJeXF5VKpVAo6IQV9GDv3r0vXLggyYH8olJdXU2n083MzPi+ymAwCATCzp07d+zY0d3W8y0oKCgtLe3iMnUCxgEp8B21WVhYWF9f35U+8KCgIGNjY/QpNSSAsbExOk/F0dGRQqFYWVlxuVw/Pz8ymWxra4t1dO2aP3++sbGxsbExj8dD7/DpdDqNRtPW1u76/m4StmfPHltbWxMTE76vnjlzhsPhmJiYjBs3rrtln5b1jJYtW9aVQhQVFdubCyGu9YCcnZ0fPXok8g2/uonXr1+/fPkyMDCQTCaHh4d7eno6ODiIqvDij805zyk0KrehWjS7Ff3/Aw2AIDz0r00kxUoGj4cAgLQ04n54lYcgiBATifRMCAgCzO3UbUfL3izINh4/fmxlZdWVNdQFrAfE/2+lf//+Xbk14/F4SUlJMPsIbcSIEej4KS0trSFDhmRlZTk4OKSmpubl5Xl7e3dlpvWHp5SyfIb5EC1dQ4KSCv93HdR1PB4gVTLqyhgPzlVNWd52y2bZ0vXVWmEfkDwgk8n//PMPkUj09vaOi4vjcDju7u7tbavi7Ozs5ua2Y8eO1gdfPainkDjO0+B9seR8fk2pKm6e9psMr7FdXFycnJz866+/Cl2CpNeEjo6OPnXqlNCXQ3zp6Oj4+vp6e3sDAAYOHPjx48fnz58DAO7cufPj5A8Gg5GQkND6EUZVCbOhlg2zj4QNHqHV01D18xsRPMzGiqGh4YULF7pSgqTHAZWVlfXp00foy6GfsrCw2Lp168SJEwEAurq6MTEx6H67sbGxeXl5np6eeDyezWY/efKk5YOrooim0kOGF0WRXZq6Sl8/N2MdhfAIBEJYWBiNRhO6BAHjgMTSB7R161ahr4U6a8yYMWPGjEH/T6VSd+3aRaFQ0C+5XG5GRsaCBQtOnjxJa+Tq9cF4G8zuqVdvlbI8GW4BAQC6OM9W0n1AbDZbUVGxGz6zlBKOjo5tjgwaNGjW6H19rXr2s9HAKKjuq7GenXqlYvFWU6wDEd79+/cRBPHw8BDuckn3AY0fP771IH0IQ+iD5Pz8fPQeDYKEgMfjX716JfTlAvqA+N+CoQu+CLcgGZ1OJxAImG96321NmDABAKCtra2mpqagoGBgYGBpaWlpadn4pVus3AiJw5gxY/r27Sv05RIdB6SqqpqcnCzctVDXpaSkREdH9+vXz9TU1NT0v2Z/wjc5mYUPSZ6amlpXJpYL6APin4DQT1GhcblcmV6FXtb5+PhgHQIkVxAEWbly5dmzZ4W7fN26de0lBNH3AaWnp69du1a4ayEIkkI4HK6goKCxsVG4yyXaB0Sj0brD2uwQ1K0cP35cWVlZuGsl2gc0duzYrk8egSBIqnRlKxSJ9gF9X+q1nenFEATJomPHjk2ePFm4rmiJ9gHFxMQcPnxYuGshCJJOX79+ra2tFe5aifYBcblcuBAHBMmZwMBAbW1t4a6VaB/Q/PnzhbsQgiCp1d56tR0B+4AgCOqS6Ohoc3PzUaNGCXGtRPuA/v77b3RFV0imfSnIGz/B8eXLp529sKqqsrKqoiNnhoUfnDFrklDR8Td77uSjx/YLPifk4M5VqxeLsNJuoqysTBx9QGJZDwgOg+62yivKFiyalpf3CetA2tVDTa1HDzWso5A9Pj4+o0ePFu5aia4H5OvrK9yFkBzgcjhSvsjvOj8RbHSFdjV0qwVnurIVmqTngkFyo7ik8PrNi3l5n4yNTQL8N9nY2KPHP33OiTwdmpf3iUBQdR45ZvXq9ZoampVVFUuXzQIA7Nq9eRcAbm4em3/fCQCorKo4efJoxrvXysoqFgMGLV++ZtDATuxonJ2deelyVHZOJgBg0ECrVasCB1oMRl/icrkXL52Nv3+HwaDb2zsyGQwAAJPJnD138ojhzlv+3IuelpmZsX7Dbwf2hYaGh1RXV1lb2x0P+xsAcPVadOzdm01NjebmA32W/jbUYXh73xp6w/j4SUpw0NaTkcfKy7+dOH7e0tJGDD9yKXX16lUDAwPhNgiTaB/QmTNnYB+Q3Lh85e8h9sMCAzazWKwt24KoVCoAoKSkaEPwKjab/fvGHUsX//rs2aNduzYBAHR7EtH3/DKfVeGhUYsWLAcAkEh1/uuWNzZR/NYG/7ZyHZvNDgj0LS4u7HgMVVUVTBZz8SLfpUtWVlVVbP5jXctqU2HhBy9eihox3GWd3+8EFUITtQkAoKKiMsl16rPnaS2riCYlP9DXNxg+3HlD0NYB5gPRgxnv3pyNirC1dQgK/NNA35BOown41lDNzdS/z58MDNi8Z/eRwYOFHxksi8TUByT6cUCQPAnw3+Tm5gEAMDXpu8bPJ+Pd67FjJly+8jcejz90MEJDXQMAoKGhuT9k+4cP7+zsHCwGDAIAmJiYtbSVLl2O0tHu+dfhU+h+Ya4Tpyxa4h3/4I7/2o7uATtx4mRX1yno/wcOtAzasCo7J3OYo1P+l9y4+NuLFi5fsXwNAMDNzSPzQwZ6mqfHjH9uX3v6NNXNzYPJZD55mjJ3zhI8Hj/M0Skm5jKdQUfzGgBgutccKyvblvIFfGsAABaLFRy0tbulHtT8+fOFHt/X6XFAFhYWwtXUxe0MIWmjqfl9Xz0zs/4AgNraagBA5oeMIUOGoW9RAMCwYSMBAHn5n9B3aRuvXz+vqa2e4vFf/yWbza6t6cTiRDgc7umzRzdjLn/9WozOcybXkwAAT5+mAgBmzVrYcmbL4A9T0742NvbJKQ/d3Dyev3jMYDCmTPZqU6zTiFEaGpr7D2zz99vo5PT96bLgb41AIHTP7AMAENM2E/wT0Lhx48RRGSS70Pc2l8tF70S0tf7bAF5DQxMAUFfHv31eTyaNHDl6pa9/64Nqauodr/ripajz0ZEzZ8xf6etPqq/btXszD+EBAKprqtTV1bU0+W896jl1RsihnSRSXVLyg1Eu43r21G1zgq4uMSL83IlTR//YEmhtbbd964FevfQEf2uqqt13mYdr164ZGBiMHz9eiGtXrlzZuT6ggoKCwsJO3KW3dvbsWdgHJN+IRL3GRkrLl2RyPQBAXZ3/cvcaGpoUSoOJiVnrf7q6Hd3nl8lkXr12fuoUb7+1G2xs7C0H/9fvq62lQ6VSWSz+G0yPGTNBTU399p3r6ekvp02bxfccExOzgwfC/zpyqri44OChnZ391rqVb9++1dTUCHdtp8cBPXr0KCkpSbjKpPwpLNR1Vla2mR8yWnqCnzxJAQCgnT4qKgQAAKlVa8jBYXhOzoe8/M8tR+h0OvofJSVlOp3G4XAE1MVg0JlMpsX/P/aiNDagK+0DANCDKakJfC9UUVFxdZ1y7foFI6M+Q+zbbhOCQpOXw5BhTv/X3n0GRHGtDQCe3WWXIlV6EQWxoIKioKjEi4olir0lWSKoEGtERL0moLFiSVQSQYmxiyVqFMWCigELRQQRAUVYBZFel759vh9zL9fPLMvusDOzwPvcPwHmnPPihZdzzpzi+kVuXo7sb62bW7hwIe6B0eHDh2/cuCH1S9KHYHZ2dlhnGwc/Pz/IQV2b1zdL//773r9/+H6G57yKirIzZ485DXMeNnQEgiAmJqYW5paXr0ZqaGrW19fNnfOV9+LvkpOfbty0euECLwODnikpiWKJeNeOAwiC9LMbwOPxtu3498oVAZYW0peZ6Onp29raXbt+qWdPw6bGxjNnj9Hp9PfvOQiCjHefdC7y+MFDIfn57/rZDch+/eqzYeCM6XOvXbs0w1PK3CeCIG9ysrfv+PfsWQs1NbVSUhKxlQEyvrVuriN7wZqamtpaByS9BzR+/Hjs1k0caDQabATr2qysrPfvDRMKhft/3v7n5XOTPKbt2P4LtiqPRqMFB4doafUIC/8l5l50bW2NpYVV2G8nBw92PH/hZPiRA9y6Wo+JX2L1TJw4deECr5yc7AKZb+W3BIVoamju2PnDn1fOrVwZ8K3Xsnv3ooVCIYPB2LfnsLOz683oqxHHfqXT6Xp6/2+7dp8+ts4jRk2eLP02KxaT1dva5sKFU8ePhzk6Om0I3CL7W+vmLl68+M8bwOXk7+8/Y8YMqV+SfjHhhw8feDzegAEDcDQWGRlZW1v7/fffy/EsIE/MmXLzvlpwMSH5usDFhAiC7Ny508HBYfbs2cqtVvoQLDU19e3btz/++COOGplMZusgHwB5NDY2fs2W3k9Z/p2/5/Q5pEcEPsdms3V1dfGV3bt3r7Ozs9RBlfQEZGtri83z4bBw4UKYAwIK0dLSOvb7Balf0tWR/pYdkMzW1hZ32dra2ra+JD0BOTk5OTk54WuMRqPBmBkohE6nm5tZUB0FkOXYsWMjR44cNgzPC8GtW7e2tYpa+mwxl8tNSUnB0RI2fIN7wQDoYl69eoV7aqVHjx7YRpx/kp6AGhsbQ0LaOdipLXp6etXV1fjKAgBU0/fff+/ggHP3/4oVK96+fSv1S9LTkomJyYgRONc+9OvX79KlS/jKAgBUE7534pjS0tIePaQfAie9B8RisbZs2YK7PdyLGAEAqumHH37APbI5f/68paWl1C+1uWLw6dOnXC4XX3tz584tKirCVxYAoIISEhI0NDTwldXW1m7rxVSbCSguLi4+Ph5fezY2NiUlch1LDgBQfSiKhoaGtjWMkq20tHTRokVtfVX6HBCCIFOnTq2rq2vrq7KFhobiKwgAUEE0Gm34cCmHPcmjpKRET6/NxVxt9oBcXFxwbwcTCoWt+4kBAJ0dh8PBfd+6k5PTkSNH2vqqrF2jkZGR+JosKSn55ptv8JUFAKia3Nzc+vp6fGXpdHpbi4DaSUDPnj1LTEzE0WTv3r21tLRwj+AAETR60JlMOKWAAnQ6XddI+nFcncXw4cNxry7esGGDjG30bWYmBEFWr16N3YKAA+7eEyCIhha9tpzfayDcyUc2biW/s+9NMjMzw102Ly9PxvUWsv4kDhw40NlZ+lFy7aqtrS0uLsZXFhDB2EpDwMO5wRh0RBNXZGWnSXUUHRIcHFxQUICv7I0bN2Tkr3b65MePH3///j2OVtXV1b/66iscBYHSoSh66tSpsFPB9TWCguwmqsPpXnhN4pfx1cMnGsjxrOqKiYnBdyKiSCSSvYOsnQRkZWV14sQJHA1raWn5+Pi8efNGjmcBIZqbm69evdrY2Mjn85uamtavXz9rucX7jLrc1HqxCM5LIUN5AS/694+Lgzr3UWR8Pj8qKgpfWRm3wmOkn4j4qezsbHt7ezhltROprKw0Njb29fXt27fvxo0bP3sH8TSq6tXTOrPeGiJIQ9Lw+XwGnU77z/9w/tjr6DPfZzYMcNadsMiYzujkM0AdsHr16o0bN8roPbWfgDri8uXLs2bNwn2hIlDUrVu3tm3bdv78+Xa3DtaUCXjNsGXvc48ePbp06ZJYLO7Ro4eGhgaKojo6OmZmZpaWllOnTpW/HjUm3dhSndYl/mrv379/zJgxbm5uRFQuVwIaN27c3bt3cSzEPnPmTF1d3dq1a/GGB9rX0NDwxx9/6Orq+vr6ZmdnDxo0CA6E6wg2m/3Z2REoiqIo+uLFC+qCotL48eNv3LiB4zzWqqoqHo9nZSX9vhOMXCl69+7d0dHRijaPIIi3t/fgwYNxFATtKiwsxNY65ObmWltbe3l5IQgyePBgyD4d5Ofnp6Pz/47up9FoHTmQtFOTSCR3797Fdxp0YGBguxvaiR2CAaVramrS0NAQCoVff/31/Pnz2Wy2HIWAYlasWPH8+fPWVG5sbHz37l2qg6KGUCik0WgyljK3pbKy8vz58+vWrZP9mLyD1KqqqvPnzysaBGbx4sVlZWX4yoJPhYaGfvnllyiKslis69evQ/YhyLJly/T1/3PFGIvFunv3bmFhIdVBUWPevHnl5eU4ChobG7ebfRRIQEZGRi0tLUePHsURyqZNmyIiInAUBNj53GFhYQkJCQiCjB079vHjx2pqavBSklAuLi6tlzJgu5HOnTvXDTtBOTk5jo6ObZ0lJpucy3cUG4JVVVXp6em1dc88UC4Oh2NnZ3f06FENDQ0vLy/4ZyfT69evAwMDWSxW66Xmt27d8vT0FAqF8H9Eu06ePNnS0iLX9jFUQdHR0RKJRNFSKIoePny4sbERR8FuKD8/f8qUKdHR0VQHAj4XFBT05MkTqqMgg1gs/vvvv/GVTUpKEovF8jypcE/e2dm5rWueZZs5cyb2pga0paSk5OTJk9ih2pGRkZ6e0i8LBRTatWvXlStXcF/b2YmcOHGirass2uXq6irnLAGet2B8Pr+xsdHQ0BBXbEAKHo/HYrFmzZrl7++P+xw4QBoURVNTU11cXKgOhEBnzpxhs9mKvv+qrq728fGRf9UOnrlMdXV1Q0PDU6dO4SibmZmZlZWFo2BXVVVVtWHDhvLychqNFh0dDdmnU6DRaHZ2dh4eHl34Ahhvb28cb98vXLiwa9cu+Z/Hvw4oJycnKipq8+bNihbcv39/7969ZZxT3U00NzdraWmdOXPG2tp6/PjxVIcDFMblcrlcrpGRkba2NtWxKJNYLA4MDCTnZPcOLUR8/fr1oEGDcBQUCAT19fVGRka4m+7sjh8/XlRUtG3bNqoDAR2Vmpqqra09cOBAqgNRmj179jg4OCg6BSkQCEJDQzdt2qRYY/hmuT/l5+dXWVmpaKmPHz+eO3eu4613Og0NDTU1NUeOHKE6EKA0bDZbIBBQHQXFfHx8cnJyFC2lhPVs4eHh4eHhipaysrKqqqrqbteHHTx4sLy8XE9Pb+XKlVTHApQmMjKyy5yAHh8f39zcjKPgqVOncFzfrIQExGQyf/rpJwRBZJ889E/r1q1TU1PrPie3xsbGmpqa9u3bF9Yxdz1GRkZHjhyRffqf6tuzZ09VVZWWlpZCpd6+fZucnIyvRWX+JlhYWHh6eio0qWRiYqKnpzd58uSmpq58VCi2k8jV1RV2b3VhM2fO7NTHEFdVVc2ePXv+/PkKlYqLi/vjjz9cXV3xNark3fClpaUGBgYlJSUKHV9QXV0dFxc3d+7cLtk14HK5S5YsuX79OtWBAMJJJBKJRILj7TXlRCJRUVGRogc/19TUaGhoKNpj+pSSf+HNzc01NDRoNNrs2bPlv9LH0NBw/vz5EokEx0t91ffy5UvIPt0EnU7PzMysqamhOhCFubm5yT457J+Sk5Nzc3M7kn2Un4AwNjY2YWFhhYWFPB6Pz+fLWUpNTc3Dw6Mr3SuPomheXp67uzvVgQDyqKmprV+/nuooFJOSkhIXF6dQx43P50dGRuIeebViELQURVdX19jYGEVRd3f3vn37ytm1s7W1HTlyJI1GCw8Pd3Bw6Ozbjvft2ycQCOBMyG7F1NRUV1eXxWLhO0WQfPfv3x83bpxCv2t5eXlaWlqzZ8/ueOvEzrkwmczExMSGhgYEQd69eydXQHQ6giCjRo368ssvCY2NaHV1dZaWlgsWLKA6EEC2CRMm4DtDh3xeXl7Dhw9XqEhwcLBAIFDW4m/yjmSNj48PCws7dOhQr1695C9VWFj48ePHsWPHEhkaAMrU2Nh46NChLVu2UB1IO3g8XkFBgfxruEUiEYfDKSgoUOiCENnIe+vk7u7+888/f/z4EUGQx48fy1nK3Nz8+vXrMTExBEenfLdu3YJ7GbsnbW3tmJgYHo9HdSBtqqioOH78OIvFkj/7xMTE5OTk9OnTR4nZh9QEhE1OjxkzBjvmUs67ephM5i+//OLg4IAgyKFDhz58+EB8mMqRlZWVnZ1NdRSAGqGhoaq8UX7ZsmU+Pj7yr3rJysp6+vTpkCFDNDQ0lBsJZbdilJeXm5qa3rlzp7S0VM6N/6mpqWFhYadPn+bxeEr/h1C6zMxMNTU1e3t7qgMB4H+ys7MVeiuSmJg4ZsyY4uJigma1KFv4Z2pqiiCIh4cHn8+/cuUKgiDt3pzh7Ox8+vRpbD47MDCwqKiIrGDxcHBwgOzTPdXX1wcFBVEdhRQrVqxQqMMRGRl58eJFBEGIm1OneOUxi8VatWrV119/jSDIlStXfH19q6qq2i01ePDgGTNmYBNDqpyGjh07Fh8fT3UUgGwPHz7U1NSkOor/p7m5+eXLl8uWLRsyZIg8z+fk5CAI0q9fv8OHDxMbGTFb83FKT0/Pzc1FUfTixYsfP36Up0hcXNzs2bPlfJh8bDa7oaGB6igAqQoKCurq6qiO4n/27t0r/y+IUChcunTpgwcPCA7qP1T0ZtTo6OgzZ85cvXq1rq5OT09P9sOFhYXNzc0DBw48fvy4p6enmZkZWWECoOquXr0qkUgWLlzY7pM8Hq+pqUkikRQXFw8bNoyU6FSsB/RPRUVFLi4u169fl+fha9eusdlsFEXr6+uJD00BgYGBVIcASLJ06dL09HSqo0BRFA0PD0dRtKWlRZ6Hsclm8nvrqr773NLSMikpydraGsvlERER2LpqqebMmRMZGYltr586dWpsbCy5wbZp48aNe/fupToKQLjk5OQvv/ySvO5D2xYtWmRjY4MgSLvvi9PT07G9XQkJCeQfbq2iQzCpGhsbL126ZGZm5unpmZSU1K9fPxmnSldVVWVkZEycODE+Pl4sFk+cOJHcYD+H3aj59OlTNzc3aiMBXVhhYSGHw5kwYYJAIGCxWLIfrqurY7PZK1eunD59OlkBfk7Ve0Cf0tbW9vX1xc7Krq2tZbPZaWlpWGL658NGRkZY0hkwYMC9e/ew9/cUngCLbfbjcDjBwcFUxQAItWnTJmoPZi0qKvL398eW+cjOPvfv329qampsbDx+/DiF2QdR/Tkg2Wpra1EUXb169fLly3k8nown+Xw+dj30ggULqqurSYzxc9jFvhwOh8IYgNKFhIS8ffuWqtYvXrwoEonKysrkeXjfvn2bN2+W8+pkonWmIZgMz58/xxY4BAQEzJo1S8ZO+nfv3unp6RkZGa1fv37y5MnK3dgivydPnpw7d+63335T/SXdoF3ULs3f7+mMSgAAGWBJREFUtm2btrb2hg0bZD929erVxsZGHx+fiooKExMTkoJrD1HnAZHM0tKSyWQymUwzM7O8vLzhw4fn5OTcunXLysrqsxPbevbsiX3G0NAwMTHRzc2toqIiMTGxb9++ZAbcu3dvCwuL+vp6ExMToVDIYDDIbB0oUWBg4JQpU8g/TTglJSU5OXnQoEEODg4yLtQViUR0Oj0lJSUtLc3b21tdXb1Hjx7kRipLF+kB/VNTU9PJkyd5PN7GjRuzs7NFItHQoUOlPtnc3Lxjxw4ulxsREVFVVUX+dYmTJ09evnz5vHnzSG4XdNzTp09FIhH5h17m5OT8+uuv27dvl92XOXz4cExMzO3bt8VisYr+kaN6DEiG3NzcJUuWYMsi8vPzRSJRW09mZmaOGjXqxo0b5AaI/vnnnyiK4rjXDVCosbFRzmkXZcnJydm0aROKorJXWr948eLDhw8oiv71118kRodHt0hAGGxFVkxMjIuLS2JiIoqiUmejhUJhZmYmiqJHjx7997//XVJSQlqEqamp48aNy8/PJ61FgE9tbe2IESPInMflcrnYitZnz57JfjI8PHzZsmXY86qvGyWgT2F/uHbv3j1v3rzi4uK2Hnvw4EFqaiqKor///ntUVJSMrpOyNDQ0vHnzBvvbJecaVkA+OZfmK8XHjx/9/PxevHgh45nm5uZff/315MmTKIqWlpaSFlvHddME1Co/P7+iogJF0UWLFq1bt66td/mZmZnbt2/Py8vDfvgKCwuJDuzatWtjxowRCARCoZDotoD89uzZQ1pb2J+i6Oho7K+gVFhv/cGDB6dPn+6M99N39wTUSigUPnr0qLm5GUXR+fPnHzp0qK0njx07NmvWLIFAIBAIMjIyiI6qpKQkICAAOyQAUGvPnj1XrlwhoaHS0lJPT89r167JeKampmbq1KmHDx8mIR7iQAKS4sOHD9jsXXl5ua+vr9SfA4lEIhQKfXx8vvnmG2zoJHslZEfEx8djM+hYFwyQD+toyBitK0VdXd358+dRFH3//n1bbcXHx2/ZsgWbwSwvLyc0HhJAAmpHWlraxYsXURTNzs7etGnT06dPP3sA23lfXFw8evTo0NBQ7OUIQcEkJSWNGjVKRTZbdx/79u0jetIH++vl7u5++fJlqQ8UFBQ0NTWhKBoQEJCcnExoMGSCBCQvkUj04MEDLBk9fvx4x44dWVlZnz2DvUdPSkry9PS8e/cu1lFSbhhCoRBb8v/bb79hTQDiYBO6sbGxxDWRmZm5bNmytg4Mw35+fvrppzlz5mDzA11MF1kJTQI6nW5ra4tt+DAxMWloaOByuQMGDIiKirp586a1tTW2wwNBECsrK3d3dxRFzc3Njx8/fvLkyQEDBvTs2VNZYRgaGmJLum/evGlnZ6evr//+/XsDAwOl1A9aRURElJWVDRkyxNbWVumVc7ncjIwMKyurhw8fTps2bcCAAZ89UFBQsH//fiaT2adPH0tLy1WrVnX2i4Kl6rIroUnD5XLv3btnamrq7u4eERHR0tKyePFiLEdgkpOTtbS0HB0dQ0JCRCLRypUrjY2NldU6iqI0Gu3rr7+2sbEJCQnBPlRW5d2WSCTi8XgXL1708/Mjov6ioiJvb+/du3f/8251Dofz4cOHiRMnRkVFaWpqTpkyhYgAVAjVXbAupbS09Ny5c69evUJR9NChQ6Ghodh+fQyXy42KisrOzkZRdP/+/UePHlXibBE2+ktLSwsODoat9h1x+/btpKQkIlY//PXXX4sWLZK6jhlbC/Lu3btFixZhq2S7CegBEaWoqOjvv/92cXGxt7ffvXu3pqbmd99913riXH5+/sOHDydMmGBra7tnzx4bG5uFCxcqZUMjdtXasmXL0tPT9fT0iBg+tHr5qK78A0/IQ3ktIuJaIRPK4H0oyfL/aSZTXWmbS9PT083Nzc3MzA4fPuzp6YkdVIiRSCR0Oj04ODg1NRW7TLW7nY4ACYgMHz58ePr06fjx4y0sLNasWWNlZbVp0yYajYYNl9LS0uLi4lauXMlgMEJCQiZMmKCUzY3Z2dnbtm1bu3btF1980dTUpNw90C2N4vN7CweN1u+hp6ZrwBJLJEqsnEKCFrSmlJedWDt7tZWptXpHqsLOwDx69GhaWtrBgwd1dXU//WpKSsqFCxf8/f1tbGyysrLkvC2n64EERLbCwsJnz57NmTOHx+N5eXl5eHisWbMG26yMouidO3fy8/PXrFlTVlZ2+vTpf/3rX6NHj+5Ic1wuV19ff8OGDTweb/v27Z9OTuHGa5JcP1LswbbQ6KGSG6yV4cG5EtdpPS1s8fRHysvLQ0NDe/fuvWLFis/OV4iNjdXV1R05cuTp06ft7OzgfF54C0Y2PT29wYMH0+l0Fovl5uZGo9FsbW3r6+tnzpxZWFjo6+s7fPhwOp2uoaFRXl6ekZExduzYoqKikydPamtr4zhHCuvST5482cDAgMVi6evr//LLL0wmsyN3Xd49XeYy1VjHoAu+lGll66Bz/2zJ4NG6NLq8k/plZWWPHj3q379/Wlpar169Fi1ahCAIdvjU27dvjYyMrly5kpCQMGnSJB0dnWHDhmFXLXRzkICopKuri83RaGhoTJs2TVtb29ramsvlTpw4sby8fOXKlY6OjjQaTUtLKz8//82bN6NGjUpMTLxx44aFhcVnXfp29erVS19fH3vFc//+fXd398LCwvz8fEWvUauvEb14WDvcQwk9KVVGoyGl75uZ6vSepu0c7Y4gSEtLC51O9/b2dnFxsbOz69OnT+v5dhkZGXPmzLG2tnZwcBg8eLCHh4eOjg7x4XcaMARTRXw+Pzc318HBITc319vbe+nSpX5+fhwOR09Pj8lkXr9+3cTEZPr06deuXauoqPD09LSyssLRSmVl5ebNmx0cHNatW4eN1KQ+5uXlhV12hCnIaua8aho1XWkrCVTWm2dcBh0d4SFrgdXFixfDwsJu37796b+eRCLZtm1bRUVFRERESUmJkZFRuxdUdFud6VaM7kNdXd3BwQFBkP79+yclJWH3FnA4nG+//fbq1atLliwZNGjQ27dvXV1dGQxGamoqgiAxMTHYwjn5WzE2Nj5x4oSPjw92nTmbzc7Ly/vsmZkzZ+bk5KxYsaL1M3yeWMjvIlPOsqESpLlB/M/Pi8Xiy5cvx8fHIwhibm7+8OFDLPu8fPly69atRUVFEolk1KhRYWFhCIJYWFhA9pEBElAnYGFhgSDI1KlTY2JiFixYgCBIfX399u3bz5496+fnZ2Njk5CQ4ODgwGAwMjMzEQQJCwuLiIgQCoXyVI798sybN2/Lli08Hg9BkF9//RXb+oTNYWNn/vv7+xP/jao6DoeD9Xry8/Ox2wfd3d1TUlKysrKw41lHjRplaWmppqY2ffp0NTU1quPtBGAOqJPBJpXNzMzmzZvn6upKp9MrKyvPnj3LYrHYbHZKSsq7d+/GjBlTWFg4YMAAdXX1VatWFRUVOTs7t1uzkZGRqakp9h9xcXG9evUyMDAIDw9HEIRGoxUVFeXl5U2ePLm6RFBbIbS2J/sKTfJVFvHEIklvey3snsuFCxdqaWk5OTk5Ojq6ubmVlpYaGBiEhoYmJydjMzsjR47s378/rERXCMwBdSlJSUmxsbGrVq0yNDQMCgqys7NzcnLKyMjw9vaurq7euHGjh4cHdn6IPL8nM2bMKC0tbf2QwWBMmTKFPXPj+8xmt7mmBH8r1HudxM3nfEj/eGHfvn2VlZVisRibsM/IyFixYsUPP/wwc+ZM1T3svZOAXmKXMnr06NZ1Q9OnT3/x4oWjo+OgQYO8vLxGjx7t7++PzfJkZ2cfOHBg9uzZs2bNkpGMqqqqPv1QLBbHxsZqie2G2nX1DUr/VVpaunDhQgRBdHR0du/eXV1dfeTIEWNj40ePHmEzO5B9OgjmgLqsMWPGrFmzBltwFBQUZGFhMXTo0C+++GLatGkPHz4MCAjAdn7Ex8cvWbIkLi4Oe33zaQ0CgaB1tyC2pEVPTy8/P5+674lsVpZWd+7cwa7/Hj169OHDh2FeWblgCNbtlJeX5+fnu7q65uXlsdlsNps9fvx47EC1O3fuPHjwYPXq1c7OznPnzhUKha0nnBsbG3///ff9+vVrLtcve4d0kyHYk7iEoR6sSZMmUR1LlwWT0N2OtrY2tm7I0NBw6dKlxsbG9vb2zc3Nvr6+1tbWX331VWlpKY1G4/P52A0w2J61lpaWvLy8sWPHaqmZdp9JaHMzi/HTHagOpCuDIVi3xmAw7OzsEAQZOnRobGwsm812dHQ0NTUNCgrS0dH5bERWXFz8448/vnz5krp4QVcDCQj8D3Zs44gRI/78889vv/32swSEomhlZeXNmzepCxB0NfAWDEjXOs8qkUhotP/MFaqpqXXJg0EBVSABAem+++47LPswGAwDAwMzM7N+/fqNGTNGU9S3roTq4EBXAQkISCcQCOzt7e3t7UeOHDlkyBBzc3Ps829TG+pKmqmODnQRkICAdKdPn1ZWVcFbAysryn+PiJTjWdC9wCQ0AIAykIAAAJSBIRggyekzx6Jv/SUWi93/5bFq5XoWiyUSiSZNcfXzXfPN1z7YMz8Eraur4x4JO53HebsuwG9LUMgfJ8IKCwtMTczY7KU1NdU3o682NjY4OblsWB+sr2+AIMjdmJtRUZff53M0NbVGuoxes3oD9vngrYG9rHqrqandun1dJBS6urr5r93ceisJUBHQAwJkyM3LeZGestxv7SSPaTduXr3059l2izQ3N4f+ttdv2Zp9ew+z1NX3/7zjWUrClqCQ9QFBL16khB89iD32+nWmtXWf5d+tneE5NyHx0b6ft7fWcPlKZFlZScju0DWrN8Q/io08f4LIbxHgAT0gQAYLC6tDB35nMBiTJ08vLMyPf/Rg8be+7ZZasXydq6sbgiALF3jt2789wP8HG5u+Q5ChaWnPnqUkYM+sD/ixdTe/mppa5PmTfD5fXV0dQRArK+sff9hJo9HsBw5+/PTv56lJK5bDsWqqBRIQIIN2D+3Wkyv69On7+k2mPKXUWf+5mYvJZCEIwvzv2khjY5O6Oi7230Kh8Nr1Sw9i71RUlKmra0gkEi631tTUDEEQDXWN1txkamqelZVBwHcGOgQSECAbg8EQiTp0k2rrymwURX8MWvc297X34u8GDXJ88uTvS3+elaBSjqxmqjElEikHPANqQQIClOn46aUZGS/SXqQE/bjLY+JUBEGKiwqVFBogCUxCA8owGAwdHd2q6krsQxRFKyoUuNUDQZC6ei6CIP37Dfz0Q0lXuSe6O4AeEKDSSJfRD+7fHu7k0tPA8PKVyMLCgn7/zSbyGGTvwGKx/jgeNn36nPfv8y5cPIUgSP57jqUFnovSAPmgBwSotHpV4LBhznv3/bR95+Z+/QaOGDFKoeLGxibBQbvzODnbtm9KS3t28MDvrq5u165fIixeoGRwJCtQzNvUhu5zK4agRfTFHCOqA+nKoAcEAKAMJCAAAGUgAQEAKAMJCABAGUhAAADKQAICAFAGEhAAgDKQgAAAlIEEBACgDCQgAABlIAEBACgDCQgAQBlIQEAxNBrCUOsWPzZ0Bo2h1tEj04Bs3eInCShRDz21+hoB1VGQobFWqKnNoDqKLg4SEFBMTzN1Ab9bHK7c3CAytlKnOoouDhIQUIymNt26v1bmk1qqAyFWaX6LgCe26qdJdSBdHCQgoDC32UYtjaLMx102B31825TxqGbWCguqA+n64EREgNOTqKqKQj6DSTMwURcKushPkZAvqSpuMTBhTfc17/CdHaB9kIAAfg01ouoyQSNXJBEr4SKKd+/eZWRkzJ07V6FSV65cEQgEbDa74wEgCKKlq2Zsoa5nzFRKbaBdcCsGwE+np5pOT6X9CD15lTx10QhHV32FSh08kfD69euSpuRz584pKxJAGugBgU6Mx+N5eXkVFBSgKDp48OCzZ89SHRFQDExCA5VQXl7+5s0bRUtVV1fz+XzsktWsrKxvvvkG+xB0FpCAgEo4cOAAl8tVtFR5eXnrNfN0Oj03N9fPz6+hoYGAAAEhIAEB6gmFQjc3t9GjRytasLa2lsfjffqZ169fe3t7KzU6QCBIQIB6TCZz5syZOApWVlbW19dj/42iqEQiMTQ0vHbtmrIDBESBBASod/bs2cLCQhwFCwoKaDQagiA9e/YcNGjQixcv7t27R0CAgCiQgADFampqzp07Z21tjaPs5s2bzc3NU1NT79+/7+TklJqaSkCAgEDwGh5QrLy8vKWlpU+fPlQHAigACQh0Hbm5uf3796c6CqAAGIIBKrW0tPj4+CirtpMnT8bGxiqrNkACSECASg8fPlTi4MvLy6umpkZZtQESwBAMUKmiokJbW1tLS4vqQAA1oAcEqGRoaKjc7PP8+fOqqiolVggIBQkIUCY1NXX16tXKrZPD4Zw+fVq5dQLiQAIClMnKypo0aZJy6/T09LSzs1NunYA4MAcEAKAM9IAANcRiMYfDIaLmy5cvP3v2jIiagdJBAgLUSEhICA8PJ6JmLS2tO3fuEFEzUDo4khVQo6SkxMPDg4iaJ02aBBs7OguYAwIAUAaGYIAaubm5xFV+9OjRly9fElc/UBZIQIACeXl5W7duJa5+BoMB89CdAswBAQqUlJSMGzeOuPrnzp1bVlZGXP1AWWAOCABAGRiCAQrU19cLhUJCmwgODhaLxYQ2AToOEhCgwOLFi8vLywltIicn5+PHj4Q2AToOEhCgQHV1tZWVFaFN7Nq1S09Pj9AmQMfBHBAAgDLQAwJkwy7wIrqVW7duRUdHE90K6CBIQIBs9+/fDw4OJroVHo+XlZVFdCugg2AdECBbbW2tiYkJ0a14eHg4OTkR3QroIJgDAgBQBoZggGyNjY08Ho/oVkpKSnbt2kV0K6CDIAEBsu3evfvx48dEt0Kn05OTk4luBXQQJCBANlNTUwsLC6JbMTIyImGqG3QQzAEBACgDPSBAtsrKSpFIREJDGzZsIKEV0BGQgADZli9fXlxcTEJDCQkJAoGAhIYAbpCAANlMTEx69OhBQkMHDx5kMBgkNARwgzkgAABloAcEyFZWVkbCXjAEQYKCgurr60loCOAGCQiQzcvLi5y8kJaWxufzSWgI4AYJCJDN2NiYTifjB2/37t1wJJCKgzkgAABloAcEyJaZmUnOOqCdO3fW1NSQ0BDADRIQIFtAQEBjYyMJDaWkpJCw6xV0BCQgQLahQ4eqqZFxENXWrVt79uxJQkMAN5gDAgBQBnpAgGxTpkzhcrkkNBQSEgJzQCoOEhAgG2n3BSYlJcEckIqDIRggm1gsJmeLVnJy8rBhwzQ0NEhoC+ADCQgAQBkYggGy+fj4kDMHtHPnzrq6OhIaArhBAgJko9Fo5AzBnjx5Qs6KR4AbDMFAl5WQkDBq1Chy1hwBfCABAQAoA0MwQLb58+d//PiRhIbgTGjVBwkIkM3MzIyEqRkejwf3gqk+GIKBrkkoFD5//nzMmDFUBwJkgQQEyNbS0sJkMmFuGMAQDFDgwIED0dHRRLeSn58fFhZGdCuggyABAbKZm5uTsD4wLy+PnNvHQEfAEAx0TcXFxXw+39bWlupAgCyQgADZhEJhS0uLrq4u1YEA6sEQDJCttrZ20aJFRLcSFhb25s0bolsBHQQJCJDNxMSEyWQ2NzcT2srt27cNDQ0JbQJ0HAzBQBckFoszMzOHDRtGdSCgHZCAAAUaGxvpdLqWlhbVgQCKwRAMUOD58+dbt24lrv4bN25cvXqVuPqBskACAhRwcXFpaGggrv579+716tWLuPqBssAQDHRBpaWl5ubmVEcB2gcJCFCjuLiYwWCYmZlRHQigEgzBADWampoCAgKIqHnv3r0xMTFE1AyUDhIQoEb//v2dnZ0rKyuVXvPdu3c9PDyUXi0gAgzBAACUgR4QoIxAILh8+bJy6ywpKWlpaVFunYA4kIAAZVgsVnZ29q1bt5RVYW5ubmBgoKamprIqBESDBASoFBAQoMR88eLFi/Xr1yurNkACmAMCAFAGekCAYu/fvw8JCel4PYmJiXD+RqcDCQhQzNbWtrKy8vHjxx2ppKKiYufOnfb29sqLC5ABhmCAeiiKikQiJpOJu4acnBx9fX1YV93pQAICKqGoqEhbW1tfX5/qQACpYAgGVIKBgcHMmTPxlV27dm16erqyIwJkgB4QUBUZGRlCodDZ2VmhUunp6Wlpab6+voTFBQgECQgAQBkYggEVkpOT88svv8j//PPnz1+9ekVkRIBYkICAChk4cCCPx7t9+7Y8D3M4nAMHDjg6OhIfFyAKDMFAZ8XhcKysrDQ0NKgOBOAHPSCgcoqKipKSkmQ/U1NTo6+vD9mns4MEBFSOlZVVdHT0vXv32nqgsLBw2bJlRkZG5MYFlA8SEFBFISEhTCazrfmBmJiYiIgI0oMCygdzQEBFSSQSiUSipqZGdSCAQNADAiqKTqeHh4dHRUV9+sn8/HyF3tMDFQcJCKguf39/Ho/X3Nzc+pmIiIjly5dTGhRQJhiCAQAoAwNsoOouXLhAo9GGDx+enp7+1VdfUR0OUCboAYFOYNeuXVFRUampqVQHApQMEhDoBCQSCY1Go9FoVAcClAwSEACAMvAWDABAGUhAAADKQAICAFAGEhAAgDKQgAAAlIEEBACgzP8BUIE3T908YxEAAAAASUVORK5CYII=",
+ "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/docs/docs/how-tos/multi-agent-network.ipynb b/docs/docs/how-tos/multi-agent-network.ipynb
new file mode 100644
index 000000000..3c8461438
--- /dev/null
+++ b/docs/docs/how-tos/multi-agent-network.ipynb
@@ -0,0 +1,569 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "87684b48-150e-4e15-b0a5-a9dd7851f8fb",
+ "metadata": {},
+ "source": [
+ "# How to build a multi-agent network"
+ ]
+ },
+ {
+ "attachments": {},
+ "cell_type": "markdown",
+ "id": "2c65639c-9705-49f1-840a-370718852e98",
+ "metadata": {},
+ "source": [
+ "!!! 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",
+ "\n",
+ "\n",
+ "In this how-to guide we will demonstrate how to implement a [multi-agent network](../../concepts/multi_agent#network) architecture.\n",
+ "\n",
+ "Each agent can be represented as a node in the graph that executes agent step(s) and decides what to do next - finish execution or route to another agent (including routing to itself, e.g. running in a loop). A common pattern for routing in multi-agent architectures is handoffs. Handoffs allow you to specify:\n",
+ "\n",
+ "1. which agent to navigate to next and (e.g. name of the node to go to)\n",
+ "2. what information to pass to that agent (e.g. state update)\n",
+ "\n",
+ "To implement handoffs, agent nodes can return `Command` object that allows you to [combine both control flow and state updates](../command):\n",
+ "\n",
+ "```python\n",
+ "def agent(state) -> Command[Literal[\"agent\", \"another_agent\"]]:\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",
+ " \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": 2,
+ "id": "0bcff5d4-130e-426d-9285-40d0f72c7cd3",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdin",
+ "output_type": "stream",
+ "text": [
+ "OPENAI_API_KEY: ········\n"
+ ]
+ }
+ ],
+ "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",
+ "
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4a53f304-3709-4df7-8714-1ca61e615743",
+ "metadata": {},
+ "source": [
+ "## Travel Recommendations Example"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "34cd131b-f0c2-4b69-887f-2cbd5afb14a7",
+ "metadata": {},
+ "source": [
+ "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, `goto` will contain `finish`.\n",
+ "\n",
+ "Now, let's define our agent nodes and graph!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "aa4bdbff-9461-46cc-aee9-8a22d3c3d9ec",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from typing_extensions import TypedDict, Literal\n",
+ "\n",
+ "from langchain_openai import ChatOpenAI\n",
+ "from langgraph.graph import MessagesState, StateGraph, START, END\n",
+ "from langgraph.types import Command\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, END]]:\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",
+ " goto = END\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\"],\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\"],\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\"],\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",
+ "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",
+ "# we'll always start with a general travel advisor\n",
+ "builder.add_edge(START, \"travel_advisor\")\n",
+ "\n",
+ "graph = builder.compile()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "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": [
+ "First, let's invoke it with a generic input:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "26a0d4df-ff99-40f0-92a8-0b3f2c591040",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "{'travel_advisor': {'messages': {'role': 'ai', 'content': 'The Caribbean offers many warm destinations perfect for a relaxing getaway. Consider visiting Jamaica for its beautiful beaches and vibrant culture, the Bahamas for its stunning islands and clear waters, or the Dominican Republic for its all-inclusive resorts and rich history. Let me know if you need more information on sightseeing or hotel recommendations!', 'name': 'travel_advisor'}}}\n",
+ "\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "for chunk in graph.stream(\n",
+ " {\"messages\": [(\"user\", \"i wanna go somewhere warm in the caribbean\")]}\n",
+ "):\n",
+ " print(chunk)\n",
+ " print(\"\\n\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "997ea9aa-36ee-40a1-a5fc-b44a079786a9",
+ "metadata": {},
+ "source": [
+ "You can see that in this case only the first agent (`travel_advisor`) ran. Let's now ask for more recommendations:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "68a547d4-0a15-43bd-aeed-c9ba1dfe388f",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "{'travel_advisor': {'messages': {'role': 'ai', 'content': 'I recommend visiting Jamaica, a beautiful Caribbean island known for its warm climate, stunning beaches, and vibrant culture.', 'name': 'travel_advisor'}}}\n",
+ "\n",
+ "\n",
+ "{'sightseeing_advisor': {'messages': {'role': 'ai', 'content': \"Jamaica is a fantastic choice for a warm Caribbean getaway. Here are some top things to do while you're there:\\n\\n1. **Dunn's River Falls**: Located near Ocho Rios, this is one of Jamaica's most famous waterfalls. You can climb the falls, swim in the refreshing pools, or simply enjoy the beautiful surroundings.\\n\\n2. **Seven Mile Beach**: Located in Negril, this is one of the most beautiful beaches in the Caribbean. It's perfect for sunbathing, swimming, and enjoying water sports.\\n\\n3. **Bob Marley Museum**: Situated in Kingston, this museum is dedicated to the life and legacy of the reggae legend Bob Marley and is a must-visit for music lovers.\\n\\n4. **Blue Mountains**: Go hiking or take a tour to explore the Blue Mountains, where you can enjoy breathtaking views and taste some of the world's best coffee.\\n\\n5. **Luminous Lagoon**: Experience the natural wonder of the Luminous Lagoon in Falmouth, where the water glows at night due to bioluminescent microorganisms.\\n\\nFor hotel recommendations, I suggest checking with a hotel advisor for the best options that suit your budget and preferences.\", 'name': 'sightseeing_advisor'}}}\n",
+ "\n",
+ "\n",
+ "{'hotel_advisor': {'messages': {'role': 'ai', 'content': 'For hotel recommendations in Jamaica, here are a few options across different areas: \\n\\n1. **Sandals Montego Bay** (Montego Bay): A luxurious all-inclusive resort ideal for couples, offering beautiful beachfront views and a variety of dining options.\\n\\n2. **Half Moon Resort** (Montego Bay): A family-friendly resort with a private beach, golf course, and various activities for all ages.\\n\\n3. **Jamaica Inn** (Ocho Rios): A charming boutique hotel known for its excellent service and tranquil atmosphere.\\n\\n4. **The Caves** (Negril): A unique and romantic cliff-side resort offering stunning ocean views and intimate dining experiences.\\n\\n5. **Trident Hotel** (Port Antonio): A luxurious and contemporary hotel offering privacy, elegance, and beautiful views of the Caribbean Sea.\\n\\nThese options cater to different tastes and budgets, ensuring a comfortable and enjoyable stay in Jamaica.', 'name': 'hotel_advisor'}}}\n",
+ "\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "for chunk in graph.stream(\n",
+ " {\n",
+ " \"messages\": [\n",
+ " (\n",
+ " \"user\",\n",
+ " \"i wanna go somewhere warm in the caribbean. pick one destination, give me some things to do and hotel recommendations\",\n",
+ " )\n",
+ " ]\n",
+ " }\n",
+ "):\n",
+ " print(chunk)\n",
+ " print(\"\\n\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c1c66f91-39b0-4ed2-91e8-6daf6d124f47",
+ "metadata": {},
+ "source": [
+ "Voila - `travel_advisor` makes a decision to first get some sightseeing recommendations from `sightseeing_advisor`, and then `sightseeing_advisor` in turn calls `hotel_advisor` for more info. Notice that we never explicitly defined the order in which the agents should be executed!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3f9930b9-16b4-4179-9990-7ddf48cb3ed7",
+ "metadata": {},
+ "source": [
+ "## Game NPCs Example"
+ ]
+ },
+ {
+ "attachments": {},
+ "cell_type": "markdown",
+ "id": "3f7b49c5-070e-4289-88aa-afbfae44cc98",
+ "metadata": {},
+ "source": [
+ "In this example we will create a team of [non-player characters (NPCs)](https://en.wikipedia.org/wiki/Non-player_character) that all run at the same time and share game state (resources). At each step, each NPC will inspect the state and decide whether to halt or continue acting at the next step. If it continues, it will update the shared game state (produce or consume resources).\n",
+ "\n",
+ "We will create 4 NPC agents:\n",
+ "\n",
+ "- `villager`: produces wood and food until there is enough, then halts\n",
+ "- `guard`: protects gold and consumes food. When there is not enough food, leaves duty and halts\n",
+ "- `merchant`: trades wood for gold. When there is not enough wood, halts\n",
+ "- `thief`: checks if the guard is on duty and steals all of the gold when the guard leaves, then halts\n",
+ "\n",
+ "Our NPC agents will be simple node functions (`villager`, `guard`, etc.). At each step of the graph execution, the agent function will inspect the resource values in the state and decide whether it should halt or continue. If it decides to continue, it will update the resource values in the state and loop back to itself to run at the next step.\n",
+ "\n",
+ "Now, let's define our agent nodes and graph!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "f15c38c0-c88a-404b-9687-a9ef9ff20ffc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from typing_extensions import Annotated, TypedDict, Literal\n",
+ "\n",
+ "from langchain_core.runnables import RunnableConfig\n",
+ "from langgraph.graph import StateGraph, START, END\n",
+ "from langgraph.types import Command\n",
+ "\n",
+ "import operator\n",
+ "\n",
+ "\n",
+ "class GameState(TypedDict):\n",
+ " # note that we're defining a reducer (operator.add) here.\n",
+ " # This will allow all agents to write their updates for resources concurrently.\n",
+ " wood: Annotated[int, operator.add]\n",
+ " food: Annotated[int, operator.add]\n",
+ " gold: Annotated[int, operator.add]\n",
+ " guard_on_duty: bool\n",
+ "\n",
+ "\n",
+ "def villager(state: GameState) -> Command[Literal[\"villager\", END]]:\n",
+ " \"\"\"Villager NPC that gathers wood and food.\"\"\"\n",
+ " current_resources = state[\"wood\"] + state[\"food\"]\n",
+ " if current_resources < 15: # Continue gathering until we have enough resources\n",
+ " print(\"Villager gathering resources.\")\n",
+ " # Loop back to the 'villager' agent\n",
+ " return Command(goto=\"villager\", update={\"wood\": 3, \"food\": 1})\n",
+ " # NOTE: Returning Command(goto=END) is not necessary for the graph to run correctly\n",
+ " # but it's useful for visualization, to show that the agent actually halts\n",
+ " else:\n",
+ " return Command(goto=END)\n",
+ "\n",
+ "\n",
+ "def guard(state: GameState) -> Command[Literal[\"guard\", END]]:\n",
+ " \"\"\"Guard NPC that protects gold and consumes food.\"\"\"\n",
+ " if not state[\"guard_on_duty\"]:\n",
+ " return Command(goto=END)\n",
+ "\n",
+ " if state[\"food\"] > 0: # Guard needs food to keep patrolling\n",
+ " print(\"Guard patrolling.\")\n",
+ " # Loop back to the 'guard' agent\n",
+ " return Command(\n",
+ " goto=\"guard\",\n",
+ " update={\"food\": -1}, # Consume food while patrolling\n",
+ " )\n",
+ " else:\n",
+ " print(\"Guard leaving to get food.\")\n",
+ " return Command(goto=END, update={\"guard_on_duty\": False}) # Leave to get food\n",
+ "\n",
+ "\n",
+ "def merchant(state: GameState) -> Command[Literal[\"merchant\", END]]:\n",
+ " \"\"\"Merchant NPC that trades wood for gold.\"\"\"\n",
+ " if state[\"wood\"] >= 5: # Trade wood for gold when available\n",
+ " print(\"Merchant trading wood for gold.\")\n",
+ " return Command(goto=\"merchant\", update={\"wood\": -5, \"gold\": 1})\n",
+ " else:\n",
+ " return Command(goto=END)\n",
+ "\n",
+ "\n",
+ "def thief(state: GameState) -> Command[Literal[\"thief\", END]]:\n",
+ " \"\"\"Thief NPC that steals gold if the guard leaves to get food.\"\"\"\n",
+ " if not state[\"guard_on_duty\"]:\n",
+ " print(\"Thief stealing gold.\")\n",
+ " return Command(goto=END, update={\"gold\": -state[\"gold\"]})\n",
+ " else:\n",
+ " # keep thief on standby (loop back to the 'thief' agent)\n",
+ " return Command(goto=\"thief\")\n",
+ "\n",
+ "\n",
+ "builder = StateGraph(GameState)\n",
+ "\n",
+ "# Add NPC nodes\n",
+ "builder.add_node(villager)\n",
+ "builder.add_node(guard)\n",
+ "builder.add_node(merchant)\n",
+ "builder.add_node(thief)\n",
+ "\n",
+ "# All NPCs start running in parallel\n",
+ "builder.add_edge(START, \"villager\")\n",
+ "builder.add_edge(START, \"guard\")\n",
+ "builder.add_edge(START, \"merchant\")\n",
+ "builder.add_edge(START, \"thief\")\n",
+ "graph = builder.compile()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "ab4cc03e-4e25-44ac-88b1-e415fcbce151",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "display(Image(graph.get_graph().draw_mermaid_png()))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5a3ea167-c302-41f7-906e-60fd0e5cd004",
+ "metadata": {},
+ "source": [
+ "Let's run it with some initial state!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "83f50671-9371-46dd-847d-5db824c1141e",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Game state {'wood': 10, 'food': 3, 'gold': 10, 'guard_on_duty': True}\n",
+ "\n",
+ "\n",
+ "Villager gathering resources.\n",
+ "Guard patrolling.\n",
+ "Merchant trading wood for gold.\n",
+ "Game state {'wood': 8, 'food': 3, 'gold': 11, 'guard_on_duty': True}\n",
+ "\n",
+ "\n",
+ "Villager gathering resources.\n",
+ "Guard patrolling.\n",
+ "Merchant trading wood for gold.\n",
+ "Game state {'wood': 6, 'food': 3, 'gold': 12, 'guard_on_duty': True}\n",
+ "\n",
+ "\n",
+ "Villager gathering resources.\n",
+ "Guard patrolling.\n",
+ "Merchant trading wood for gold.\n",
+ "Game state {'wood': 4, 'food': 3, 'gold': 13, 'guard_on_duty': True}\n",
+ "\n",
+ "\n",
+ "Villager gathering resources.\n",
+ "Guard patrolling.\n",
+ "Game state {'wood': 7, 'food': 3, 'gold': 13, 'guard_on_duty': True}\n",
+ "\n",
+ "\n",
+ "Villager gathering resources.\n",
+ "Guard patrolling.\n",
+ "Game state {'wood': 10, 'food': 3, 'gold': 13, 'guard_on_duty': True}\n",
+ "\n",
+ "\n",
+ "Villager gathering resources.\n",
+ "Guard patrolling.\n",
+ "Game state {'wood': 13, 'food': 3, 'gold': 13, 'guard_on_duty': True}\n",
+ "\n",
+ "\n",
+ "Guard patrolling.\n",
+ "Game state {'wood': 13, 'food': 2, 'gold': 13, 'guard_on_duty': True}\n",
+ "\n",
+ "\n",
+ "Guard patrolling.\n",
+ "Game state {'wood': 13, 'food': 1, 'gold': 13, 'guard_on_duty': True}\n",
+ "\n",
+ "\n",
+ "Guard patrolling.\n",
+ "Game state {'wood': 13, 'food': 0, 'gold': 13, 'guard_on_duty': True}\n",
+ "\n",
+ "\n",
+ "Guard leaving to get food.\n",
+ "Game state {'wood': 13, 'food': 0, 'gold': 13, 'guard_on_duty': False}\n",
+ "\n",
+ "\n",
+ "Thief stealing gold.\n",
+ "Game state {'wood': 13, 'food': 0, 'gold': 0, 'guard_on_duty': False}\n",
+ "\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "initial_state = {\"wood\": 10, \"food\": 3, \"gold\": 10, \"guard_on_duty\": True}\n",
+ "for state in graph.stream(initial_state, stream_mode=\"values\"):\n",
+ " print(\"Game state\", state)\n",
+ " print(\"\\n\")"
+ ]
+ }
+ ],
+ "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
+}
diff --git a/docs/docs/how-tos/update-state-from-tools.ipynb b/docs/docs/how-tos/update-state-from-tools.ipynb
new file mode 100644
index 000000000..6e916ca2a
--- /dev/null
+++ b/docs/docs/how-tos/update-state-from-tools.ipynb
@@ -0,0 +1,383 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "7c58c957-83d8-44ff-8580-a9b3dd39a0a9",
+ "metadata": {},
+ "source": [
+ "# How to update graph state from tools"
+ ]
+ },
+ {
+ "attachments": {},
+ "cell_type": "markdown",
+ "id": "95f30587-8dd2-40be-920d-59539089c09f",
+ "metadata": {},
+ "source": [
+ "!!! info \"Prerequisites\"\n",
+ " This guide assumes familiarity with the following:\n",
+ " \n",
+ " - [Command](../../concepts/low_level/#command)\n",
+ "\n",
+ "A common use case is updating graph state from inside a tool. For example, in a customer support application you might want to look up customer account number or ID in the beginning of the conversation. To update the graph state from the tool, you can return `Command(update={\"my_custom_key\": \"foo\", \"messages\": [...]})` from the tool:\n",
+ "\n",
+ "```python\n",
+ "@tool\n",
+ "def lookup_user_info(tool_call_id: Annotated[str, InjectedToolCallId], config: RunnableConfig):\n",
+ " \"\"\"Use this to look up user information to better assist them with their questions.\"\"\"\n",
+ " user_info = get_user_info(config)\n",
+ " return Command(\n",
+ " update={\n",
+ " # update the state keys\n",
+ " \"user_info\": user_info,\n",
+ " # update the message history\n",
+ " \"messages\": [ToolMessage(\"Successfully looked up user information\", tool_call_id=tool_call_id)]\n",
+ " }\n",
+ " )\n",
+ "```\n",
+ "\n",
+ "!!! important\n",
+ "\n",
+ " If you want to use tools that return `Command` and update graph state, you can either use prebuilt [`create_react_agent`][langgraph.prebuilt.chat_agent_executor.create_react_agent] / [`ToolNode`][langgraph.prebuilt.tool_node.ToolNode] components, or implement your own tool-executing node that collects `Command` objects returned by the tools and returns a list of them, e.g.:\n",
+ " \n",
+ " ```python\n",
+ " def call_tools(state):\n",
+ " ...\n",
+ " commands = [tools_by_name[call[\"name\"].invoke(call, config={\"coerce_tool_content\": False}) for tool_call in tool_calls]\n",
+ " return commands\n",
+ " ```\n",
+ "\n",
+ "This guide shows how you can do this using LangGraph's prebuilt components ([`create_react_agent`][langgraph.prebuilt.chat_agent_executor.create_react_agent] / [`ToolNode`][langgraph.prebuilt.tool_node.ToolNode]).\n",
+ "\n",
+ "!!! note\n",
+ "\n",
+ " Support for tools that return [`Command`][langgraph.types.Command] was added in LangGraph `v0.2.57`.\n",
+ "\n",
+ "## Setup\n",
+ "\n",
+ "First, let's install the required packages and set our API keys:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "64500eca-1cdc-43d9-9401-f4cd9999881f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "%%capture --no-stderr\n",
+ "%pip install -U langgraph langchain-openai"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "a3f92fb2-9175-47fa-9c7d-ad5f44bfd20e",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Please provide your OPENAI_API_KEY ········\n"
+ ]
+ }
+ ],
+ "source": [
+ "import os\n",
+ "import getpass\n",
+ "\n",
+ "\n",
+ "def _set_if_undefined(var: str):\n",
+ " if not os.environ.get(var):\n",
+ " os.environ[var] = getpass.getpass(f\"Please provide your {var}\")\n",
+ "\n",
+ "\n",
+ "_set_if_undefined(\"OPENAI_API_KEY\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "caf6ff9f-c1e6-499e-a230-9fa231ea7d2f",
+ "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",
+ "
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "10e9a9c6-fa3f-416c-bac0-3e58d7259908",
+ "metadata": {},
+ "source": [
+ "Let's create a simple ReAct style agent that can look up user information and personalize the response based on the user info."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4255b9b9-cf67-4cc3-8018-1708f5dfcfd2",
+ "metadata": {},
+ "source": [
+ "## Define tool"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7de6b010-aab1-4fe8-8251-907fcae78583",
+ "metadata": {},
+ "source": [
+ "First, let's define the tool that we'll be using to look up user information. We'll use a naive implementation that simply looks user information up using a dictionary:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8d070c9f-6e61-4724-85dc-ac4531b9c79a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "USER_INFO = [\n",
+ " {\"user_id\": \"1\", \"name\": \"Bob Dylan\", \"location\": \"New York, NY\"},\n",
+ " {\"user_id\": \"2\", \"name\": \"Taylor Swift\", \"location\": \"Beverly Hills, CA\"},\n",
+ "]\n",
+ "\n",
+ "USER_ID_TO_USER_INFO = {info[\"user_id\"]: info for info in USER_INFO}"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "08d1ecca-ee57-4e97-b8d0-e09de85337d4",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from langgraph.prebuilt.chat_agent_executor import AgentState\n",
+ "from langgraph.types import Command\n",
+ "from langchain_core.tools import tool\n",
+ "from langchain_core.tools.base import InjectedToolCallId\n",
+ "from langchain_core.messages import ToolMessage\n",
+ "from langchain_core.runnables import RunnableConfig\n",
+ "\n",
+ "from typing_extensions import Any, Annotated\n",
+ "\n",
+ "\n",
+ "class State(AgentState):\n",
+ " # user provided\n",
+ " last_name: str\n",
+ " # updated by the tool\n",
+ " user_info: dict[str, Any]\n",
+ "\n",
+ "\n",
+ "@tool\n",
+ "def lookup_user_info(\n",
+ " tool_call_id: Annotated[str, InjectedToolCallId], config: RunnableConfig\n",
+ "):\n",
+ " \"\"\"Use this to look up user information to better assist them with their questions.\"\"\"\n",
+ " user_id = config.get(\"configurable\", {}).get(\"user_id\")\n",
+ " if user_id is None:\n",
+ " raise ValueError(\"Please provide user ID\")\n",
+ "\n",
+ " if user_id not in USER_ID_TO_USER_INFO:\n",
+ " raise ValueError(f\"User '{user_id}' not found\")\n",
+ "\n",
+ " user_info = USER_ID_TO_USER_INFO[user_id]\n",
+ " return Command(\n",
+ " update={\n",
+ " # update the state keys\n",
+ " \"user_info\": user_info,\n",
+ " # update the message history\n",
+ " \"messages\": [\n",
+ " ToolMessage(\n",
+ " \"Successfully looked up user information\", tool_call_id=tool_call_id\n",
+ " )\n",
+ " ],\n",
+ " }\n",
+ " )"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b99e5f24-5e5e-4a34-baae-467182675bb5",
+ "metadata": {},
+ "source": [
+ "## Define prompt"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cbb06aea-6654-4245-91f8-af6e8f2b5377",
+ "metadata": {},
+ "source": [
+ "Let's now add personalization: we'll respond differently to the user based on the state values AFTER the state has been updated from the tool. To achieve this, let's define a function that will dynamically construct the system prompt based on the graph state. It will be called ever time the LLM is called and the function output will be passed to the LLM:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "c553d062-d145-4145-84bd-9b798f7c95c2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def state_modifier(state: State):\n",
+ " user_info = state.get(\"user_info\")\n",
+ " if user_info is None:\n",
+ " return state[\"messages\"]\n",
+ "\n",
+ " system_msg = (\n",
+ " f\"User name is {user_info['name']}. User lives in {user_info['location']}\"\n",
+ " )\n",
+ " return [{\"role\": \"system\", \"content\": system_msg}] + state[\"messages\"]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c5acdd5d-68be-466b-9c21-46cbed91d2bc",
+ "metadata": {},
+ "source": [
+ "## Define graph"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "afb65028-0359-46c8-b09c-ffc90180f759",
+ "metadata": {},
+ "source": [
+ "Finally, let's combine this into a single graph using the prebuilt `create_react_agent`:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "2d59db29-fd51-4d29-9854-21763a4855e3",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from langgraph.prebuilt import create_react_agent\n",
+ "from langchain_openai import ChatOpenAI\n",
+ "\n",
+ "model = ChatOpenAI(model=\"gpt-4o\")\n",
+ "\n",
+ "agent = create_react_agent(\n",
+ " model,\n",
+ " # pass the tool that can update state\n",
+ " [lookup_user_info],\n",
+ " state_schema=State,\n",
+ " # pass dynamic prompt function\n",
+ " state_modifier=state_modifier,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0782b8ab-a603-47b8-9a76-77f593402678",
+ "metadata": {},
+ "source": [
+ "## Use it!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6165e153-ab28-4404-adea-796c7bd0701b",
+ "metadata": {},
+ "source": [
+ "Let's now try running our agent. We'll need to provide user ID in the config so that our tool knows what information to look up:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "de34a58b-1765-4b63-a232-d46790aff884",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "{'agent': {'messages': [AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_7LSUh6ZDvGJAUvlWvXiCK4Gf', 'function': {'arguments': '{}', 'name': 'lookup_user_info'}, 'type': 'function'}], 'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 11, 'prompt_tokens': 56, 'total_tokens': 67, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0}}, 'model_name': 'gpt-4o-2024-08-06', 'system_fingerprint': 'fp_9d50cd990b', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-57eeb216-e35d-4501-aaac-b5c6b26fb17c-0', tool_calls=[{'name': 'lookup_user_info', 'args': {}, 'id': 'call_7LSUh6ZDvGJAUvlWvXiCK4Gf', 'type': 'tool_call'}], usage_metadata={'input_tokens': 56, 'output_tokens': 11, 'total_tokens': 67, 'input_token_details': {'audio': 0, 'cache_read': 0}, 'output_token_details': {'audio': 0, 'reasoning': 0}})]}}\n",
+ "\n",
+ "\n",
+ "{'tools': {'user_info': {'user_id': '1', 'name': 'Bob Dylan', 'location': 'New York, NY'}, 'messages': [ToolMessage(content='Successfully looked up user information', name='lookup_user_info', id='168d8ff8-b021-4c8b-a11a-3b50c30a072c', tool_call_id='call_7LSUh6ZDvGJAUvlWvXiCK4Gf')]}}\n",
+ "\n",
+ "\n",
+ "{'agent': {'messages': [AIMessage(content=\"Hi Bob! Since you're in New York, NY, there are plenty of exciting things to do over the weekend. Here are some suggestions:\\n\\n1. **Explore Central Park**: Take a leisurely walk, rent a bike, or have a picnic in this iconic park.\\n\\n2. **Visit a Museum**: Check out The Metropolitan Museum of Art or the Museum of Modern Art (MoMA) for an enriching cultural experience.\\n\\n3. **Broadway Show**: Catch a Broadway show or an off-Broadway performance for some world-class entertainment.\\n\\n4. **Food Tour**: Explore different neighborhoods like Greenwich Village or Williamsburg for diverse culinary experiences.\\n\\n5. **Brooklyn Bridge Walk**: Take a walk across the Brooklyn Bridge for stunning views of the city skyline.\\n\\n6. **Visit a Rooftop Bar**: Enjoy a drink with a view at one of New York’s many rooftop bars.\\n\\n7. **Explore a New Neighborhood**: Discover the unique charm of areas like SoHo, Chelsea, or Astoria.\\n\\n8. **Live Music**: Check out live music venues for a night of great performances.\\n\\n9. **Art Galleries**: Visit some of the smaller art galleries around Chelsea or the Lower East Side.\\n\\n10. **Attend a Local Event**: Look up any local events or festivals happening this weekend.\\n\\nFeel free to let me know if you want more details on any of these activities!\", additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 285, 'prompt_tokens': 95, 'total_tokens': 380, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0}}, 'model_name': 'gpt-4o-2024-08-06', 'system_fingerprint': 'fp_9d50cd990b', 'finish_reason': 'stop', 'logprobs': None}, id='run-f13ce15b-02b6-40e6-8264-c4d9edd0d03a-0', usage_metadata={'input_tokens': 95, 'output_tokens': 285, 'total_tokens': 380, 'input_token_details': {'audio': 0, 'cache_read': 0}, 'output_token_details': {'audio': 0, 'reasoning': 0}})]}}\n",
+ "\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "for chunk in agent.stream(\n",
+ " {\"messages\": [(\"user\", \"hi, what should i do this weekend?\")]},\n",
+ " # provide user ID in the config\n",
+ " {\"configurable\": {\"user_id\": \"1\"}},\n",
+ "):\n",
+ " print(chunk)\n",
+ " print(\"\\n\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d9b2281f-269c-41dd-b6b2-4c743f11ffc9",
+ "metadata": {},
+ "source": [
+ "We can see that the model correctly recommended some New York activities for Bob Dylan! Let's try getting recommendations for Taylor Swift:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "9d71af94-572a-4961-88a7-665e792cf96a",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "{'agent': {'messages': [AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_5HLtJtzcgmKbtmK6By21wW5Y', 'function': {'arguments': '{}', 'name': 'lookup_user_info'}, 'type': 'function'}], 'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 11, 'prompt_tokens': 56, 'total_tokens': 67, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0}}, 'model_name': 'gpt-4o-2024-08-06', 'system_fingerprint': 'fp_c7ca0ebaca', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-bacacd7d-76cc-4f6b-9e9b-d9e6f00b9391-0', tool_calls=[{'name': 'lookup_user_info', 'args': {}, 'id': 'call_5HLtJtzcgmKbtmK6By21wW5Y', 'type': 'tool_call'}], usage_metadata={'input_tokens': 56, 'output_tokens': 11, 'total_tokens': 67, 'input_token_details': {'audio': 0, 'cache_read': 0}, 'output_token_details': {'audio': 0, 'reasoning': 0}})]}}\n",
+ "\n",
+ "\n",
+ "{'tools': {'user_info': {'user_id': '2', 'name': 'Taylor Swift', 'location': 'Beverly Hills, CA'}, 'messages': [ToolMessage(content='Successfully looked up user information', name='lookup_user_info', id='d81ef31e-6d77-4f13-ae86-e2e6ba567e3d', tool_call_id='call_5HLtJtzcgmKbtmK6By21wW5Y')]}}\n",
+ "\n",
+ "\n",
+ "{'agent': {'messages': [AIMessage(content=\"Hi Taylor! Since you're in Beverly Hills, here are a few suggestions for a fun weekend:\\n\\n1. **Hiking at Runyon Canyon**: Enjoy a scenic hike with beautiful views of Los Angeles. It's a great way to get some exercise and enjoy the outdoors.\\n\\n2. **Visit Rodeo Drive**: Spend some time shopping or window shopping at the famous Rodeo Drive. You might even spot some celebrities!\\n\\n3. **Explore the Getty Center**: Check out the art collections and beautiful gardens at the Getty Center. The architecture and views are stunning.\\n\\n4. **Relax at a Spa**: Treat yourself to a relaxing day at one of Beverly Hills' luxurious spas.\\n\\n5. **Dining Out**: Try a new restaurant or visit your favorite spot for a delicious meal. Beverly Hills has a fantastic dining scene.\\n\\n6. **Attend a Local Event**: Check out any local events or concerts happening this weekend. Beverly Hills often hosts exciting events.\\n\\nEnjoy your weekend!\", additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 198, 'prompt_tokens': 95, 'total_tokens': 293, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0}}, 'model_name': 'gpt-4o-2024-08-06', 'system_fingerprint': 'fp_c7ca0ebaca', 'finish_reason': 'stop', 'logprobs': None}, id='run-2057df76-f192-4c69-a66a-1f0a86bf5d66-0', usage_metadata={'input_tokens': 95, 'output_tokens': 198, 'total_tokens': 293, 'input_token_details': {'audio': 0, 'cache_read': 0}, 'output_token_details': {'audio': 0, 'reasoning': 0}})]}}\n",
+ "\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "for chunk in agent.stream(\n",
+ " {\"messages\": [(\"user\", \"hi, what should i do this weekend?\")]},\n",
+ " {\"configurable\": {\"user_id\": \"2\"}},\n",
+ "):\n",
+ " print(chunk)\n",
+ " print(\"\\n\")"
+ ]
+ }
+ ],
+ "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.12.3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/mkdocs.yml b/docs/mkdocs.yml
index bc1ff59ea..da7eaf3e3 100644
--- a/docs/mkdocs.yml
+++ b/docs/mkdocs.yml
@@ -192,6 +192,7 @@ nav:
- how-tos/tool-calling.ipynb
- how-tos/tool-calling-errors.ipynb
- how-tos/pass-run-time-values-to-tools.ipynb
+ - how-tos/update-state-from-tools.ipynb
- how-tos/pass-config-to-tools.ipynb
- how-tos/many-tools.ipynb
- Subgraphs:
@@ -199,6 +200,8 @@ nav:
- how-tos/subgraph.ipynb
- how-tos/subgraphs-manage-state.ipynb
- how-tos/subgraph-transform-state.ipynb
+ - Multi-agent:
+ - how-tos/multi-agent-network.ipynb
- State Management:
- State Management: how-tos#state-management
- how-tos/state-model.ipynb
diff --git a/libs/checkpoint-postgres/langgraph/store/postgres/aio.py b/libs/checkpoint-postgres/langgraph/store/postgres/aio.py
index e62d360cc..2354b3a8f 100644
--- a/libs/checkpoint-postgres/langgraph/store/postgres/aio.py
+++ b/libs/checkpoint-postgres/langgraph/store/postgres/aio.py
@@ -155,9 +155,6 @@ class AsyncPostgresStore(AsyncBatchedBaseStore, BasePostgresStore[_ainternal.Con
return results
- def batch(self, ops: Iterable[Op]) -> list[Result]:
- return asyncio.run_coroutine_threadsafe(self.abatch(ops), self.loop).result()
-
@classmethod
@asynccontextmanager
async def from_conn_string(
diff --git a/libs/checkpoint-postgres/tests/test_async_store.py b/libs/checkpoint-postgres/tests/test_async_store.py
index eda0e2820..068ec1502 100644
--- a/libs/checkpoint-postgres/tests/test_async_store.py
+++ b/libs/checkpoint-postgres/tests/test_async_store.py
@@ -1,8 +1,10 @@
# type: ignore
+import asyncio
import itertools
import sys
import uuid
from collections.abc import AsyncIterator
+from concurrent.futures import ThreadPoolExecutor
from contextlib import asynccontextmanager
from typing import Any, Optional
@@ -10,7 +12,13 @@ import pytest
from langchain_core.embeddings import Embeddings
from psycopg import AsyncConnection
-from langgraph.store.base import GetOp, Item, ListNamespacesOp, PutOp, SearchOp
+from langgraph.store.base import (
+ GetOp,
+ Item,
+ ListNamespacesOp,
+ PutOp,
+ SearchOp,
+)
from langgraph.store.postgres import AsyncPostgresStore
from tests.conftest import (
DEFAULT_URI,
@@ -63,6 +71,128 @@ async def store(request) -> AsyncIterator[AsyncPostgresStore]:
await conn.execute(f"DROP DATABASE {database}")
+async def test_no_running_loop(store: AsyncPostgresStore) -> None:
+ with pytest.raises(asyncio.InvalidStateError):
+ store.put(("foo", "bar"), "baz", {"val": "baz"})
+ with pytest.raises(asyncio.InvalidStateError):
+ store.get(("foo", "bar"), "baz")
+ with pytest.raises(asyncio.InvalidStateError):
+ store.delete(("foo", "bar"), "baz")
+ with pytest.raises(asyncio.InvalidStateError):
+ store.search(("foo", "bar"))
+ with pytest.raises(asyncio.InvalidStateError):
+ store.list_namespaces(prefix=("foo",))
+ with pytest.raises(asyncio.InvalidStateError):
+ store.batch([PutOp(namespace=("foo", "bar"), key="baz", value={"val": "baz"})])
+ with ThreadPoolExecutor(max_workers=1) as executor:
+ future = executor.submit(store.put, ("foo", "bar"), "baz", {"val": "baz"})
+ result = await asyncio.wrap_future(future)
+ assert result is None
+ future = executor.submit(store.get, ("foo", "bar"), "baz")
+ result = await asyncio.wrap_future(future)
+ assert result.value == {"val": "baz"}
+ result = await asyncio.wrap_future(
+ executor.submit(store.list_namespaces, prefix=("foo",))
+ )
+
+
+async def test_large_batches(request: Any, store: AsyncPostgresStore) -> None:
+ N = 100 # less important that we are performant here
+ M = 10
+
+ with ThreadPoolExecutor(max_workers=10) as executor:
+ futures = []
+ for m in range(M):
+ for i in range(N):
+ futures += [
+ executor.submit(
+ store.put,
+ ("test", "foo", "bar", "baz", str(m % 2)),
+ f"key{i}",
+ value={"foo": "bar" + str(i)},
+ ),
+ executor.submit(
+ store.get,
+ ("test", "foo", "bar", "baz", str(m % 2)),
+ f"key{i}",
+ ),
+ executor.submit(
+ store.list_namespaces,
+ prefix=None,
+ max_depth=m + 1,
+ ),
+ executor.submit(
+ store.search,
+ ("test",),
+ ),
+ executor.submit(
+ store.put,
+ ("test", "foo", "bar", "baz", str(m % 2)),
+ f"key{i}",
+ value={"foo": "bar" + str(i)},
+ ),
+ executor.submit(
+ store.put,
+ ("test", "foo", "bar", "baz", str(m % 2)),
+ f"key{i}",
+ None,
+ ),
+ ]
+
+ results = await asyncio.gather(
+ *(asyncio.wrap_future(future) for future in futures)
+ )
+ assert len(results) == M * N * 6
+
+
+async def test_large_batches_async(store: AsyncPostgresStore) -> None:
+ N = 1000
+ M = 10
+ coros = []
+ for m in range(M):
+ for i in range(N):
+ coros.append(
+ store.aput(
+ ("test", "foo", "bar", "baz", str(m % 2)),
+ f"key{i}",
+ value={"foo": "bar" + str(i)},
+ )
+ )
+ coros.append(
+ store.aget(
+ ("test", "foo", "bar", "baz", str(m % 2)),
+ f"key{i}",
+ )
+ )
+ coros.append(
+ store.alist_namespaces(
+ prefix=None,
+ max_depth=m + 1,
+ )
+ )
+ coros.append(
+ store.asearch(
+ ("test",),
+ )
+ )
+ coros.append(
+ store.aput(
+ ("test", "foo", "bar", "baz", str(m % 2)),
+ f"key{i}",
+ value={"foo": "bar" + str(i)},
+ )
+ )
+ coros.append(
+ store.adelete(
+ ("test", "foo", "bar", "baz", str(m % 2)),
+ f"key{i}",
+ )
+ )
+
+ results = await asyncio.gather(*coros)
+ assert len(results) == M * N * 6
+
+
async def test_abatch_order(store: AsyncPostgresStore) -> None:
# Setup test data
await store.aput(("test", "foo"), "key1", {"data": "value1"})
diff --git a/libs/checkpoint/langgraph/checkpoint/memory/__init__.py b/libs/checkpoint/langgraph/checkpoint/memory/__init__.py
index e30c082c7..cb6b7b852 100644
--- a/libs/checkpoint/langgraph/checkpoint/memory/__init__.py
+++ b/libs/checkpoint/langgraph/checkpoint/memory/__init__.py
@@ -1,4 +1,3 @@
-import asyncio
import logging
import os
import pickle
@@ -6,7 +5,6 @@ import random
import shutil
from collections import defaultdict
from contextlib import AbstractAsyncContextManager, AbstractContextManager, ExitStack
-from functools import partial
from types import TracebackType
from typing import Any, AsyncIterator, Dict, Iterator, Optional, Sequence, Tuple, Type
@@ -395,9 +393,7 @@ class MemorySaver(
Returns:
Optional[CheckpointTuple]: The retrieved checkpoint tuple, or None if no matching checkpoint was found.
"""
- return await asyncio.get_running_loop().run_in_executor(
- None, self.get_tuple, config
- )
+ return self.get_tuple(config)
async def alist(
self,
@@ -418,24 +414,8 @@ class MemorySaver(
Yields:
AsyncIterator[CheckpointTuple]: An asynchronous iterator of checkpoint tuples.
"""
- loop = asyncio.get_running_loop()
- iter = await loop.run_in_executor(
- None,
- partial(
- self.list,
- before=before,
- limit=limit,
- filter=filter,
- ),
- config,
- )
- while True:
- # handling StopIteration exception inside coroutine won't work
- # as expected, so using next() with default value to break the loop
- if item := await loop.run_in_executor(None, next, iter, None):
- yield item
- else:
- break
+ for item in self.list(config, filter=filter, before=before, limit=limit):
+ yield item
async def aput(
self,
@@ -455,9 +435,7 @@ class MemorySaver(
Returns:
RunnableConfig: The updated config containing the saved checkpoint's timestamp.
"""
- return await asyncio.get_running_loop().run_in_executor(
- None, self.put, config, checkpoint, metadata, new_versions
- )
+ return self.put(config, checkpoint, metadata, new_versions)
async def aput_writes(
self,
@@ -474,10 +452,9 @@ class MemorySaver(
config (RunnableConfig): The config to associate with the writes.
writes (List[Tuple[str, Any]]): The writes to save, each as a (channel, value) pair.
task_id (str): Identifier for the task creating the writes.
+ return self.put_writes(config, writes, task_id)
"""
- return await asyncio.get_running_loop().run_in_executor(
- None, self.put_writes, config, writes, task_id
- )
+ return self.put_writes(config, writes, task_id)
def get_next_version(self, current: Optional[str], channel: ChannelProtocol) -> str:
if current is None:
diff --git a/libs/checkpoint/langgraph/store/base/batch.py b/libs/checkpoint/langgraph/store/base/batch.py
index 33c502574..6cfc11419 100644
--- a/libs/checkpoint/langgraph/store/base/batch.py
+++ b/libs/checkpoint/langgraph/store/base/batch.py
@@ -1,6 +1,7 @@
import asyncio
+import functools
import weakref
-from typing import Any, Literal, Optional, Union
+from typing import Any, Callable, Iterable, Literal, Optional, TypeVar, Union
from langgraph.store.base import (
BaseStore,
@@ -11,11 +12,39 @@ from langgraph.store.base import (
NamespacePath,
Op,
PutOp,
+ Result,
SearchItem,
SearchOp,
_validate_namespace,
)
+F = TypeVar("F", bound=Callable)
+
+
+def _check_loop(func: F) -> F:
+ @functools.wraps(func)
+ def wrapper(store: "AsyncBatchedBaseStore", *args: Any, **kwargs: Any) -> Any:
+ method_name: str = func.__name__
+ try:
+ current_loop = asyncio.get_running_loop()
+ if current_loop is store._loop:
+ replacement_str = (
+ f"Specifically, replace `store.{method_name}(...)` with `await store.a{method_name}(...)"
+ if method_name
+ else "For example, replace `store.get(...)` with `await store.aget(...)`"
+ )
+ raise asyncio.InvalidStateError(
+ f"Synchronous calls to {store.__class__.__name__} detected in the main event loop. "
+ "This can lead to deadlocks or performance issues. "
+ "Please use the asynchronous interface for main thread operations. "
+ f"{replacement_str} "
+ )
+ except RuntimeError:
+ pass
+ return func(store, *args, **kwargs)
+
+ return wrapper
+
class AsyncBatchedBaseStore(BaseStore):
"""Efficiently batch operations in a background task."""
@@ -23,6 +52,7 @@ class AsyncBatchedBaseStore(BaseStore):
__slots__ = ("_loop", "_aqueue", "_task")
def __init__(self) -> None:
+ super().__init__()
self._loop = asyncio.get_running_loop()
self._aqueue: dict[asyncio.Future, Op] = {}
self._task = self._loop.create_task(_run(self._aqueue, weakref.ref(self)))
@@ -99,6 +129,82 @@ class AsyncBatchedBaseStore(BaseStore):
self._aqueue[fut] = op
return await fut
+ @_check_loop
+ def batch(self, ops: Iterable[Op]) -> list[Result]:
+ return asyncio.run_coroutine_threadsafe(self.abatch(ops), self._loop).result()
+
+ @_check_loop
+ def get(
+ self,
+ namespace: tuple[str, ...],
+ key: str,
+ ) -> Optional[Item]:
+ return asyncio.run_coroutine_threadsafe(
+ self.aget(namespace, key=key), self._loop
+ ).result()
+
+ @_check_loop
+ def search(
+ self,
+ namespace_prefix: tuple[str, ...],
+ /,
+ *,
+ query: Optional[str] = None,
+ filter: Optional[dict[str, Any]] = None,
+ limit: int = 10,
+ offset: int = 0,
+ ) -> list[SearchItem]:
+ return asyncio.run_coroutine_threadsafe(
+ self.asearch(
+ namespace_prefix, query=query, filter=filter, limit=limit, offset=offset
+ ),
+ self._loop,
+ ).result()
+
+ @_check_loop
+ def put(
+ self,
+ namespace: tuple[str, ...],
+ key: str,
+ value: dict[str, Any],
+ index: Optional[Union[Literal[False], list[str]]] = None,
+ ) -> None:
+ _validate_namespace(namespace)
+ asyncio.run_coroutine_threadsafe(
+ self.aput(namespace, key=key, value=value, index=index), self._loop
+ ).result()
+
+ @_check_loop
+ def delete(
+ self,
+ namespace: tuple[str, ...],
+ key: str,
+ ) -> None:
+ asyncio.run_coroutine_threadsafe(
+ self.adelete(namespace, key=key), self._loop
+ ).result()
+
+ @_check_loop
+ def list_namespaces(
+ self,
+ *,
+ prefix: Optional[NamespacePath] = None,
+ suffix: Optional[NamespacePath] = None,
+ max_depth: Optional[int] = None,
+ limit: int = 100,
+ offset: int = 0,
+ ) -> list[tuple[str, ...]]:
+ return asyncio.run_coroutine_threadsafe(
+ self.alist_namespaces(
+ prefix=prefix,
+ suffix=suffix,
+ max_depth=max_depth,
+ limit=limit,
+ offset=offset,
+ ),
+ self._loop,
+ ).result()
+
def _dedupe_ops(values: list[Op]) -> tuple[Optional[list[int]], list[Op]]:
"""Dedupe operations while preserving order for results.
@@ -144,7 +250,8 @@ def _dedupe_ops(values: list[Op]) -> tuple[Optional[list[int]], list[Op]]:
async def _run(
- aqueue: dict[asyncio.Future, Op], store: weakref.ReferenceType[BaseStore]
+ aqueue: dict[asyncio.Future, Op],
+ store: weakref.ReferenceType[BaseStore],
) -> None:
while True:
await asyncio.sleep(0)
diff --git a/libs/langgraph/langgraph/func/__init__.py b/libs/langgraph/langgraph/func/__init__.py
index 2dda24754..26d583ed2 100644
--- a/libs/langgraph/langgraph/func/__init__.py
+++ b/libs/langgraph/langgraph/func/__init__.py
@@ -1,6 +1,7 @@
import asyncio
import concurrent
import concurrent.futures
+import inspect
import types
from functools import partial, update_wrapper
from typing import (
@@ -24,7 +25,7 @@ from langgraph.pregel.call import get_runnable_for_func
from langgraph.pregel.read import PregelNode
from langgraph.pregel.write import ChannelWrite, ChannelWriteEntry
from langgraph.store.base import BaseStore
-from langgraph.types import RetryPolicy
+from langgraph.types import RetryPolicy, StreamMode, StreamWriter
P = ParamSpec("P")
P1 = TypeVar("P1")
@@ -76,10 +77,32 @@ def entrypoint(
store: Optional[BaseStore] = None,
) -> Callable[[types.FunctionType], Pregel]:
def _imp(func: types.FunctionType) -> Pregel:
+ if inspect.isgeneratorfunction(func):
+
+ def gen_wrapper(*args: Any, writer: StreamWriter, **kwargs: Any) -> Any:
+ for chunk in func(*args, **kwargs):
+ writer(chunk)
+
+ bound = get_runnable_for_func(gen_wrapper)
+ stream_mode: StreamMode = "custom"
+ elif inspect.isasyncgenfunction(func):
+
+ async def agen_wrapper(
+ *args: Any, writer: StreamWriter, **kwargs: Any
+ ) -> Any:
+ async for chunk in func(*args, **kwargs):
+ writer(chunk)
+
+ bound = get_runnable_for_func(agen_wrapper)
+ stream_mode = "custom"
+ else:
+ bound = get_runnable_for_func(func)
+ stream_mode = "updates"
+
return Pregel(
nodes={
func.__name__: PregelNode(
- bound=get_runnable_for_func(func),
+ bound=bound,
triggers=[START],
channels=[START],
writers=[ChannelWrite([ChannelWriteEntry(END)], tags=[TAG_HIDDEN])],
@@ -89,7 +112,7 @@ def entrypoint(
input_channels=START,
output_channels=END,
stream_channels=END,
- stream_mode="updates",
+ stream_mode=stream_mode,
checkpointer=checkpointer,
store=store,
)
diff --git a/libs/langgraph/langgraph/graph/state.py b/libs/langgraph/langgraph/graph/state.py
index c416d5f6a..7a5614f91 100644
--- a/libs/langgraph/langgraph/graph/state.py
+++ b/libs/langgraph/langgraph/graph/state.py
@@ -559,6 +559,7 @@ class StateGraph(Graph):
for key, node in self.nodes.items():
compiled.attach_node(key, node)
+ compiled.attach_branch(START, SELF, CONTROL_BRANCH, with_reader=False)
for key, node in self.nodes.items():
compiled.attach_branch(key, SELF, CONTROL_BRANCH, with_reader=False)
diff --git a/libs/langgraph/langgraph/prebuilt/tool_node.py b/libs/langgraph/langgraph/prebuilt/tool_node.py
index 38c349edb..d3d0751e2 100644
--- a/libs/langgraph/langgraph/prebuilt/tool_node.py
+++ b/libs/langgraph/langgraph/prebuilt/tool_node.py
@@ -1,7 +1,7 @@
import asyncio
import inspect
import json
-from copy import copy
+from copy import copy, deepcopy
from typing import (
Any,
Callable,
@@ -20,6 +20,7 @@ from langchain_core.messages import (
AnyMessage,
ToolCall,
ToolMessage,
+ convert_to_messages,
)
from langchain_core.runnables import RunnableConfig
from langchain_core.runnables.config import (
@@ -35,6 +36,7 @@ from typing_extensions import Annotated, get_args, get_origin
from langgraph.errors import GraphBubbleUp
from langgraph.store.base import BaseStore
+from langgraph.types import Command
from langgraph.utils.runnable import RunnableCallable
INVALID_TOOL_NAME_ERROR_TEMPLATE = (
@@ -47,7 +49,7 @@ def msg_content_output(output: Any) -> Union[str, list[dict]]:
recognized_content_block_types = ("image", "image_url", "text", "json")
if isinstance(output, str):
return output
- elif all(
+ elif isinstance(output, list) and all(
[
isinstance(x, dict) and x.get("type") in recognized_content_block_types
for x in output
@@ -210,12 +212,31 @@ class ToolNode(RunnableCallable):
*,
store: BaseStore,
) -> Any:
- tool_calls, output_type = self._parse_input(input, store)
+ tool_calls, input_type = self._parse_input(input, store)
config_list = get_config_list(config, len(tool_calls))
+ input_types = [input_type] * len(tool_calls)
with get_executor_for_config(config) as executor:
- outputs = [*executor.map(self._run_one, tool_calls, config_list)]
- # TypedDict, pydantic, dataclass, etc. should all be able to load from dict
- return outputs if output_type == "list" else {self.messages_key: outputs}
+ outputs = [
+ *executor.map(self._run_one, tool_calls, input_types, config_list)
+ ]
+
+ # preserve existing behavior for non-command tool outputs for backwards compatibility
+ if not any(isinstance(output, Command) for output in outputs):
+ # TypedDict, pydantic, dataclass, etc. should all be able to load from dict
+ return outputs if input_type == "list" else {self.messages_key: outputs}
+
+ # LangGraph will automatically handle list of Command and non-command node updates
+ combined_outputs: list[
+ Command | list[ToolMessage] | dict[str, list[ToolMessage]]
+ ] = []
+ for output in outputs:
+ if isinstance(output, Command):
+ combined_outputs.append(output)
+ else:
+ combined_outputs.append(
+ [output] if input_type == "list" else {self.messages_key: [output]}
+ )
+ return combined_outputs
def invoke(
self, input: Input, config: Optional[RunnableConfig] = None, **kwargs: Any
@@ -242,26 +263,97 @@ class ToolNode(RunnableCallable):
*,
store: BaseStore,
) -> Any:
- tool_calls, output_type = self._parse_input(input, store)
+ tool_calls, input_type = self._parse_input(input, store)
outputs = await asyncio.gather(
- *(self._arun_one(call, config) for call in tool_calls)
+ *(self._arun_one(call, input_type, config) for call in tool_calls)
)
- # TypedDict, pydantic, dataclass, etc. should all be able to load from dict
- return outputs if output_type == "list" else {self.messages_key: outputs}
- def _run_one(self, call: ToolCall, config: RunnableConfig) -> ToolMessage:
+ # preserve existing behavior for non-command tool outputs for backwards compatibility
+ if not any(isinstance(output, Command) for output in outputs):
+ # TypedDict, pydantic, dataclass, etc. should all be able to load from dict
+ return outputs if input_type == "list" else {self.messages_key: outputs}
+
+ # LangGraph will automatically handle list of Command and non-command node updates
+ combined_outputs: list[
+ Command | list[ToolMessage] | dict[str, list[ToolMessage]]
+ ] = []
+ for output in outputs:
+ if isinstance(output, Command):
+ combined_outputs.append(output)
+ else:
+ combined_outputs.append(
+ [output] if input_type == "list" else {self.messages_key: [output]}
+ )
+ return combined_outputs
+
+ def _run_one(
+ self,
+ call: ToolCall,
+ input_type: Literal["list", "dict"],
+ config: RunnableConfig,
+ ) -> ToolMessage:
if invalid_tool_message := self._validate_tool_call(call):
return invalid_tool_message
try:
input = {**call, **{"type": "tool_call"}}
- tool_message: ToolMessage = self.tools_by_name[call["name"]].invoke(
- input, config
+ response = self.tools_by_name[call["name"]].invoke(input)
+
+ # GraphInterrupt is a special exception that will always be raised.
+ # It can be triggered in the following scenarios:
+ # (1) a NodeInterrupt is raised inside a tool
+ # (2) a NodeInterrupt is raised inside a graph node for a graph called as a tool
+ # (3) a GraphInterrupt is raised when a subgraph is interrupted inside a graph called as a tool
+ # (2 and 3 can happen in a "supervisor w/ tools" multi-agent architecture)
+ except GraphBubbleUp as e:
+ raise e
+ except Exception as e:
+ if isinstance(self.handle_tool_errors, tuple):
+ handled_types: tuple = self.handle_tool_errors
+ elif callable(self.handle_tool_errors):
+ handled_types = _infer_handled_types(self.handle_tool_errors)
+ else:
+ # default behavior is catching all exceptions
+ handled_types = (Exception,)
+
+ # Unhandled
+ if not self.handle_tool_errors or not isinstance(e, handled_types):
+ raise e
+ # Handled
+ else:
+ content = _handle_tool_error(e, flag=self.handle_tool_errors)
+ return ToolMessage(
+ content=content,
+ name=call["name"],
+ tool_call_id=call["id"],
+ status="error",
)
- tool_message.content = cast(
- Union[str, list], msg_content_output(tool_message.content)
+
+ if isinstance(response, Command):
+ return self._validate_tool_command(response, call, input_type)
+ elif isinstance(response, ToolMessage):
+ response.content = cast(
+ Union[str, list], msg_content_output(response.content)
)
- return tool_message
+ return response
+ else:
+ raise TypeError(
+ f"Tool {call['name']} returned unexpected type: {type(response)}"
+ )
+
+ async def _arun_one(
+ self,
+ call: ToolCall,
+ input_type: Literal["list", "dict"],
+ config: RunnableConfig,
+ ) -> ToolMessage:
+ if invalid_tool_message := self._validate_tool_call(call):
+ return invalid_tool_message
+
+ try:
+ input = {**call, **{"type": "tool_call"}}
+ response = await self.tools_by_name[call["name"]].ainvoke(input)
+
# GraphInterrupt is a special exception that will always be raised.
# It can be triggered in the following scenarios:
# (1) a NodeInterrupt is raised inside a tool
@@ -286,50 +378,24 @@ class ToolNode(RunnableCallable):
else:
content = _handle_tool_error(e, flag=self.handle_tool_errors)
- return ToolMessage(
- content=content, name=call["name"], tool_call_id=call["id"], status="error"
- )
-
- async def _arun_one(self, call: ToolCall, config: RunnableConfig) -> ToolMessage:
- if invalid_tool_message := self._validate_tool_call(call):
- return invalid_tool_message
-
- try:
- input = {**call, **{"type": "tool_call"}}
- tool_message: ToolMessage = await self.tools_by_name[call["name"]].ainvoke(
- input, config
+ return ToolMessage(
+ content=content,
+ name=call["name"],
+ tool_call_id=call["id"],
+ status="error",
)
- tool_message.content = cast(
- Union[str, list], msg_content_output(tool_message.content)
+
+ if isinstance(response, Command):
+ return self._validate_tool_command(response, call, input_type)
+ elif isinstance(response, ToolMessage):
+ response.content = cast(
+ Union[str, list], msg_content_output(response.content)
+ )
+ return response
+ else:
+ raise TypeError(
+ f"Tool {call['name']} returned unexpected type: {type(response)}"
)
- return tool_message
- # GraphInterrupt is a special exception that will always be raised.
- # It can be triggered in the following scenarios:
- # (1) a NodeInterrupt is raised inside a tool
- # (2) a NodeInterrupt is raised inside a graph node for a graph called as a tool
- # (3) a GraphInterrupt is raised when a subgraph is interrupted inside a graph called as a tool
- # (2 and 3 can happen in a "supervisor w/ tools" multi-agent architecture)
- except GraphBubbleUp as e:
- raise e
- except Exception as e:
- if isinstance(self.handle_tool_errors, tuple):
- handled_types: tuple = self.handle_tool_errors
- elif callable(self.handle_tool_errors):
- handled_types = _infer_handled_types(self.handle_tool_errors)
- else:
- # default behavior is catching all exceptions
- handled_types = (Exception,)
-
- # Unhandled
- if not self.handle_tool_errors or not isinstance(e, handled_types):
- raise e
- # Handled
- else:
- content = _handle_tool_error(e, flag=self.handle_tool_errors)
-
- return ToolMessage(
- content=content, name=call["name"], tool_call_id=call["id"], status="error"
- )
def _parse_input(
self,
@@ -341,14 +407,14 @@ class ToolNode(RunnableCallable):
store: BaseStore,
) -> Tuple[list[ToolCall], Literal["list", "dict"]]:
if isinstance(input, list):
- output_type = "list"
+ input_type = "list"
message: AnyMessage = input[-1]
elif isinstance(input, dict) and (messages := input.get(self.messages_key, [])):
- output_type = "dict"
+ input_type = "dict"
message = messages[-1]
elif messages := getattr(input, self.messages_key, None):
# Assume dataclass-like state that can coerce from dict
- output_type = "dict"
+ input_type = "dict"
message = messages[-1]
else:
raise ValueError("No message found in input")
@@ -359,7 +425,7 @@ class ToolNode(RunnableCallable):
tool_calls = [
self._inject_tool_args(call, input, store) for call in message.tool_calls
]
- return tool_calls, output_type
+ return tool_calls, input_type
def _validate_tool_call(self, call: ToolCall) -> Optional[ToolMessage]:
if (requested_tool := call["name"]) not in self.tools_by_name:
@@ -453,6 +519,67 @@ class ToolNode(RunnableCallable):
tool_call_with_store = self._inject_store(tool_call_with_state, store)
return tool_call_with_store
+ def _validate_tool_command(
+ self, command: Command, call: ToolCall, input_type: Literal["list", "dict"]
+ ) -> Command:
+ if isinstance(command.update, dict):
+ # input type is dict when ToolNode is invoked with a dict input (e.g. {"messages": [AIMessage(..., tool_calls=[...])]})
+ if input_type != "dict":
+ raise ValueError(
+ f"Tools can provide a dict in Command.update only when using dict with '{self.messages_key}' key as ToolNode input, "
+ f"got: {command.update} for tool '{call['name']}'"
+ )
+
+ updated_command = deepcopy(command)
+ state_update = cast(dict[str, Any], updated_command.update) or {}
+ messages_update = state_update.get(self.messages_key, [])
+ elif isinstance(command.update, list):
+ # input type is list when ToolNode is invoked with a list input (e.g. [AIMessage(..., tool_calls=[...])])
+ if input_type != "list":
+ raise ValueError(
+ f"Tools can provide a list of messages in Command.update only when using list of messages as ToolNode input, "
+ f"got: {command.update} for tool '{call['name']}'"
+ )
+
+ updated_command = deepcopy(command)
+ messages_update = updated_command.update
+ else:
+ return command
+
+ # convert to message objects if updates are in a dict format
+ messages_update = convert_to_messages(messages_update)
+ have_seen_tool_messages = False
+ for message in messages_update:
+ if not isinstance(message, ToolMessage):
+ continue
+
+ if have_seen_tool_messages:
+ raise ValueError(
+ f"Expected at most one ToolMessage in Command.update for tool '{call['name']}', got multiple: {messages_update}."
+ )
+
+ if message.tool_call_id != call["id"]:
+ raise ValueError(
+ f"ToolMessage.tool_call_id must match the tool call id. Expected: {call['id']}, got: {message.tool_call_id} for tool '{call['name']}'."
+ )
+
+ message.name = call["name"]
+ have_seen_tool_messages = True
+
+ # validate that we always have exactly one ToolMessage in Command.update if command is sent to the CURRENT graph
+ if updated_command.graph is None and not have_seen_tool_messages:
+ example_update = (
+ '`Command(update={"messages": [ToolMessage("Success", tool_call_id=tool_call_id), ...]}, ...)`'
+ if input_type == "dict"
+ else '`Command(update=[ToolMessage("Success", tool_call_id=tool_call_id), ...], ...)`'
+ )
+ raise ValueError(
+ f"Expected exactly one message (ToolMessage) in Command.update for tool '{call['name']}', got: {messages_update}. "
+ "Every tool call (LLM requesting to call a tool) in the message history MUST have a corresponding ToolMessage. "
+ f"You can fix it by modifying the tool to return {example_update}."
+ )
+ return updated_command
+
def tools_condition(
state: Union[list[AnyMessage], dict[str, Any], BaseModel],
diff --git a/libs/langgraph/langgraph/pregel/__init__.py b/libs/langgraph/langgraph/pregel/__init__.py
index e714afe21..ba4533830 100644
--- a/libs/langgraph/langgraph/pregel/__init__.py
+++ b/libs/langgraph/langgraph/pregel/__init__.py
@@ -18,7 +18,6 @@ from typing import (
Type,
Union,
cast,
- get_type_hints,
overload,
)
from uuid import UUID, uuid5
@@ -117,6 +116,7 @@ from langgraph.utils.config import (
patch_config,
patch_configurable,
)
+from langgraph.utils.fields import get_enhanced_type_hints
from langgraph.utils.pydantic import create_model
from langgraph.utils.queue import AsyncQueue, SyncQueue # type: ignore[attr-defined]
@@ -319,8 +319,15 @@ class Pregel(PregelProtocol):
)
+ (
[
- ConfigurableFieldSpec(id=name, annotation=typ)
- for name, typ in get_type_hints(self.config_type).items()
+ ConfigurableFieldSpec(
+ id=name,
+ annotation=typ,
+ default=default,
+ description=description,
+ )
+ for name, typ, default, description in get_enhanced_type_hints(
+ self.config_type
+ )
]
if self.config_type is not None
else []
diff --git a/libs/langgraph/langgraph/pregel/io.py b/libs/langgraph/langgraph/pregel/io.py
index f2df972d8..d54f8b8b2 100644
--- a/libs/langgraph/langgraph/pregel/io.py
+++ b/libs/langgraph/langgraph/pregel/io.py
@@ -14,6 +14,8 @@ from langgraph.constants import (
PUSH,
RESUME,
RETURN,
+ SELF,
+ START,
TAG_HIDDEN,
TASKS,
)
@@ -79,12 +81,14 @@ def map_command(
else:
sends = [cmd.goto]
for send in sends:
- if not isinstance(send, Send):
+ if isinstance(send, Send):
+ yield (NULL_TASK_ID, PUSH if FF_SEND_V2 else TASKS, send)
+ elif isinstance(send, str):
+ yield (NULL_TASK_ID, f"branch:{START}:{SELF}:{send}", START)
+ else:
raise TypeError(
- f"In Command.goto, expected Send, got {type(send).__name__}"
+ f"In Command.goto, expected Send/str, got {type(send).__name__}"
)
- yield (NULL_TASK_ID, PUSH if FF_SEND_V2 else TASKS, send)
- # TODO handle goto str for state graph
if cmd.resume:
if isinstance(cmd.resume, dict) and all(is_task_id(k) for k in cmd.resume):
for tid, resume in cmd.resume.items():
diff --git a/libs/langgraph/langgraph/pregel/loop.py b/libs/langgraph/langgraph/pregel/loop.py
index 678e355ab..cf0716e7c 100644
--- a/libs/langgraph/langgraph/pregel/loop.py
+++ b/libs/langgraph/langgraph/pregel/loop.py
@@ -311,7 +311,9 @@ class PregelLoop(LoopProtocol):
) -> Optional[PregelExecutableTask]:
"""Accept a PUSH from a task, potentially returning a new task to start."""
# don't start if we should interrupt *after* the original task
- if should_interrupt(self.checkpoint, self.interrupt_after, [task]):
+ if self.interrupt_after and should_interrupt(
+ self.checkpoint, self.interrupt_after, [task]
+ ):
self.to_interrupt.append(task)
return
if pushed := cast(
@@ -333,7 +335,9 @@ class PregelLoop(LoopProtocol):
),
):
# don't start if we should interrupt *before* the new task
- if should_interrupt(self.checkpoint, self.interrupt_before, [pushed]):
+ if self.interrupt_before and should_interrupt(
+ self.checkpoint, self.interrupt_before, [pushed]
+ ):
self.to_interrupt.append(pushed)
return
# produce debug output
@@ -409,7 +413,7 @@ class PregelLoop(LoopProtocol):
}
)
# after execution, check if we should interrupt
- if should_interrupt(
+ if self.interrupt_after and should_interrupt(
self.checkpoint, self.interrupt_after, self.tasks.values()
):
self.status = "interrupt_after"
@@ -422,18 +426,6 @@ class PregelLoop(LoopProtocol):
self.status = "out_of_steps"
return False
- # apply NULL writes
- if null_writes := [
- w[1:] for w in self.checkpoint_pending_writes if w[0] == NULL_TASK_ID
- ]:
- mv_writes = apply_writes(
- self.checkpoint,
- self.channels,
- [PregelTaskWrites((), INPUT, null_writes, [])],
- self.checkpointer_get_next_version,
- )
- for key, values in mv_writes.items():
- self._update_mv(key, values)
# prepare next tasks
self.tasks = prepare_next_tasks(
self.checkpoint,
@@ -493,7 +485,7 @@ class PregelLoop(LoopProtocol):
return self.tick(input_keys=input_keys)
# before execution, check if we should interrupt
- if should_interrupt(
+ if self.interrupt_before and should_interrupt(
self.checkpoint, self.interrupt_before, self.tasks.values()
):
self.status = "interrupt_before"
@@ -535,9 +527,35 @@ class PregelLoop(LoopProtocol):
# - receiving None input (outer graph) or RESUMING flag (subgraph)
configurable = self.config.get(CONF, {})
is_resuming = bool(self.checkpoint["channel_versions"]) and bool(
- configurable.get(CONFIG_KEY_RESUMING, self.input is None)
+ configurable.get(
+ CONFIG_KEY_RESUMING,
+ self.input is None or isinstance(self.input, Command),
+ )
)
+ # map command to writes
+ if isinstance(self.input, Command):
+ writes: defaultdict[str, list[tuple[str, Any]]] = defaultdict(list)
+ # group writes by task ID
+ for tid, c, v in map_command(self.input, self.checkpoint_pending_writes):
+ writes[tid].append((c, v))
+ if not writes:
+ raise EmptyInputError("Received empty Command input")
+ # save writes
+ for tid, ws in writes.items():
+ self.put_writes(tid, ws)
+ # apply NULL writes
+ if null_writes := [
+ w[1:] for w in self.checkpoint_pending_writes if w[0] == NULL_TASK_ID
+ ]:
+ mv_writes = apply_writes(
+ self.checkpoint,
+ self.channels,
+ [PregelTaskWrites((), INPUT, null_writes, [])],
+ self.checkpointer_get_next_version,
+ )
+ for key, values in mv_writes.items():
+ self._update_mv(key, values)
# proceed past previous checkpoint
if is_resuming:
self.checkpoint["versions_seen"].setdefault(INTERRUPT, {})
@@ -549,17 +567,6 @@ class PregelLoop(LoopProtocol):
self._emit(
"values", map_output_values, self.output_keys, True, self.channels
)
- # map command to writes
- elif isinstance(self.input, Command):
- writes: defaultdict[str, list[tuple[str, Any]]] = defaultdict(list)
- # group writes by task ID
- for tid, c, v in map_command(self.input, self.checkpoint_pending_writes):
- writes[tid].append((c, v))
- if not writes:
- raise EmptyInputError("Received empty Command input")
- # save writes
- for tid, ws in writes.items():
- self.put_writes(tid, ws)
# map inputs to channel updates
elif input_writes := deque(map_input(input_keys, self.input)):
# TODO shouldn't these writes be passed to put_writes too?
diff --git a/libs/langgraph/langgraph/types.py b/libs/langgraph/langgraph/types.py
index 1c23ad4de..850f8ff41 100644
--- a/libs/langgraph/langgraph/types.py
+++ b/libs/langgraph/langgraph/types.py
@@ -32,6 +32,14 @@ if TYPE_CHECKING:
from langgraph.store.base import BaseStore
+try:
+ from langchain_core.messages.tool import ToolOutputMixin
+except ImportError:
+
+ class ToolOutputMixin: # type: ignore[no-redef]
+ pass
+
+
All = Literal["*"]
"""Special value to indicate that graph should interrupt on all nodes."""
@@ -244,7 +252,7 @@ N = TypeVar("N", bound=Hashable)
@dataclasses.dataclass(**_DC_KWARGS)
-class Command(Generic[N]):
+class Command(Generic[N], ToolOutputMixin):
"""One or more commands to update the graph's state and send messages to nodes.
Args:
@@ -339,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,
diff --git a/libs/langgraph/langgraph/utils/fields.py b/libs/langgraph/langgraph/utils/fields.py
index f4786cb34..009e5aee1 100644
--- a/libs/langgraph/langgraph/utils/fields.py
+++ b/libs/langgraph/langgraph/utils/fields.py
@@ -1,5 +1,5 @@
import dataclasses
-from typing import Any, Optional, Type, Union
+from typing import Any, Generator, Optional, Type, Union, get_type_hints
from typing_extensions import Annotated, NotRequired, ReadOnly, Required, get_origin
@@ -106,3 +106,44 @@ def get_field_default(name: str, type_: Any, schema: Type[Any]) -> Any:
if _is_optional_type(type_):
return None
return ...
+
+
+def get_enhanced_type_hints(
+ type: Type[Any],
+) -> Generator[tuple[str, Any, Any, Optional[str]], None, None]:
+ """Attempt to extract default values and descriptions from provided type, used for config schema."""
+ for name, typ in get_type_hints(type).items():
+ default = None
+ description = None
+
+ # Pydantic models
+ try:
+ if hasattr(type, "__fields__") and name in type.__fields__:
+ field = type.__fields__[name]
+
+ if hasattr(field, "description") and field.description is not None:
+ description = field.description
+
+ if hasattr(field, "default") and field.default is not None:
+ default = field.default
+ if (
+ hasattr(default, "__class__")
+ and getattr(default.__class__, "__name__", "")
+ == "PydanticUndefinedType"
+ ):
+ default = None
+
+ except (AttributeError, KeyError, TypeError):
+ pass
+
+ # TypedDict, dataclass
+ try:
+ if hasattr(type, "__dict__"):
+ type_dict = getattr(type, "__dict__")
+
+ if name in type_dict:
+ default = type_dict[name]
+ except (AttributeError, KeyError, TypeError):
+ pass
+
+ yield name, typ, default, description
diff --git a/libs/langgraph/langgraph/utils/runnable.py b/libs/langgraph/langgraph/utils/runnable.py
index ccebba862..7cd6a85b9 100644
--- a/libs/langgraph/langgraph/utils/runnable.py
+++ b/libs/langgraph/langgraph/utils/runnable.py
@@ -404,12 +404,10 @@ class RunnableSeq(Runnable):
config = patch_config(
config, callbacks=run_manager.get_child(f"seq:step:{i+1}")
)
- context = copy_context()
- context.run(_set_config_context, config)
if i == 0:
- input = context.run(step.invoke, input, config, **kwargs)
+ input = step.invoke(input, config, **kwargs)
else:
- input = context.run(step.invoke, input, config)
+ input = step.invoke(input, config)
# finish the root run
except BaseException as e:
run_manager.on_chain_error(e)
@@ -443,16 +441,10 @@ class RunnableSeq(Runnable):
config = patch_config(
config, callbacks=run_manager.get_child(f"seq:step:{i+1}")
)
- context = copy_context()
- context.run(_set_config_context, config)
if i == 0:
- coro = step.ainvoke(input, config, **kwargs)
+ input = await step.ainvoke(input, config, **kwargs)
else:
- coro = step.ainvoke(input, config)
- if ASYNCIO_ACCEPTS_CONTEXT:
- input = await asyncio.create_task(coro, context=context)
- else:
- input = await asyncio.create_task(coro)
+ input = await step.ainvoke(input, config)
# finish the root run
except BaseException as e:
await run_manager.on_chain_error(e)
diff --git a/libs/langgraph/poetry.lock b/libs/langgraph/poetry.lock
index 634b9d8db..bdb2a4da6 100644
--- a/libs/langgraph/poetry.lock
+++ b/libs/langgraph/poetry.lock
@@ -1325,13 +1325,13 @@ files = [
[[package]]
name = "langchain-core"
-version = "0.3.15"
+version = "0.3.23"
description = "Building applications with LLMs through composability"
optional = false
python-versions = "<4.0,>=3.9"
files = [
- {file = "langchain_core-0.3.15-py3-none-any.whl", hash = "sha256:3d4ca6dbb8ed396a6ee061063832a2451b0ce8c345570f7b086ffa7288e4fa29"},
- {file = "langchain_core-0.3.15.tar.gz", hash = "sha256:b1a29787a4ffb7ec2103b4e97d435287201da7809b369740dd1e32f176325aba"},
+ {file = "langchain_core-0.3.23-py3-none-any.whl", hash = "sha256:550c0b996990830fa6515a71a1192a8a0343367999afc36d4ede14222941e420"},
+ {file = "langchain_core-0.3.23.tar.gz", hash = "sha256:f9e175e3b82063cc3b160c2ca2b155832e1c6f915312e1204828f97d4aabf6e1"},
]
[package.dependencies]
@@ -1382,7 +1382,7 @@ url = "../checkpoint-duckdb"
[[package]]
name = "langgraph-checkpoint-postgres"
-version = "2.0.7"
+version = "2.0.8"
description = "Library with a Postgres implementation of LangGraph checkpoint saver."
optional = false
python-versions = "^3.9.0,<4.0"
@@ -1418,7 +1418,7 @@ url = "../checkpoint-sqlite"
[[package]]
name = "langgraph-sdk"
-version = "0.1.42"
+version = "0.1.43"
description = "SDK for interacting with LangGraph API"
optional = false
python-versions = "^3.9.0,<4.0"
@@ -3413,4 +3413,4 @@ type = ["pytest-mypy"]
[metadata]
lock-version = "2.0"
python-versions = ">=3.9.0,<4.0"
-content-hash = "2df4d5d5e61917bdfff0ba430067a17662666eedee2858d841fa02e594cf69d0"
+content-hash = "936530a5f00f329aeff2e6e921fe64480be317fad2c0a59cd54ea9018d089304"
diff --git a/libs/langgraph/pyproject.toml b/libs/langgraph/pyproject.toml
index 925be91ff..a5fa31c74 100644
--- a/libs/langgraph/pyproject.toml
+++ b/libs/langgraph/pyproject.toml
@@ -1,6 +1,6 @@
[tool.poetry]
name = "langgraph"
-version = "0.2.57"
+version = "0.2.58"
description = "Building stateful, multi-actor applications with LLMs"
authors = []
license = "MIT"
@@ -9,7 +9,7 @@ repository = "https://www.github.com/langchain-ai/langgraph"
[tool.poetry.dependencies]
python = ">=3.9.0,<4.0"
-langchain-core = ">=0.2.43,<0.4.0,!=0.3.0,!=0.3.1,!=0.3.2,!=0.3.3,!=0.3.4,!=0.3.5,!=0.3.6,!=0.3.7,!=0.3.8,!=0.3.9,!=0.3.10,!=0.3.11,!=0.3.12,!=0.3.13,!=0.3.14"
+langchain-core = ">=0.2.43,<0.4.0,!=0.3.0,!=0.3.1,!=0.3.2,!=0.3.3,!=0.3.4,!=0.3.5,!=0.3.6,!=0.3.7,!=0.3.8,!=0.3.9,!=0.3.10,!=0.3.11,!=0.3.12,!=0.3.13,!=0.3.14,!=0.3.15,!=0.3.16,!=0.3.17,!=0.3.18,!=0.3.19,!=0.3.20,!=0.3.21,!=0.3.22"
langgraph-checkpoint = "^2.0.4"
langgraph-sdk = "^0.1.42"
diff --git a/libs/langgraph/tests/test_prebuilt.py b/libs/langgraph/tests/test_prebuilt.py
index 0997668b2..9c6541d9a 100644
--- a/libs/langgraph/tests/test_prebuilt.py
+++ b/libs/langgraph/tests/test_prebuilt.py
@@ -46,7 +46,7 @@ from langgraph.prebuilt import (
create_react_agent,
tools_condition,
)
-from langgraph.prebuilt.chat_agent_executor import _validate_chat_history
+from langgraph.prebuilt.chat_agent_executor import AgentState, _validate_chat_history
from langgraph.prebuilt.tool_node import (
TOOL_CALL_ERROR_TEMPLATE,
InjectedState,
@@ -56,7 +56,7 @@ from langgraph.prebuilt.tool_node import (
)
from langgraph.store.base import BaseStore
from langgraph.store.memory import InMemoryStore
-from langgraph.types import Interrupt
+from langgraph.types import Command, Interrupt, interrupt
from tests.conftest import (
ALL_CHECKPOINTERS_ASYNC,
ALL_CHECKPOINTERS_SYNC,
@@ -988,6 +988,645 @@ def test_tool_node_node_interrupt():
assert task.interrupts == (Interrupt(value="foo", when="during"),)
+@pytest.mark.skipif(
+ not IS_LANGCHAIN_CORE_030_OR_GREATER,
+ reason="Langchain core 0.3.0 or greater is required",
+)
+async def test_tool_node_command():
+ from langchain_core.tools.base import InjectedToolCallId
+
+ @dec_tool
+ def transfer_to_bob(tool_call_id: Annotated[str, InjectedToolCallId]):
+ """Transfer to Bob"""
+ return Command(
+ update={
+ "messages": [
+ ToolMessage(content="Transferred to Bob", tool_call_id=tool_call_id)
+ ]
+ },
+ goto="bob",
+ graph=Command.PARENT,
+ )
+
+ @dec_tool
+ async def async_transfer_to_bob(tool_call_id: Annotated[str, InjectedToolCallId]):
+ """Transfer to Bob"""
+ return Command(
+ update={
+ "messages": [
+ ToolMessage(content="Transferred to Bob", tool_call_id=tool_call_id)
+ ]
+ },
+ goto="bob",
+ graph=Command.PARENT,
+ )
+
+ class CustomToolSchema(BaseModel):
+ tool_call_id: Annotated[str, InjectedToolCallId]
+
+ class MyCustomTool(BaseTool):
+ def _run(*args: Any, **kwargs: Any):
+ return Command(
+ update={
+ "messages": [
+ ToolMessage(
+ content="Transferred to Bob",
+ tool_call_id=kwargs["tool_call_id"],
+ )
+ ]
+ },
+ goto="bob",
+ graph=Command.PARENT,
+ )
+
+ async def _arun(*args: Any, **kwargs: Any):
+ return Command(
+ update={
+ "messages": [
+ ToolMessage(
+ content="Transferred to Bob",
+ tool_call_id=kwargs["tool_call_id"],
+ )
+ ]
+ },
+ goto="bob",
+ graph=Command.PARENT,
+ )
+
+ custom_tool = MyCustomTool(
+ name="custom_transfer_to_bob",
+ description="Transfer to bob",
+ args_schema=CustomToolSchema,
+ )
+ async_custom_tool = MyCustomTool(
+ name="async_custom_transfer_to_bob",
+ description="Transfer to bob",
+ args_schema=CustomToolSchema,
+ )
+
+ # test mixing regular tools and tools returning commands
+ def add(a: int, b: int) -> int:
+ """Add two numbers"""
+ return a + b
+
+ result = ToolNode([add, transfer_to_bob]).invoke(
+ {
+ "messages": [
+ AIMessage(
+ "",
+ tool_calls=[
+ {"args": {"a": 1, "b": 2}, "id": "1", "name": "add"},
+ {"args": {}, "id": "2", "name": "transfer_to_bob"},
+ ],
+ )
+ ]
+ }
+ )
+
+ assert result == [
+ {
+ "messages": [
+ ToolMessage(
+ content="3",
+ tool_call_id="1",
+ name="add",
+ )
+ ]
+ },
+ Command(
+ update={
+ "messages": [
+ ToolMessage(
+ content="Transferred to Bob",
+ tool_call_id="2",
+ name="transfer_to_bob",
+ )
+ ]
+ },
+ goto="bob",
+ graph=Command.PARENT,
+ ),
+ ]
+
+ # test tools returning commands
+
+ # test sync tools
+ for tool in [transfer_to_bob, custom_tool]:
+ result = ToolNode([tool]).invoke(
+ {
+ "messages": [
+ AIMessage(
+ "", tool_calls=[{"args": {}, "id": "1", "name": tool.name}]
+ )
+ ]
+ }
+ )
+ assert result == [
+ Command(
+ update={
+ "messages": [
+ ToolMessage(
+ content="Transferred to Bob",
+ tool_call_id="1",
+ name=tool.name,
+ )
+ ]
+ },
+ goto="bob",
+ graph=Command.PARENT,
+ )
+ ]
+
+ # test async tools
+ for tool in [async_transfer_to_bob, async_custom_tool]:
+ result = await ToolNode([tool]).ainvoke(
+ {
+ "messages": [
+ AIMessage(
+ "", tool_calls=[{"args": {}, "id": "1", "name": tool.name}]
+ )
+ ]
+ }
+ )
+ assert result == [
+ Command(
+ update={
+ "messages": [
+ ToolMessage(
+ content="Transferred to Bob",
+ tool_call_id="1",
+ name=tool.name,
+ )
+ ]
+ },
+ goto="bob",
+ graph=Command.PARENT,
+ )
+ ]
+
+ # test multiple commands
+ result = ToolNode([transfer_to_bob, custom_tool]).invoke(
+ {
+ "messages": [
+ AIMessage(
+ "",
+ tool_calls=[
+ {"args": {}, "id": "1", "name": "transfer_to_bob"},
+ {"args": {}, "id": "2", "name": "custom_transfer_to_bob"},
+ ],
+ )
+ ]
+ }
+ )
+ assert result == [
+ Command(
+ update={
+ "messages": [
+ ToolMessage(
+ content="Transferred to Bob",
+ tool_call_id="1",
+ name="transfer_to_bob",
+ )
+ ]
+ },
+ goto="bob",
+ graph=Command.PARENT,
+ ),
+ Command(
+ update={
+ "messages": [
+ ToolMessage(
+ content="Transferred to Bob",
+ tool_call_id="2",
+ name="custom_transfer_to_bob",
+ )
+ ]
+ },
+ goto="bob",
+ graph=Command.PARENT,
+ ),
+ ]
+
+ # test validation (mismatch between input type and command.update type)
+ with pytest.raises(ValueError):
+
+ @dec_tool
+ def list_update_tool(tool_call_id: Annotated[str, InjectedToolCallId]):
+ """My tool"""
+ return Command(
+ update=[ToolMessage(content="foo", tool_call_id=tool_call_id)]
+ )
+
+ ToolNode([list_update_tool]).invoke(
+ {
+ "messages": [
+ AIMessage(
+ "",
+ tool_calls=[
+ {"args": {}, "id": "1", "name": "list_update_tool"}
+ ],
+ )
+ ]
+ }
+ )
+
+ # test validation (missing tool message in the update for current graph)
+ with pytest.raises(ValueError):
+
+ @dec_tool
+ def no_update_tool():
+ """My tool"""
+ return Command(update={"messages": []})
+
+ ToolNode([no_update_tool]).invoke(
+ {
+ "messages": [
+ AIMessage(
+ "",
+ tool_calls=[{"args": {}, "id": "1", "name": "no_update_tool"}],
+ )
+ ]
+ }
+ )
+
+ # test validation (missing tool message in the update for parent graph is OK)
+ @dec_tool
+ def node_update_parent_tool():
+ """No update"""
+ return Command(update={"messages": []}, graph=Command.PARENT)
+
+ assert ToolNode([node_update_parent_tool]).invoke(
+ {
+ "messages": [
+ AIMessage(
+ "",
+ tool_calls=[
+ {"args": {}, "id": "1", "name": "node_update_parent_tool"}
+ ],
+ )
+ ]
+ }
+ ) == [Command(update={"messages": []}, graph=Command.PARENT)]
+
+ # test validation (multiple tool messages)
+ with pytest.raises(ValueError):
+ for graph in (None, Command.PARENT):
+
+ @dec_tool
+ def multiple_tool_messages_tool():
+ """My tool"""
+ return Command(
+ update={
+ "messages": [
+ ToolMessage(content="foo", tool_call_id=""),
+ ToolMessage(content="bar", tool_call_id=""),
+ ]
+ },
+ graph=graph,
+ )
+
+ ToolNode([multiple_tool_messages_tool]).invoke(
+ {
+ "messages": [
+ AIMessage(
+ "",
+ tool_calls=[
+ {
+ "args": {},
+ "id": "1",
+ "name": "multiple_tool_messages_tool",
+ }
+ ],
+ )
+ ]
+ }
+ )
+
+
+@pytest.mark.skipif(
+ not IS_LANGCHAIN_CORE_030_OR_GREATER,
+ reason="Langchain core 0.3.0 or greater is required",
+)
+async def test_tool_node_command_list_input():
+ from langchain_core.tools.base import InjectedToolCallId
+
+ @dec_tool
+ def transfer_to_bob(tool_call_id: Annotated[str, InjectedToolCallId]):
+ """Transfer to Bob"""
+ return Command(
+ update=[
+ ToolMessage(content="Transferred to Bob", tool_call_id=tool_call_id)
+ ],
+ goto="bob",
+ graph=Command.PARENT,
+ )
+
+ @dec_tool
+ async def async_transfer_to_bob(tool_call_id: Annotated[str, InjectedToolCallId]):
+ """Transfer to Bob"""
+ return Command(
+ update=[
+ ToolMessage(content="Transferred to Bob", tool_call_id=tool_call_id)
+ ],
+ goto="bob",
+ graph=Command.PARENT,
+ )
+
+ class CustomToolSchema(BaseModel):
+ tool_call_id: Annotated[str, InjectedToolCallId]
+
+ class MyCustomTool(BaseTool):
+ def _run(*args: Any, **kwargs: Any):
+ return Command(
+ update=[
+ ToolMessage(
+ content="Transferred to Bob",
+ tool_call_id=kwargs["tool_call_id"],
+ )
+ ],
+ goto="bob",
+ graph=Command.PARENT,
+ )
+
+ async def _arun(*args: Any, **kwargs: Any):
+ return Command(
+ update=[
+ ToolMessage(
+ content="Transferred to Bob",
+ tool_call_id=kwargs["tool_call_id"],
+ )
+ ],
+ goto="bob",
+ graph=Command.PARENT,
+ )
+
+ custom_tool = MyCustomTool(
+ name="custom_transfer_to_bob",
+ description="Transfer to bob",
+ args_schema=CustomToolSchema,
+ )
+ async_custom_tool = MyCustomTool(
+ name="async_custom_transfer_to_bob",
+ description="Transfer to bob",
+ args_schema=CustomToolSchema,
+ )
+
+ # test mixing regular tools and tools returning commands
+ def add(a: int, b: int) -> int:
+ """Add two numbers"""
+ return a + b
+
+ result = ToolNode([add, transfer_to_bob]).invoke(
+ [
+ AIMessage(
+ "",
+ tool_calls=[
+ {"args": {"a": 1, "b": 2}, "id": "1", "name": "add"},
+ {"args": {}, "id": "2", "name": "transfer_to_bob"},
+ ],
+ )
+ ]
+ )
+
+ assert result == [
+ [
+ ToolMessage(
+ content="3",
+ tool_call_id="1",
+ name="add",
+ )
+ ],
+ Command(
+ update=[
+ ToolMessage(
+ content="Transferred to Bob",
+ tool_call_id="2",
+ name="transfer_to_bob",
+ )
+ ],
+ goto="bob",
+ graph=Command.PARENT,
+ ),
+ ]
+
+ # test tools returning commands
+
+ # test sync tools
+ for tool in [transfer_to_bob, custom_tool]:
+ result = ToolNode([tool]).invoke(
+ [AIMessage("", tool_calls=[{"args": {}, "id": "1", "name": tool.name}])]
+ )
+ assert result == [
+ Command(
+ update=[
+ ToolMessage(
+ content="Transferred to Bob",
+ tool_call_id="1",
+ name=tool.name,
+ )
+ ],
+ goto="bob",
+ graph=Command.PARENT,
+ )
+ ]
+
+ # test async tools
+ for tool in [async_transfer_to_bob, async_custom_tool]:
+ result = await ToolNode([tool]).ainvoke(
+ [AIMessage("", tool_calls=[{"args": {}, "id": "1", "name": tool.name}])]
+ )
+ assert result == [
+ Command(
+ update=[
+ ToolMessage(
+ content="Transferred to Bob",
+ tool_call_id="1",
+ name=tool.name,
+ )
+ ],
+ goto="bob",
+ graph=Command.PARENT,
+ )
+ ]
+
+ # test multiple commands
+ result = ToolNode([transfer_to_bob, custom_tool]).invoke(
+ [
+ AIMessage(
+ "",
+ tool_calls=[
+ {"args": {}, "id": "1", "name": "transfer_to_bob"},
+ {"args": {}, "id": "2", "name": "custom_transfer_to_bob"},
+ ],
+ )
+ ]
+ )
+ assert result == [
+ Command(
+ update=[
+ ToolMessage(
+ content="Transferred to Bob",
+ tool_call_id="1",
+ name="transfer_to_bob",
+ )
+ ],
+ goto="bob",
+ graph=Command.PARENT,
+ ),
+ Command(
+ update=[
+ ToolMessage(
+ content="Transferred to Bob",
+ tool_call_id="2",
+ name="custom_transfer_to_bob",
+ )
+ ],
+ goto="bob",
+ graph=Command.PARENT,
+ ),
+ ]
+
+ # test validation (mismatch between input type and command.update type)
+ with pytest.raises(ValueError):
+
+ @dec_tool
+ def list_update_tool(tool_call_id: Annotated[str, InjectedToolCallId]):
+ """My tool"""
+ return Command(
+ update={
+ "messages": [ToolMessage(content="foo", tool_call_id=tool_call_id)]
+ }
+ )
+
+ ToolNode([list_update_tool]).invoke(
+ [
+ AIMessage(
+ "",
+ tool_calls=[{"args": {}, "id": "1", "name": "list_update_tool"}],
+ )
+ ]
+ )
+
+ # test validation (missing tool message in the update for current graph)
+ with pytest.raises(ValueError):
+
+ @dec_tool
+ def no_update_tool():
+ """My tool"""
+ return Command(update=[])
+
+ ToolNode([no_update_tool]).invoke(
+ [
+ AIMessage(
+ "",
+ tool_calls=[{"args": {}, "id": "1", "name": "no_update_tool"}],
+ )
+ ]
+ )
+
+ # test validation (missing tool message in the update for parent graph is OK)
+ @dec_tool
+ def node_update_parent_tool():
+ """No update"""
+ return Command(update=[], graph=Command.PARENT)
+
+ assert ToolNode([node_update_parent_tool]).invoke(
+ [
+ AIMessage(
+ "",
+ tool_calls=[{"args": {}, "id": "1", "name": "node_update_parent_tool"}],
+ )
+ ]
+ ) == [Command(update=[], graph=Command.PARENT)]
+
+ # test validation (multiple tool messages)
+ with pytest.raises(ValueError):
+ for graph in (None, Command.PARENT):
+
+ @dec_tool
+ def multiple_tool_messages_tool():
+ """My tool"""
+ return Command(
+ update=[
+ ToolMessage(content="foo", tool_call_id=""),
+ ToolMessage(content="bar", tool_call_id=""),
+ ],
+ graph=graph,
+ )
+
+ ToolNode([multiple_tool_messages_tool]).invoke(
+ [
+ AIMessage(
+ "",
+ tool_calls=[
+ {
+ "args": {},
+ "id": "1",
+ "name": "multiple_tool_messages_tool",
+ }
+ ],
+ )
+ ]
+ )
+
+
+@pytest.mark.skipif(
+ not IS_LANGCHAIN_CORE_030_OR_GREATER,
+ reason="Langchain core 0.3.0 or greater is required",
+)
+def test_react_agent_update_state():
+ from langchain_core.tools.base import InjectedToolCallId
+
+ class State(AgentState):
+ user_name: str
+
+ @dec_tool
+ def get_user_name(tool_call_id: Annotated[str, InjectedToolCallId]):
+ """Retrieve user name"""
+ user_name = interrupt("Please provider user name:")
+ return Command(
+ update={
+ "user_name": user_name,
+ "messages": [
+ ToolMessage(
+ "Successfully retrieved user name", tool_call_id=tool_call_id
+ )
+ ],
+ }
+ )
+
+ def state_modifier(state: State):
+ user_name = state.get("user_name")
+ if user_name is None:
+ return state["messages"]
+
+ system_msg = f"User name is {user_name}"
+ return [{"role": "system", "content": system_msg}] + state["messages"]
+
+ checkpointer = MemorySaver()
+ tool_calls = [[{"args": {}, "id": "1", "name": "get_user_name"}]]
+ model = FakeToolCallingModel(tool_calls=tool_calls)
+ agent = create_react_agent(
+ model,
+ [get_user_name],
+ state_schema=State,
+ state_modifier=state_modifier,
+ checkpointer=checkpointer,
+ )
+ config = {"configurable": {"thread_id": "1"}}
+ # run until interrpupted
+ agent.invoke({"messages": [("user", "what's my name")]}, config)
+ # supply the value for the interrupt
+ response = agent.invoke(Command(resume="Archibald"), config)
+ # confirm that the state was updated
+ assert response["user_name"] == "Archibald"
+ assert len(response["messages"]) == 4
+ tool_message: ToolMessage = response["messages"][-2]
+ assert tool_message.content == "Successfully retrieved user name"
+ assert tool_message.tool_call_id == "1"
+ assert tool_message.name == "get_user_name"
+
+
def my_function(some_val: int, some_other_val: str) -> str:
return f"{some_val} - {some_other_val}"
diff --git a/libs/langgraph/tests/test_pregel.py b/libs/langgraph/tests/test_pregel.py
index 1cbadf099..ad48108a9 100644
--- a/libs/langgraph/tests/test_pregel.py
+++ b/libs/langgraph/tests/test_pregel.py
@@ -7602,7 +7602,7 @@ def test_root_graph(
content="result for query",
name="search_api",
tool_call_id="tool_call123",
- id="00000000-0000-4000-8000-000000000033",
+ id="00000000-0000-4000-8000-000000000037",
)
]
},
@@ -7625,7 +7625,7 @@ def test_root_graph(
content="result for another",
name="search_api",
tool_call_id="tool_call456",
- id="00000000-0000-4000-8000-000000000041",
+ id="00000000-0000-4000-8000-000000000045",
)
]
},
@@ -8235,7 +8235,7 @@ def test_root_graph(
"__root__": [
HumanMessage(
content="what is weather in sf",
- id="00000000-0000-4000-8000-000000000070",
+ id="00000000-0000-4000-8000-000000000078",
),
AIMessage(
content="",
@@ -8255,7 +8255,7 @@ def test_root_graph(
),
AIMessage(content="answer", id="ai2"),
AIMessage(
- content="an extra message", id="00000000-0000-4000-8000-000000000092"
+ content="an extra message", id="00000000-0000-4000-8000-000000000100"
),
HumanMessage(content="what is weather in la"),
],
@@ -12901,7 +12901,7 @@ def test_send_to_nested_graphs(
metadata={
"step": 1,
"source": "loop",
- "writes": {"edit": None},
+ "writes": None,
"parents": {"": AnyStr()},
"thread_id": "1",
"checkpoint_ns": AnyStr("generate_joke:"),
@@ -12946,7 +12946,7 @@ def test_send_to_nested_graphs(
metadata={
"step": 1,
"source": "loop",
- "writes": {"edit": None},
+ "writes": None,
"parents": {"": AnyStr()},
"thread_id": "1",
"checkpoint_ns": AnyStr("generate_joke:"),
@@ -14904,3 +14904,141 @@ def test_dict_mixed_return() -> None:
graph = graph.compile()
assert graph.invoke({"foo": ""}) == {"foo": "ab"}
+
+
+@pytest.mark.parametrize("checkpointer_name", ALL_CHECKPOINTERS_SYNC)
+def test_command_with_static_breakpoints(
+ request: pytest.FixtureRequest, checkpointer_name: str
+) -> None:
+ """Test that we can use Command to resume and update with static breakpoints."""
+
+ checkpointer = request.getfixturevalue(f"checkpointer_{checkpointer_name}")
+
+ class State(TypedDict):
+ """The graph state."""
+
+ foo: str
+
+ def node1(state: State):
+ return {
+ "foo": state["foo"] + "|node-1",
+ }
+
+ def node2(state: State):
+ return {
+ "foo": state["foo"] + "|node-2",
+ }
+
+ builder = StateGraph(State)
+ builder.add_node("node1", node1)
+ builder.add_node("node2", node2)
+ builder.add_edge(START, "node1")
+ builder.add_edge("node1", "node2")
+
+ graph = builder.compile(checkpointer=checkpointer, interrupt_before=["node1"])
+ config = {"configurable": {"thread_id": str(uuid.uuid4())}}
+
+ # Start the graph and interrupt at the first node
+ graph.invoke({"foo": "abc"}, config)
+ result = graph.invoke(Command(resume="node1"), config)
+ assert result == {"foo": "abc|node-1|node-2"}
+
+
+@pytest.mark.parametrize("checkpointer_name", ALL_CHECKPOINTERS_SYNC)
+def test_multistep_plan(request: pytest.FixtureRequest, checkpointer_name: str):
+ from langchain_core.messages import AnyMessage
+
+ checkpointer = request.getfixturevalue(f"checkpointer_{checkpointer_name}")
+
+ class State(TypedDict, total=False):
+ plan: list[Union[str, list[str]]]
+ messages: Annotated[list[AnyMessage], add_messages]
+
+ def planner(state: State):
+ if state.get("plan") is None:
+ # create plan somehow
+ plan = ["step1", ["step2", "step3"], "step4"]
+ # pick the first step to execute next
+ first_step, *plan = plan
+ # put the rest of plan in state
+ return Command(goto=first_step, update={"plan": plan})
+ elif state["plan"]:
+ # go to the next step of the plan
+ next_step, *next_plan = state["plan"]
+ return Command(goto=next_step, update={"plan": next_plan})
+ else:
+ # the end of the plan
+ pass
+
+ def step1(state: State):
+ return Command(goto="planner", update={"messages": [("human", "step1")]})
+
+ def step2(state: State):
+ return Command(goto="planner", update={"messages": [("human", "step2")]})
+
+ def step3(state: State):
+ return Command(goto="planner", update={"messages": [("human", "step3")]})
+
+ def step4(state: State):
+ return Command(goto="planner", update={"messages": [("human", "step4")]})
+
+ builder = StateGraph(State)
+ builder.add_node(planner)
+ builder.add_node(step1)
+ builder.add_node(step2)
+ builder.add_node(step3)
+ builder.add_node(step4)
+ builder.add_edge(START, "planner")
+ graph = builder.compile(checkpointer=checkpointer)
+
+ config = {"configurable": {"thread_id": "1"}}
+
+ assert graph.invoke({"messages": [("human", "start")]}, config) == {
+ "messages": [
+ _AnyIdHumanMessage(content="start"),
+ _AnyIdHumanMessage(content="step1"),
+ _AnyIdHumanMessage(content="step2"),
+ _AnyIdHumanMessage(content="step3"),
+ _AnyIdHumanMessage(content="step4"),
+ ],
+ "plan": [],
+ }
+
+
+@pytest.mark.parametrize("checkpointer_name", ALL_CHECKPOINTERS_SYNC)
+def test_command_goto_with_static_breakpoints(
+ request: pytest.FixtureRequest, checkpointer_name: str
+) -> None:
+ """Use Command goto with static breakpoints."""
+
+ checkpointer = request.getfixturevalue(f"checkpointer_{checkpointer_name}")
+
+ class State(TypedDict):
+ """The graph state."""
+
+ foo: Annotated[str, operator.add]
+
+ def node1(state: State):
+ return {
+ "foo": "|node-1",
+ }
+
+ def node2(state: State):
+ return {
+ "foo": "|node-2",
+ }
+
+ builder = StateGraph(State)
+ builder.add_node("node1", node1)
+ builder.add_node("node2", node2)
+ builder.add_edge(START, "node1")
+ builder.add_edge("node1", "node2")
+
+ graph = builder.compile(checkpointer=checkpointer, interrupt_before=["node1"])
+
+ config = {"configurable": {"thread_id": str(uuid.uuid4())}}
+
+ # Start the graph and interrupt at the first node
+ graph.invoke({"foo": "abc"}, config)
+ result = graph.invoke(Command(goto=["node2"]), config)
+ assert result == {"foo": "abc|node-1|node-2|node-2"}
diff --git a/libs/langgraph/tests/test_pregel_async.py b/libs/langgraph/tests/test_pregel_async.py
index f43e76d31..cde54ae7c 100644
--- a/libs/langgraph/tests/test_pregel_async.py
+++ b/libs/langgraph/tests/test_pregel_async.py
@@ -12621,9 +12621,19 @@ async def test_store_injected_async(checkpointer_name: str, store_name: str) ->
)
return {"count": 1}
+ def other_node(inputs: State, config: RunnableConfig, store: BaseStore):
+ assert isinstance(store, BaseStore)
+ store.put(("not", "interesting"), "key", {"val": "val"})
+ item = store.get(("not", "interesting"), "key")
+ assert item is not None
+ assert item.value == {"val": "val"}
+ return {"count": 0}
+
builder = StateGraph(State)
builder.add_node("node", Node())
+ builder.add_node("other_node", other_node)
builder.add_edge("__start__", "node")
+ builder.add_edge("node", "other_node")
N = 500
M = 1
@@ -13189,3 +13199,135 @@ async def test_interrupt_loop(checkpointer_name: str):
] == [
{"node": {"age": 19}},
]
+
+
+@pytest.mark.parametrize("checkpointer_name", ALL_CHECKPOINTERS_ASYNC)
+async def test_command_with_static_breakpoints(checkpointer_name: str) -> None:
+ """Test that we can use Command to resume and update with static breakpoints."""
+
+ class State(TypedDict):
+ """The graph state."""
+
+ foo: str
+
+ def node1(state: State):
+ return {
+ "foo": state["foo"] + "|node-1",
+ }
+
+ def node2(state: State):
+ return {
+ "foo": state["foo"] + "|node-2",
+ }
+
+ builder = StateGraph(State)
+ builder.add_node("node1", node1)
+ builder.add_node("node2", node2)
+ builder.add_edge(START, "node1")
+ builder.add_edge("node1", "node2")
+
+ async with awith_checkpointer(checkpointer_name) as checkpointer:
+ graph = builder.compile(checkpointer=checkpointer, interrupt_before=["node1"])
+ config = {"configurable": {"thread_id": str(uuid.uuid4())}}
+
+ # Start the graph and interrupt at the first node
+ await graph.ainvoke({"foo": "abc"}, config)
+ result = await graph.ainvoke(Command(update={"foo": "def"}), config)
+ assert result == {"foo": "def|node-1|node-2"}
+
+
+@pytest.mark.parametrize("checkpointer_name", ALL_CHECKPOINTERS_ASYNC)
+async def test_multistep_plan(checkpointer_name: str):
+ from langchain_core.messages import AnyMessage
+
+ class State(TypedDict, total=False):
+ plan: list[Union[str, list[str]]]
+ messages: Annotated[list[AnyMessage], add_messages]
+
+ def planner(state: State):
+ if state.get("plan") is None:
+ # create plan somehow
+ plan = ["step1", ["step2", "step3"], "step4"]
+ # pick the first step to execute next
+ first_step, *plan = plan
+ # put the rest of plan in state
+ return Command(goto=first_step, update={"plan": plan})
+ elif state["plan"]:
+ # go to the next step of the plan
+ next_step, *next_plan = state["plan"]
+ return Command(goto=next_step, update={"plan": next_plan})
+ else:
+ # the end of the plan
+ pass
+
+ def step1(state: State):
+ return Command(goto="planner", update={"messages": [("human", "step1")]})
+
+ def step2(state: State):
+ return Command(goto="planner", update={"messages": [("human", "step2")]})
+
+ def step3(state: State):
+ return Command(goto="planner", update={"messages": [("human", "step3")]})
+
+ def step4(state: State):
+ return Command(goto="planner", update={"messages": [("human", "step4")]})
+
+ builder = StateGraph(State)
+ builder.add_node(planner)
+ builder.add_node(step1)
+ builder.add_node(step2)
+ builder.add_node(step3)
+ builder.add_node(step4)
+ builder.add_edge(START, "planner")
+
+ async with awith_checkpointer(checkpointer_name) as checkpointer:
+ graph = builder.compile(checkpointer=checkpointer)
+
+ config = {"configurable": {"thread_id": "1"}}
+
+ assert await graph.ainvoke({"messages": [("human", "start")]}, config) == {
+ "messages": [
+ _AnyIdHumanMessage(content="start"),
+ _AnyIdHumanMessage(content="step1"),
+ _AnyIdHumanMessage(content="step2"),
+ _AnyIdHumanMessage(content="step3"),
+ _AnyIdHumanMessage(content="step4"),
+ ],
+ "plan": [],
+ }
+
+
+@pytest.mark.parametrize("checkpointer_name", ALL_CHECKPOINTERS_ASYNC)
+async def test_command_goto_with_static_breakpoints(checkpointer_name: str) -> None:
+ """Use Command goto with static breakpoints."""
+
+ class State(TypedDict):
+ """The graph state."""
+
+ foo: Annotated[str, operator.add]
+
+ def node1(state: State):
+ return {
+ "foo": "|node-1",
+ }
+
+ def node2(state: State):
+ return {
+ "foo": "|node-2",
+ }
+
+ builder = StateGraph(State)
+ builder.add_node("node1", node1)
+ builder.add_node("node2", node2)
+ builder.add_edge(START, "node1")
+ builder.add_edge("node1", "node2")
+
+ async with awith_checkpointer(checkpointer_name) as checkpointer:
+ graph = builder.compile(checkpointer=checkpointer, interrupt_before=["node1"])
+
+ config = {"configurable": {"thread_id": str(uuid.uuid4())}}
+
+ # Start the graph and interrupt at the first node
+ await graph.ainvoke({"foo": "abc"}, config)
+ result = await graph.ainvoke(Command(goto=["node2"]), config)
+ assert result == {"foo": "abc|node-1|node-2|node-2"}
diff --git a/libs/langgraph/tests/test_utils.py b/libs/langgraph/tests/test_utils.py
index e8ea94fff..616f1a78f 100644
--- a/libs/langgraph/tests/test_utils.py
+++ b/libs/langgraph/tests/test_utils.py
@@ -21,7 +21,11 @@ from typing_extensions import Annotated, NotRequired, Required
from langgraph.graph import END, StateGraph
from langgraph.graph.graph import CompiledGraph
-from langgraph.utils.fields import _is_optional_type, get_field_default
+from langgraph.utils.fields import (
+ _is_optional_type,
+ get_enhanced_type_hints,
+ get_field_default,
+)
from langgraph.utils.runnable import is_async_callable, is_async_generator
pytestmark = pytest.mark.anyio
@@ -227,3 +231,57 @@ def test_is_required():
assert get_field_default("val_12", gcannos["val_12"], MyGrandChildDict) is None
assert get_field_default("val_9", gcannos["val_9"], MyGrandChildDict) is None
assert get_field_default("val_13", gcannos["val_13"], MyGrandChildDict) == ...
+
+
+def test_enhanced_type_hints() -> None:
+ from dataclasses import dataclass
+ from typing import Annotated
+
+ from pydantic import BaseModel, Field
+
+ class MyTypedDict(TypedDict):
+ val_1: str
+ val_2: int = 42
+ val_3: str = "default"
+
+ hints = list(get_enhanced_type_hints(MyTypedDict))
+ assert len(hints) == 3
+ assert hints[0] == ("val_1", str, None, None)
+ assert hints[1] == ("val_2", int, 42, None)
+ assert hints[2] == ("val_3", str, "default", None)
+
+ @dataclass
+ class MyDataclass:
+ val_1: str
+ val_2: int = 42
+ val_3: str = "default"
+
+ hints = list(get_enhanced_type_hints(MyDataclass))
+ assert len(hints) == 3
+ assert hints[0] == ("val_1", str, None, None)
+ assert hints[1] == ("val_2", int, 42, None)
+ assert hints[2] == ("val_3", str, "default", None)
+
+ class MyPydanticModel(BaseModel):
+ val_1: str
+ val_2: int = 42
+ val_3: str = Field(default="default", description="A description")
+
+ hints = list(get_enhanced_type_hints(MyPydanticModel))
+ assert len(hints) == 3
+ assert hints[0] == ("val_1", str, None, None)
+ assert hints[1] == ("val_2", int, 42, None)
+ assert hints[2] == ("val_3", str, "default", "A description")
+
+ class MyPydanticModelWithAnnotated(BaseModel):
+ val_1: Annotated[str, Field(description="A description")]
+ val_2: Annotated[int, Field(default=42)]
+ val_3: Annotated[
+ str, Field(default="default", description="Another description")
+ ]
+
+ hints = list(get_enhanced_type_hints(MyPydanticModelWithAnnotated))
+ assert len(hints) == 3
+ assert hints[0] == ("val_1", str, None, "A description")
+ assert hints[1] == ("val_2", int, 42, None)
+ assert hints[2] == ("val_3", str, "default", "Another description")
diff --git a/libs/sdk-js/package.json b/libs/sdk-js/package.json
index 02628e6dc..8e3e061b2 100644
--- a/libs/sdk-js/package.json
+++ b/libs/sdk-js/package.json
@@ -1,6 +1,6 @@
{
"name": "@langchain/langgraph-sdk",
- "version": "0.0.31",
+ "version": "0.0.32",
"description": "Client library for interacting with the LangGraph API",
"type": "module",
"packageManager": "yarn@1.22.19",
diff --git a/poetry.lock b/poetry.lock
index e0a15a09c..e2317d365 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -2933,13 +2933,13 @@ tenacity = ">=8.1.0,<8.4.0 || >8.4.0,<9.0.0"
[[package]]
name = "langchain-core"
-version = "0.3.21"
+version = "0.3.23"
description = "Building applications with LLMs through composability"
optional = false
python-versions = "<4.0,>=3.9"
files = [
- {file = "langchain_core-0.3.21-py3-none-any.whl", hash = "sha256:7e723dff80946a1198976c6876fea8326dc82566ef9bcb5f8d9188f738733665"},
- {file = "langchain_core-0.3.21.tar.gz", hash = "sha256:561b52b258ffa50a9fb11d7a1940ebfd915654d1ec95b35e81dfd5ee84143411"},
+ {file = "langchain_core-0.3.23-py3-none-any.whl", hash = "sha256:550c0b996990830fa6515a71a1192a8a0343367999afc36d4ede14222941e420"},
+ {file = "langchain_core-0.3.23.tar.gz", hash = "sha256:f9e175e3b82063cc3b160c2ca2b155832e1c6f915312e1204828f97d4aabf6e1"},
]
[package.dependencies]
@@ -3035,7 +3035,7 @@ langchain-core = ">=0.3.0,<0.4.0"
[[package]]
name = "langgraph"
-version = "0.2.54"
+version = "0.2.57"
description = "Building stateful, multi-actor applications with LLMs"
optional = false
python-versions = ">=3.9.0,<4.0"
@@ -3043,7 +3043,7 @@ files = []
develop = true
[package.dependencies]
-langchain-core = ">=0.2.43,<0.4.0,!=0.3.0,!=0.3.1,!=0.3.2,!=0.3.3,!=0.3.4,!=0.3.5,!=0.3.6,!=0.3.7,!=0.3.8,!=0.3.9,!=0.3.10,!=0.3.11,!=0.3.12,!=0.3.13,!=0.3.14"
+langchain-core = ">=0.2.43,<0.4.0,!=0.3.0,!=0.3.1,!=0.3.2,!=0.3.3,!=0.3.4,!=0.3.5,!=0.3.6,!=0.3.7,!=0.3.8,!=0.3.9,!=0.3.10,!=0.3.11,!=0.3.12,!=0.3.13,!=0.3.14,!=0.3.15,!=0.3.16,!=0.3.17,!=0.3.18,!=0.3.19,!=0.3.20,!=0.3.21,!=0.3.22"
langgraph-checkpoint = "^2.0.4"
langgraph-sdk = "^0.1.42"
@@ -3070,7 +3070,7 @@ url = "libs/checkpoint"
[[package]]
name = "langgraph-checkpoint-postgres"
-version = "2.0.7"
+version = "2.0.8"
description = "Library with a Postgres implementation of LangGraph checkpoint saver."
optional = false
python-versions = "^3.9.0,<4.0"
@@ -3106,7 +3106,7 @@ url = "libs/checkpoint-sqlite"
[[package]]
name = "langgraph-sdk"
-version = "0.1.42"
+version = "0.1.43"
description = "SDK for interacting with LangGraph API"
optional = false
python-versions = "^3.9.0,<4.0"
@@ -3585,6 +3585,7 @@ optional = false
python-versions = ">=3.6"
files = [
{file = "mkdocs-redirects-1.2.1.tar.gz", hash = "sha256:9420066d70e2a6bb357adf86e67023dcdca1857f97f07c7fe450f8f1fb42f861"},
+ {file = "mkdocs_redirects-1.2.1-py3-none-any.whl", hash = "sha256:497089f9e0219e7389304cffefccdfa1cac5ff9509f2cb706f4c9b221726dffb"},
]
[package.dependencies]
@@ -5096,7 +5097,6 @@ description = "Pure-Python implementation of ASN.1 types and DER/BER/CER codecs
optional = false
python-versions = ">=3.8"
files = [
- {file = "pyasn1-0.6.1-py3-none-any.whl", hash = "sha256:0d632f46f2ba09143da3a8afe9e33fb6f92fa2320ab7e886e2d0f7672af84629"},
{file = "pyasn1-0.6.1.tar.gz", hash = "sha256:6f580d2bdd84365380830acf45550f2511469f673cb4a5ae3857a3170128b034"},
]
@@ -5107,7 +5107,6 @@ description = "A collection of ASN.1-based protocols modules"
optional = false
python-versions = ">=3.8"
files = [
- {file = "pyasn1_modules-0.4.1-py3-none-any.whl", hash = "sha256:49bfa96b45a292b711e986f222502c1c9a5e1f4e568fc30e2574a6c7d07838fd"},
{file = "pyasn1_modules-0.4.1.tar.gz", hash = "sha256:c28e2dbf9c06ad61c71a075c7e0f9fd0f1b0bb2d2ad4377f240d33ac2ab60a7c"},
]
@@ -6167,11 +6166,6 @@ files = [
{file = "scikit_learn-1.5.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f60021ec1574e56632be2a36b946f8143bf4e5e6af4a06d85281adc22938e0dd"},
{file = "scikit_learn-1.5.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:394397841449853c2290a32050382edaec3da89e35b3e03d6cc966aebc6a8ae6"},
{file = "scikit_learn-1.5.2-cp312-cp312-win_amd64.whl", hash = "sha256:57cc1786cfd6bd118220a92ede80270132aa353647684efa385a74244a41e3b1"},
- {file = "scikit_learn-1.5.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e9a702e2de732bbb20d3bad29ebd77fc05a6b427dc49964300340e4c9328b3f5"},
- {file = "scikit_learn-1.5.2-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:b0768ad641981f5d3a198430a1d31c3e044ed2e8a6f22166b4d546a5116d7908"},
- {file = "scikit_learn-1.5.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:178ddd0a5cb0044464fc1bfc4cca5b1833bfc7bb022d70b05db8530da4bb3dd3"},
- {file = "scikit_learn-1.5.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f7284ade780084d94505632241bf78c44ab3b6f1e8ccab3d2af58e0e950f9c12"},
- {file = "scikit_learn-1.5.2-cp313-cp313-win_amd64.whl", hash = "sha256:b7b0f9a0b1040830d38c39b91b3a44e1b643f4b36e36567b80b7c6bd2202a27f"},
{file = "scikit_learn-1.5.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:757c7d514ddb00ae249832fe87100d9c73c6ea91423802872d9e74970a0e40b9"},
{file = "scikit_learn-1.5.2-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:52788f48b5d8bca5c0736c175fa6bdaab2ef00a8f536cda698db61bd89c551c1"},
{file = "scikit_learn-1.5.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:643964678f4b5fbdc95cbf8aec638acc7aa70f5f79ee2cdad1eec3df4ba6ead8"},
@@ -6962,6 +6956,7 @@ description = "Automatically mock your HTTP interactions to simplify and speed u
optional = false
python-versions = ">=3.8"
files = [
+ {file = "vcrpy-6.0.1-py2.py3-none-any.whl", hash = "sha256:621c3fb2d6bd8aa9f87532c688e4575bcbbde0c0afeb5ebdb7e14cac409edfdd"},
{file = "vcrpy-6.0.1.tar.gz", hash = "sha256:9e023fee7f892baa0bbda2f7da7c8ac51165c1c6e38ff8688683a12a4bde9278"},
]