WEBDIENSTE/langgraph
1
0
Fork 0
mirror of https://github.com/langchain-ai/langgraph.git synced 2026-08-22 07:32:25 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/main' into wfh/llm_compiler

Browse Source
This commit is contained in:
William Fu-Hinthorn
2024-02-09 16:07:01 -08:00
parent c26a8675c3 dfca91c775
commit 13fb3dfa8b
6 changed files with 1031 additions and 12 deletions
Download Patch File Download Diff File Expand all files Collapse all files
README.md
+8 -3
View File
@@ -135,7 +135,7 @@ The path that is taken is not known until that node is run (the LLM decides).
1. Conditional Edge: after the agent is called, we should either:
a. If the agent said to take an action, then the function to invoke tools should be called
b. If the agent said that it was finished, then it should finish
2. Normal Edge: after the tools are invoked, it should always go back to the agent to decide what to do next
@@ -469,7 +469,7 @@ It can often be tough to evaluation chat bots in multi-turn situations. One way
### Async
If you are running LangGraph in async workflows, you may want to create the nodes to be async by default.
In order for a walkthrough on how to do that, see [this documentation](https://github.com/langchain-ai/langgraph/blob/main/examples/async.ipynb)
For a walkthrough on how to do that, see [this documentation](https://github.com/langchain-ai/langgraph/blob/main/examples/async.ipynb)
### Streaming Tokens
@@ -479,7 +479,12 @@ For a guide on how to do this, see [this documentation](https://github.com/langc
### Persistence
LangGraph comes with built-in persistence, allowing you to save the state of the graph at point and resume from there.
In order for a walkthrough on how to do that, see [this documentation](https://github.com/langchain-ai/langgraph/blob/main/examples/persistence.ipynb)
For a walkthrough on how to do that, see [this documentation](https://github.com/langchain-ai/langgraph/blob/main/examples/persistence.ipynb)
### Human-in-the-loop
LangGraph comes with built-in support for human-in-the-loop workflows. This is useful when you want to have a human review the current state before proceeding to a particular node.
For a walkthrough on how to do that, see [this documentation](https://github.com/langchain-ai/langgraph/blob/main/examples/human-in-the-loop.ipynb)
## Documentation
examples/human-in-the-loop.ipynb
+501
View File
@@ -0,0 +1,501 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "51466c8d-8ce4-4b3d-be4e-18fdbeda5f53",
"metadata": {},
"source": [
"# Human-in-the-loop\n",
"\n",
"When creating LangGraph agents, it is often nice to add a human in the loop component.\n",
"This can be helpful when giving them access to tools.\n",
"Often in these situations you may want to manually approve an action before taking.\n",
"\n",
"This can be in several ways, but the primary supported way is to add an \"interupt\" before a node is executed.\n",
"This interupts execution at that node.\n",
"You can then resume from that spot to continue."
]
},
{
"cell_type": "markdown",
"id": "7cbd446a-808f-4394-be92-d45ab818953c",
"metadata": {},
"source": [
"## Setup\n",
"\n",
"First we need to install the packages required"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "af4ce0ba-7596-4e5f-8bf8-0b0bd6e62833",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.3.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.0\u001b[0m\n",
"\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n"
]
}
],
"source": [
"!pip install --quiet -U langchain langchain_openai tavily-python"
]
},
{
"cell_type": "markdown",
"id": "0abe11f4-62ed-4dc4-8875-3db21e260d1d",
"metadata": {},
"source": [
"Next, we need to set API keys for OpenAI (the LLM we will use) and Tavily (the search tool we will use)"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "c903a1cf-2977-4e2d-ad7d-8b3946821d89",
"metadata": {},
"outputs": [
{
"name": "stdin",
"output_type": "stream",
"text": [
"OpenAI API Key: ········\n",
"Tavily API Key: ········\n"
]
}
],
"source": [
"import os\n",
"import getpass\n",
"\n",
"os.environ[\"OPENAI_API_KEY\"] = getpass.getpass(\"OpenAI API Key:\")\n",
"os.environ[\"TAVILY_API_KEY\"] = getpass.getpass(\"Tavily API Key:\")"
]
},
{
"cell_type": "markdown",
"id": "f0ed46a8-effe-4596-b0e1-a6a29ee16f5c",
"metadata": {},
"source": [
"Optionally, we can set API key for [LangSmith tracing](https://smith.langchain.com/), which will give us best-in-class observability."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "95e25aec-7c9f-4a63-b143-225d0e9a79c3",
"metadata": {},
"outputs": [],
"source": [
"os.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\n",
"os.environ[\"LANGCHAIN_API_KEY\"] = getpass.getpass(\"LangSmith API Key:\")"
]
},
{
"cell_type": "markdown",
"id": "21ac643b-cb06-4724-a80c-2862ba4773f1",
"metadata": {},
"source": [
"## Set up the tools\n",
"\n",
"We will first define the tools we want to use.\n",
"For this simple example, we will use a built-in search tool via Tavily.\n",
"However, it is really easy to create your own tools - see documentation [here](https://python.langchain.com/docs/modules/agents/tools/custom_tools) on how to do that.\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "d7ef57dd-5d6e-4ad3-9377-a92201c1310e",
"metadata": {},
"outputs": [],
"source": [
"from langchain_community.tools.tavily_search import TavilySearchResults\n",
"\n",
"tools = [TavilySearchResults(max_results=1)]"
]
},
{
"cell_type": "markdown",
"id": "01885785-b71a-44d1-b1d6-7b5b14d53b58",
"metadata": {},
"source": [
"We can now wrap these tools in a simple ToolExecutor.\n",
"This is a real simple class that takes in a ToolInvocation and calls that tool, returning the output.\n",
"A ToolInvocation is any class with `tool` and `tool_input` attribute.\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "5cf3331e-ccb3-41c8-aeb9-a840a94d41e7",
"metadata": {},
"outputs": [],
"source": [
"from langgraph.prebuilt import ToolExecutor\n",
"\n",
"tool_executor = ToolExecutor(tools)"
]
},
{
"cell_type": "markdown",
"id": "5497ed70-fce3-47f1-9cad-46f912bad6a5",
"metadata": {},
"source": [
"## Set up the model\n",
"\n",
"Now we need to load the chat model we want to use.\n",
"Importantly, this should satisfy two criteria:\n",
"\n",
"1. It should work with messages. We will represent all agent state in the form of messages, so it needs to be able to work well with them.\n",
"2. It should work with OpenAI function calling. This means it should either be an OpenAI model or a model that exposes a similar interface.\n",
"\n",
"Note: these model requirements are not requirements for using LangGraph - they are just requirements for this one example."
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "892b54b9-75f0-4804-9ed0-88b5e5532989",
"metadata": {},
"outputs": [],
"source": [
"from langchain_openai import ChatOpenAI\n",
"\n",
"# We will set streaming=True so that we can stream tokens\n",
"# See the streaming section for more information on this.\n",
"model = ChatOpenAI(temperature=0, streaming=True)"
]
},
{
"cell_type": "markdown",
"id": "a77995c0-bae2-4cee-a036-8688a90f05b9",
"metadata": {},
"source": [
"\n",
"After we've done this, we should make sure the model knows that it has these tools available to call.\n",
"We can do this by converting the LangChain tools into the format for OpenAI function calling, and then bind them to the model class.\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "cd3cbae5-d92c-4559-a4aa-44721b80d107",
"metadata": {},
"outputs": [],
"source": [
"from langchain_core.utils.function_calling import convert_to_openai_function\n",
"\n",
"functions = [convert_to_openai_function(t) for t in tools]\n",
"model = model.bind_functions(functions)"
]
},
{
"cell_type": "markdown",
"id": "e03c5094-9297-4d19-a04e-3eedc75cefb4",
"metadata": {},
"source": [
"## Define the nodes\n",
"\n",
"We now need to define a few different nodes in our graph.\n",
"In `langgraph`, a node can be either a function or a [runnable](https://python.langchain.com/docs/expression_language/).\n",
"There are two main nodes we need for this:\n",
"\n",
"1. The agent: responsible for deciding what (if any) actions to take.\n",
"2. A function to invoke tools: if the agent decides to take an action, this node will then execute that action.\n",
"\n",
"We will also need to define some edges.\n",
"Some of these edges may be conditional.\n",
"The reason they are conditional is that based on the output of a node, one of several paths may be taken.\n",
"The path that is taken is not known until that node is run (the LLM decides).\n",
"\n",
"1. Conditional Edge: after the agent is called, we should either:\n",
" a. If the agent said to take an action, then the function to invoke tools should be called\n",
" b. If the agent said that it was finished, then it should finish\n",
"2. Normal Edge: after the tools are invoked, it should always go back to the agent to decide what to do next\n",
"\n",
"Let's define the nodes, as well as a function to decide how what conditional edge to take."
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "3b541bb9-900c-40d0-964d-7b5dfee30667",
"metadata": {},
"outputs": [],
"source": [
"from langgraph.prebuilt import ToolInvocation\n",
"import json\n",
"from langchain_core.messages import FunctionMessage\n",
"\n",
"# Define the function that determines whether to continue or not\n",
"def should_continue(messages):\n",
" last_message = messages[-1]\n",
" # If there is no function call, then we finish\n",
" if \"function_call\" not in last_message.additional_kwargs:\n",
" return \"end\"\n",
" # Otherwise if there is, we continue\n",
" else:\n",
" return \"continue\"\n",
"\n",
"# Define the function that calls the model\n",
"def call_model(messages):\n",
" response = model.invoke(messages)\n",
" # We return a list, because this will get added to the existing list\n",
" return response\n",
"\n",
"# Define the function to execute tools\n",
"def call_tool(messages):\n",
" # Based on the continue condition\n",
" # we know the last message involves a function call\n",
" last_message = messages[-1]\n",
" # We construct an ToolInvocation from the function_call\n",
" action = ToolInvocation(\n",
" tool=last_message.additional_kwargs[\"function_call\"][\"name\"],\n",
" tool_input=json.loads(last_message.additional_kwargs[\"function_call\"][\"arguments\"]),\n",
" )\n",
" # We call the tool_executor and get back a response\n",
" response = tool_executor.invoke(action)\n",
" # We use the response to create a FunctionMessage\n",
" function_message = FunctionMessage(content=str(response), name=action.tool)\n",
" # We return a list, because this will get added to the existing list\n",
" return function_message"
]
},
{
"cell_type": "markdown",
"id": "ffd6e892-946c-4899-8cc0-7c9291c1f73b",
"metadata": {},
"source": [
"## Define the graph\n",
"\n",
"We can now put it all together and define the graph!"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "812b4e70-4956-4415-8880-db48b3dcbad2",
"metadata": {},
"outputs": [],
"source": [
"from langgraph.graph import MessageGraph, END\n",
"# Define a new graph\n",
"workflow = MessageGraph()\n",
"\n",
"# Define the two nodes we will cycle between\n",
"workflow.add_node(\"agent\", call_model)\n",
"workflow.add_node(\"action\", call_tool)\n",
"\n",
"# Set the entrypoint as `agent`\n",
"# This means that this node is the first one called\n",
"workflow.set_entry_point(\"agent\")\n",
"\n",
"# We now add a conditional edge\n",
"workflow.add_conditional_edges(\n",
" # First, we define the start node. We use `agent`.\n",
" # This means these are the edges taken after the `agent` node is called.\n",
" \"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",
" # Otherwise we finish.\n",
" \"end\": END\n",
" }\n",
")\n",
"\n",
"# We now add a normal edge from `tools` to `agent`.\n",
"# This means that after `tools` is called, `agent` node is called next.\n",
"workflow.add_edge('action', 'agent')"
]
},
{
"cell_type": "markdown",
"id": "bc9c8536-f90b-44fa-958d-5df016c66d8f",
"metadata": {},
"source": [
"**Persistence**\n",
"\n",
"To add in persistence, we pass in a checkpoint when compiling the graph"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "6845ed6a-d155-4105-9160-28849877248b",
"metadata": {},
"outputs": [],
"source": [
"from langgraph.checkpoint.sqlite import SqliteSaver\n",
"\n",
"memory = SqliteSaver.from_conn_string(\":memory:\")"
]
},
{
"cell_type": "markdown",
"id": "cc7fa795-b3f8-4731-b37e-db7a802558ac",
"metadata": {},
"source": [
"**Interrupt**\n",
"\n",
"To always interrupt before a particular node, pass the name of the node to compile."
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "79d29875-8aa8-434c-9f20-1c58346a6249",
"metadata": {},
"outputs": [],
"source": [
"# Finally, we compile it!\n",
"# This compiles it into a LangChain Runnable,\n",
"# meaning you can use it as you would any other runnable\n",
"app = workflow.compile(checkpointer=memory, interrupt_before=['action'])"
]
},
{
"cell_type": "markdown",
"id": "2a1b56c5-bd61-4192-8bdb-458a1e9f0159",
"metadata": {},
"source": [
"## Interacting with the Agent\n",
"\n",
"We can now interact with the agent and see that it stops before calling a tool.\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "cfd140f0-a5a6-4697-8115-322242f197b5",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"content='Hello Bob! How can I assist you today?'\n"
]
}
],
"source": [
"from langchain_core.messages import HumanMessage\n",
"inputs = [HumanMessage(content=\"hi! I'm bob\")]\n",
"for event in app.stream(inputs, {\"configurable\": {\"thread_id\": \"2\"}}):\n",
" for k, v in event.items():\n",
" if k != \"__end__\":\n",
" print(v)"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "08ae8246-11d5-40e1-8567-361e5bef8917",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"content='Your name is Bob.'\n"
]
}
],
"source": [
"inputs = [HumanMessage(content=\"what is my name?\")]\n",
"for event in app.stream(inputs, {\"configurable\": {\"thread_id\": \"2\"}}):\n",
" for k, v in event.items():\n",
" if k != \"__end__\":\n",
" print(v)"
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "273d56a8-f40f-4a51-a27f-7c6bb2bda0ba",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"content='' additional_kwargs={'function_call': {'arguments': '{\\n \"query\": \"weather in San Francisco now\"\\n}', 'name': 'tavily_search_results_json'}}\n"
]
}
],
"source": [
"inputs = [HumanMessage(content=\"what's the weather in sf now?\")]\n",
"for event in app.stream(inputs, {\"configurable\": {\"thread_id\": \"2\"}}):\n",
" for k, v in event.items():\n",
" if k != \"__end__\":\n",
" print(v)"
]
},
{
"cell_type": "markdown",
"id": "1bca3814-db08-4b0b-8c0c-95b6c5440c81",
"metadata": {},
"source": [
"**Resume**\n",
"\n",
"We can now call the agent again with no inputs to continue, ie. run the tool as requested."
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "51923913-20f7-4ee1-b9ba-d01f5fb2869b",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"content='[{\\'url\\': \\'https://www.sfexaminer.com/news/climate/san-francisco-weather-forecast-calls-for-strongest-2024-rain/article_75347810-bfc3-11ee-abf6-e74c528e0583.html\\', \\'content\\': \"San Francisco is projected to receive 2.5 and 3 inches of rain, Clouser said, as well as gusts of wind up to 45 mph. Bay Area starting Wednesday at 4 a.m. and a 24-hour wind advisory in San Francisco starting at the same time. One of winter\\'s \\'stronger\\' storms to douse San Francisco On the heels of record-breaking heat to open the week, heavy rain is slated to pound the Bay Area on Wednesday.A series of historic storms last winter led to one of the wettest water years (Oct. 1 to Sept. 30) in The City\\'s history, highlighted by a 10-day stretch last January in which San Francisco...\"}]' name='tavily_search_results_json'\n",
"content=\"Currently, I couldn't retrieve the exact weather information for San Francisco. However, there is a forecast of heavy rain and gusts of wind up to 45 mph in San Francisco starting Wednesday at 4 a.m. You may want to check a reliable weather website or app for the most up-to-date weather conditions.\"\n"
]
}
],
"source": [
"for event in app.stream(None, {\"configurable\": {\"thread_id\": \"2\"}}):\n",
" for k, v in event.items():\n",
" if k != \"__end__\":\n",
" print(v)"
]
}
],
"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.1"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
examples/plan-and-execute/plan-and-execute.ipynb
+494
View File
@@ -0,0 +1,494 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "79b5811c-1074-495f-9722-8325b5e717d3",
"metadata": {},
"source": [
"# Plan-and-Execute\n",
"\n",
"This notebook shows how to create a \"plan-and-execute\" style agent. This is heavily inspired by the [Plan-and-Solve](https://arxiv.org/abs/2305.04091) paper as well as the [Baby-AGI](https://github.com/yoheinakajima/babyagi) project.\n",
"\n",
"The core idea is to first come up with a multi-step plan, and then go through that plan one item at a time.\n",
"After accomplishing a particular task, you can then revisit the plan and modify as appropriate.\n",
"\n",
"This compares to a typical [ReAct](https://arxiv.org/abs/2210.03629) style agent where you think one step at a time.\n",
"The advantages of this \"plan-and-execute\" style agent are:\n",
"\n",
"1. Explicit long term planning (which even really strong LLMs can struggle with)\n",
"2. Ability to use smaller/weaker models for the execution step, only using larger/better models for the planning step"
]
},
{
"cell_type": "markdown",
"id": "a44a72d6-7e0c-4478-9d20-4c09000420a8",
"metadata": {},
"source": [
"## Setup\n",
"\n",
"First, we need to install the packages required."
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "b451b58a-89bd-424f-8c06-0d9fe325e01b",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.3.2\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.0\u001b[0m\n",
"\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpython3.11 -m pip install --upgrade pip\u001b[0m\n"
]
}
],
"source": [
"!pip install --quiet -U langchain langchain_openai tavily-python"
]
},
{
"cell_type": "markdown",
"id": "35f267b0-98db-4a59-8b2c-a23f795576ff",
"metadata": {},
"source": [
"Next, we need to set API keys for OpenAI (the LLM we will use) and Tavily (the search tool we will use)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ce438281-08d5-4804-afe7-e4089f7b016b",
"metadata": {},
"outputs": [],
"source": [
"import os\n",
"import getpass\n",
"\n",
"os.environ[\"OPENAI_API_KEY\"] = getpass.getpass(\"OpenAI API Key:\")\n",
"os.environ[\"TAVILY_API_KEY\"] = getpass.getpass(\"Tavily API Key:\")"
]
},
{
"cell_type": "markdown",
"id": "be2d7981-3737-4134-8bef-d00d18d4e91d",
"metadata": {},
"source": [
"Optionally, we can set API key for LangSmith tracing, which will give us best-in-class observability."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "01f460d1-f26f-47d1-ae76-de74d5d851de",
"metadata": {},
"outputs": [],
"source": [
"os.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\n",
"os.environ[\"LANGCHAIN_API_KEY\"] = getpass.getpass(\"LangSmith API Key:\")"
]
},
{
"cell_type": "code",
"execution_count": 37,
"id": "e475c7f9-4c46-4f21-8ba6-2e4d67b09cae",
"metadata": {},
"outputs": [],
"source": [
"import os\n",
"os.environ[\"LANGCHAIN_PROJECT\"] = \"brex\""
]
},
{
"cell_type": "markdown",
"id": "6c5fb09a-0311-44c2-b243-d0e80de78902",
"metadata": {},
"source": [
"## Define Tools\n",
"\n",
"We will first define the tools we want to use. For this simple example, we will use a built-in search tool via Tavily. However, it is really easy to create your own tools - see documentation [here](https://python.langchain.com/docs/modules/agents/tools/custom_tools) on how to do that."
]
},
{
"cell_type": "code",
"execution_count": 38,
"id": "25b9ec62-0675-4715-811c-9b32c635b22f",
"metadata": {},
"outputs": [],
"source": [
"from langchain_community.tools.tavily_search import TavilySearchResults\n",
"\n",
"tools = [TavilySearchResults(max_results=3)]"
]
},
{
"cell_type": "markdown",
"id": "3dcda478-fa80-4e3e-bb35-0f622fe73a31",
"metadata": {},
"source": [
"## Define our Execution Agent\n",
"\n",
"Now we will create the execution agent we want to use to execute tasks. \n",
"Note that for this example, we will be using the same execution agent for each task, but this doesn't HAVE to be the case."
]
},
{
"cell_type": "code",
"execution_count": 39,
"id": "72d233ca-1dbf-4b43-b680-b3bf39e3691f",
"metadata": {},
"outputs": [],
"source": [
"from langchain import hub\n",
"from langchain.agents import create_openai_functions_agent\n",
"from langchain_openai import ChatOpenAI\n",
"# Get the prompt to use - you can modify this!\n",
"prompt = hub.pull(\"hwchase17/openai-functions-agent\")\n",
"# Choose the LLM that will drive the agent\n",
"llm = ChatOpenAI(model=\"gpt-4-turbo-preview\")\n",
"# Construct the OpenAI Functions agent\n",
"agent_runnable = create_openai_functions_agent(llm, tools, prompt)"
]
},
{
"cell_type": "code",
"execution_count": 40,
"id": "a3ea9bd3-87d9-4a78-aec6-8ab4bf34479b",
"metadata": {},
"outputs": [],
"source": [
"from langgraph.prebuilt import create_agent_executor"
]
},
{
"cell_type": "code",
"execution_count": 41,
"id": "998aebde-c204-494f-930c-14747ed34861",
"metadata": {},
"outputs": [],
"source": [
"agent_executor = create_agent_executor(agent_runnable, tools)"
]
},
{
"cell_type": "code",
"execution_count": 42,
"id": "746e697a-dec4-4342-a814-9b3456828169",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'input': 'who is the winnner of the us open',\n",
" 'chat_history': [],\n",
" 'agent_outcome': AgentFinish(return_values={'output': 'The winners of the US Open in 2023 are:\\n\\n- For tennis, Coco Gauff won her first Grand Slam title at the US Open 2023 with a comeback victory against Aryna Sabalenka. [Source](https://sports.yahoo.com/us-open-2023-coco-gauff-wins-1st-grand-slam-title-with-wild-comeback-vs-aryna-sabalenka-222431287.html)\\n\\n- In golf, Wyndham Clark won the 2023 US Open, marking his first major championship victory. The tournament took place at the Los Angeles Country Club. [Source](https://www.nbclosangeles.com/news/sports/golf/wyndham-clark-wins-2023-us-open-for-first-major-championship/3172672/)'}, log='The winners of the US Open in 2023 are:\\n\\n- For tennis, Coco Gauff won her first Grand Slam title at the US Open 2023 with a comeback victory against Aryna Sabalenka. [Source](https://sports.yahoo.com/us-open-2023-coco-gauff-wins-1st-grand-slam-title-with-wild-comeback-vs-aryna-sabalenka-222431287.html)\\n\\n- In golf, Wyndham Clark won the 2023 US Open, marking his first major championship victory. The tournament took place at the Los Angeles Country Club. [Source](https://www.nbclosangeles.com/news/sports/golf/wyndham-clark-wins-2023-us-open-for-first-major-championship/3172672/)'),\n",
" 'intermediate_steps': [(AgentActionMessageLog(tool='tavily_search_results_json', tool_input={'query': 'US Open winner 2023'}, log=\"\\nInvoking: `tavily_search_results_json` with `{'query': 'US Open winner 2023'}`\\n\\n\\n\", message_log=[AIMessage(content='', additional_kwargs={'function_call': {'arguments': '{\"query\":\"US Open winner 2023\"}', 'name': 'tavily_search_results_json'}})]),\n",
" '[{\\'url\\': \\'https://sports.yahoo.com/us-open-2023-coco-gauff-wins-1st-grand-slam-title-with-wild-comeback-vs-aryna-sabalenka-222431287.html\\', \\'content\\': \\'— US Open Tennis (@usopen) September 9, 2023 — US Open Tennis (@usopen) September 9, 2023 US Open 2023: Coco Gauff wins 1st Grand Slam title with wild comeback vs. Aryna Sabalenka What a backhand winner from Coco Gauff! pic.twitter.com/JhDcFpsJ4E — US Open Tennis (@usopen) September 9, 2023— US Open Tennis (@usopen) September 9, 2023 Gauff got the momentum change the crowd was looking for early in the second set, breaking Sabalenka to go up 3-1 and holding serve from there to take ...\\'}, {\\'url\\': \\'https://www.nbclosangeles.com/news/sports/golf/wyndham-clark-wins-2023-us-open-for-first-major-championship/3172672/\\', \\'content\\': \"Wyndham Clark wins 2023 US Open for first major championship 2023 US Open features a record purse. Here\\'s how much the winning golfer will make Clark on Sunday claimed the 2023 US Open title at the Los Angeles Country Club, making it his first major championship US Open champion in 2011 and a four-time total major winner -- who recorded a nine-under.Clark on Sunday claimed the 2023 US Open title at the Los Angeles Country Club, making it his first major championship triumph. The 29-year-old finished the tournament going 10-under, just edging ...\"}, {\\'url\\': \\'https://www.sportingnews.com/us/golf/news/us-open-2023-live-scores-results-leaderboard/jbmxrpro5jc37drgq8e2lehn\\', \\'content\\': \\'MORE: Watch the 2023 U.S. Open live with Fubo (free trial) U.S. Open leaderboard 2023 Edition Who won the U.S. Open in 2023? Complete scores, results, highlights from Los Angeles Country Club The golf world headed to the City of Angels — Los Angeles — for the 2023 U.S. Open. MORE:\\\\xa0How much prize money does the U.S. Open winner make?Nick Brinkerhoff 06-19-2023 • 23 min read (Getty Images) The golf world headed to the City of Angels — Los Angeles — for the 2023 U.S. Open. And the tournament got its Hollywood ending....\\'}]')]}"
]
},
"execution_count": 42,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"agent_executor.invoke({\"input\": \"who is the winnner of the us open\", \"chat_history\": []})"
]
},
{
"cell_type": "markdown",
"id": "5cf66804-44b2-4904-b1a7-17ad70b551f5",
"metadata": {},
"source": [
"## Define the State\n",
"\n",
"Let's now start by defining the state the track for this agent.\n",
"\n",
"First, we will need to track the current plan. Let's represent that as a list of strings.\n",
"\n",
"Next, we should track previously executed steps. Let's represent that as a list of tuples (these tuples will contain the step and then the result)\n",
"\n",
"Finally, we need to have some state to represent the final response as well as the original input."
]
},
{
"cell_type": "code",
"execution_count": 43,
"id": "8eeeaeea-8f10-4fbe-8e24-4e1a2381a009",
"metadata": {},
"outputs": [],
"source": [
"from langchain_core.pydantic_v1 import BaseModel, Field\n",
"from typing import List, Tuple, Annotated, TypedDict\n",
"import operator\n",
"\n",
"\n",
"class PlanExecute(TypedDict):\n",
"\n",
" input: str \n",
" plan: List[str]\n",
" past_steps: Annotated[List[Tuple], operator.add]\n",
" response: str"
]
},
{
"cell_type": "markdown",
"id": "1dbd770a-9941-40a9-977e-4d55359eee21",
"metadata": {},
"source": [
"## Planning Step\n",
"\n",
"Let's now think about creating the planning step. This will use function calling to create a plan."
]
},
{
"cell_type": "code",
"execution_count": 44,
"id": "4a88626d-6dfd-4488-87f0-a9a0dd6da44c",
"metadata": {},
"outputs": [],
"source": [
"from langchain_core.pydantic_v1 import BaseModel\n",
"\n",
"\n",
"class Plan(BaseModel):\n",
" \"\"\"Plan to follow in future\"\"\"\n",
" steps: List[str] = Field(description=\"different steps to follow, should be in sorted order\")\n"
]
},
{
"cell_type": "code",
"execution_count": 45,
"id": "ec7b1867-1ea3-4df3-9a98-992a1c32ec49",
"metadata": {},
"outputs": [],
"source": [
"from langchain.chains.openai_functions import create_structured_output_runnable\n",
"from langchain_core.prompts import ChatPromptTemplate\n",
"\n",
"planner_prompt = ChatPromptTemplate.from_template(\"\"\"For the given objective, come up with a simple step by step plan. \\\n",
"This plan should involve individual tasks, that if executed correctly will yield the correct answer. Do not add any superfluous steps. \\\n",
"The result of the final step should be the final answer. Make sure that each step has all the information needed - do not skip steps.\n",
"\n",
"{objective}\"\"\")\n",
"planner = create_structured_output_runnable(Plan, ChatOpenAI(model=\"gpt-4-turbo-preview\", temperature=0), planner_prompt)"
]
},
{
"cell_type": "code",
"execution_count": 46,
"id": "67ce37b7-e089-479b-bcb8-c3f5d9874613",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Plan(steps=['Identify the current year.', 'Search for the Australia Open winner of the current year.', 'Find the hometown of the identified winner.'])"
]
},
"execution_count": 46,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"planner.invoke({'objective': 'what is the hometown of the current Australia open winner?'})"
]
},
{
"cell_type": "markdown",
"id": "6e09ad9d-6f90-4bdc-bb43-b1ce94517c29",
"metadata": {},
"source": [
"## Re-Plan Step\n",
"\n",
"Now, let's create a step that re-does the plan based on the result of the previous step."
]
},
{
"cell_type": "code",
"execution_count": 47,
"id": "ec2d12cc-016a-44d1-aa08-4c5ce1e8fe2a",
"metadata": {},
"outputs": [],
"source": [
"from langchain.chains.openai_functions import create_openai_fn_runnable\n",
"class Response(BaseModel):\n",
" \"\"\"Response to user.\"\"\"\n",
" response: str\n",
"\n",
"replanner_prompt = ChatPromptTemplate.from_template(\"\"\"For the given objective, come up with a simple step by step plan. \\\n",
"This plan should involve individual tasks, that if executed correctly will yield the correct answer. Do not add any superfluous steps. \\\n",
"The result of the final step should be the final answer. Make sure that each step has all the information needed - do not skip steps.\n",
"\n",
"Your objective was this:\n",
"{input}\n",
"\n",
"Your original plan was this:\n",
"{plan}\n",
"\n",
"You have currently done the follow steps:\n",
"{past_steps}\n",
"\n",
"Update your plan accordingly. If no more steps are needed and you can return to the user, then respond with that. Otherwise, fill out the plan. Only add steps to the plan that still NEED to be done. Do not return previously done steps as part of the plan.\"\"\")\n",
"\n",
"\n",
"replanner = create_openai_fn_runnable([Plan, Response], ChatOpenAI(model=\"gpt-4-turbo-preview\", temperature=0), replanner_prompt)\n"
]
},
{
"cell_type": "markdown",
"id": "859abd13-6ba0-45ad-b341-e652dd5f755b",
"metadata": {},
"source": [
"## Create the Graph\n",
"\n",
"We can now create the graph!"
]
},
{
"cell_type": "code",
"execution_count": 48,
"id": "6c8e0dad-bcea-4c9a-8922-0d820892e2d0",
"metadata": {},
"outputs": [],
"source": [
"async def execute_step(state: PlanExecute):\n",
" task = state['plan'][0]\n",
" agent_response = await agent_executor.ainvoke({\"input\": task, \"chat_history\": []})\n",
" return {\"past_steps\": (task, agent_response['agent_outcome'].return_values['output'])}\n",
"\n",
"async def plan_step(state: PlanExecute):\n",
" plan = await planner.ainvoke({\"objective\": state[\"input\"]})\n",
" return {\"plan\": plan.steps}\n",
"\n",
"async def replan_step(state: PlanExecute):\n",
" output = await replanner.ainvoke(state)\n",
" if isinstance(output, Response):\n",
" return {\"response\": output.response}\n",
" else:\n",
" return {\"plan\": output.steps}\n",
"\n",
"def should_end(state: PlanExecute):\n",
" if state['response']:\n",
" return True\n",
" else:\n",
" return False"
]
},
{
"cell_type": "code",
"execution_count": 49,
"id": "e954cea0-5ccc-46c2-a27b-f5b7185b597d",
"metadata": {},
"outputs": [],
"source": [
"from langgraph.graph import StateGraph, END\n",
"\n",
"workflow = StateGraph(PlanExecute)\n",
"\n",
"# Add the plan node\n",
"workflow.add_node(\"planner\", plan_step)\n",
"\n",
"# Add the execution step\n",
"workflow.add_node(\"agent\", execute_step)\n",
"\n",
"# Add a replan node\n",
"workflow.add_node(\"replan\", replan_step)\n",
"\n",
"workflow.set_entry_point(\"planner\")\n",
"\n",
"# From plan we go to agent\n",
"workflow.add_edge('planner', 'agent')\n",
"\n",
"# From agent, we replan\n",
"workflow.add_edge(\"agent\", \"replan\")\n",
"\n",
"workflow.add_conditional_edges(\n",
" \"replan\",\n",
" # Next, we pass in the function that will determine which node is called next.\n",
" should_end,\n",
" {\n",
" # If `tools`, then we call the tool node.\n",
" True: END,\n",
" False: \"agent\",\n",
" }\n",
")\n",
"\n",
"# Finally, we compile it!\n",
"# This compiles it into a LangChain Runnable,\n",
"# meaning you can use it as you would any other runnable\n",
"app = workflow.compile()"
]
},
{
"cell_type": "code",
"execution_count": 50,
"id": "b8ac1f67-e87a-427c-b4f7-44351295b788",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'plan': ['Identify the winner of the 2024 Australia Open.', \"Research the winner's biography to find their place of birth or hometown.\", 'Confirm the hometown of the 2024 Australia Open winner.']}\n",
"{'past_steps': ('Identify the winner of the 2024 Australia Open.', \"The winners of the 2024 Australian Open were Jannik Sinner in the men's singles category and Aryna Sabalenka in the women's singles category.\")}\n",
"{'plan': [\"Research Jannik Sinner's biography to find his place of birth or hometown.\", \"Research Aryna Sabalenka's biography to find her place of birth or hometown.\", 'Confirm the hometown of Jannik Sinner.', 'Confirm the hometown of Aryna Sabalenka.']}\n",
"{'past_steps': (\"Research Jannik Sinner's biography to find his place of birth or hometown.\", 'Jannik Sinner was born in Innichen, Italy. This town is also known as San Candido, which is mentioned as his hometown.')}\n",
"{'plan': [\"Research Aryna Sabalenka's biography to find her place of birth or hometown.\", 'Confirm the hometown of Aryna Sabalenka.']}\n",
"{'past_steps': (\"Research Aryna Sabalenka's biography to find her place of birth or hometown.\", 'Aryna Sabalenka was born in Minsk, the capital of Belarus.')}\n",
"{'response': 'The hometown of the 2024 Australia Open winners are Innichen (San Candido), Italy for Jannik Sinner and Minsk, Belarus for Aryna Sabalenka. No further steps are needed.'}\n"
]
}
],
"source": [
"from langchain_core.messages import HumanMessage\n",
"config = {\"recursion_limit\": 50}\n",
"inputs = {\"input\": \"what is the hometown of the 2024 Australia open winner?\"}\n",
"async for event in app.astream(inputs, config=config):\n",
" for k, v in event.items():\n",
" if k != \"__end__\":\n",
" print(v)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8c20341e-267d-4ba0-9a0b-dad055a76b1d",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "ad8f7955-2cc9-4ebb-8c41-13abb3351a24",
"metadata": {},
"outputs": [],
"source": []
}
],
"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.1"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
langgraph/graph/graph.py
+16 -4
View File
@@ -1,6 +1,6 @@
from asyncio import iscoroutinefunction
from collections import defaultdict
from typing import Any, Callable, Dict, NamedTuple, Optional
from typing import Any, Callable, Dict, NamedTuple, Optional, Sequence
from langchain_core.runnables import Runnable
from langchain_core.runnables.base import (
@@ -88,7 +88,7 @@ class Graph:
def set_finish_point(self, key: str) -> None:
return self.add_edge(key, END)
def validate(self) -> None:
def validate(self, interrupt: Optional[Sequence[str]] = None) -> None:
all_starts = {src for src, _ in self.edges} | {src for src in self.branches}
for node in self.nodes:
if node not in all_starts:
@@ -114,8 +114,17 @@ class Graph:
if node not in all_ends:
raise ValueError(f"Node `{node}` is not reachable")
def compile(self, checkpointer: Optional[BaseCheckpointSaver] = None) -> Pregel:
self.validate()
if interrupt:
for node in interrupt:
if node not in self.nodes:
raise ValueError(f"Node `{node}` is not present")
def compile(
self,
checkpointer: Optional[BaseCheckpointSaver] = None,
interrupt_before: Optional[Sequence[str]] = None,
) -> Pregel:
self.validate(interrupt=interrupt_before)
outgoing_edges = defaultdict(list)
for start, end in self.edges:
@@ -145,4 +154,7 @@ class Graph:
output=END,
hidden=[f"{node}:inbox" for node in self.nodes],
checkpointer=checkpointer,
interrupt=[f"{node}:inbox" for node in interrupt_before]
if interrupt_before
else [],
)
langgraph/graph/state.py
+11 -4
View File
@@ -1,7 +1,7 @@
from collections import defaultdict
from functools import partial
from inspect import signature
from typing import Any, Optional, Type
from typing import Any, Optional, Sequence, Type
from langchain_core.runnables import RunnableLambda, RunnablePassthrough
from langchain_core.runnables.base import RunnableLike
@@ -34,8 +34,12 @@ class StateGraph(Graph):
)
return super().add_node(key, action)
def compile(self, checkpointer: Optional[BaseCheckpointSaver] = None) -> Pregel:
self.validate()
def compile(
self,
checkpointer: Optional[BaseCheckpointSaver] = None,
interrupt_before: Optional[Sequence[str]] = None,
) -> Pregel:
self.validate(interrupt=interrupt_before)
state_keys = list(self.channels)
state_keys_read = state_keys[0] if state_keys == ["__root__"] else state_keys
@@ -98,6 +102,9 @@ class StateGraph(Graph):
output=END,
hidden=[f"{node}:inbox" for node in self.nodes] + [START] + state_keys,
checkpointer=checkpointer,
interrupt=[f"{node}:inbox" for node in interrupt_before]
if interrupt_before
else [],
)
@@ -105,7 +112,7 @@ def _coerce_state(schema: Type[Any], input: dict[str, Any]) -> dict[str, Any]:
return schema(**input)
def _dict_getter(allowed_keys: str, key: str, input: dict) -> Any:
def _dict_getter(allowed_keys: list[str], key: str, input: dict) -> Any:
if input is not None:
if not isinstance(input, dict) or any(key not in allowed_keys for key in input):
raise InvalidUpdateError(
pyproject.toml
+1 -1
View File
@@ -1,6 +1,6 @@
[tool.poetry]
name = "langgraph"
version = "0.0.23"
version = "0.0.24"
description = "langgraph"
authors = []
license = "LangGraph License"