diff --git a/examples/multi_agent/agent_supervisor.ipynb b/examples/multi_agent/agent_supervisor.ipynb index 07c85533f..ec3e3b52c 100644 --- a/examples/multi_agent/agent_supervisor.ipynb +++ b/examples/multi_agent/agent_supervisor.ipynb @@ -15,23 +15,25 @@ "\n", "![diagram](./img/supervisor-diagram.png)\n", "\n", - "To simplify the code in each agent node, we will use the AgentExecutor class from LangChain. This and other \"advanced agent\" notebooks are designed to show how you can implement certain design patterns in LangGraph. If the pattern suits your needs, we recommend combining it with some of the other fundamental patterns described elsewhere in the docs for best performance." + "To simplify the code in each agent node, we will use the AgentExecutor class from LangChain. This and other \"advanced agent\" notebooks are designed to show how you can implement certain design patterns in LangGraph. If the pattern suits your needs, we recommend combining it with some of the other fundamental patterns described elsewhere in the docs for best performance.\n", + "\n", + "Before we build, let's configure our environment:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0d30b6f7-3bec-4d9f-af50-43dfdc81ae6c", + "metadata": {}, + "outputs": [], + "source": [ + "# %%capture --no-stderr\n", + "# %pip install -U langchain langchain_openai langchain_experimental langsmith pandas" ] }, { "cell_type": "code", "execution_count": 1, - "id": "0d30b6f7-3bec-4d9f-af50-43dfdc81ae6c", - "metadata": {}, - "outputs": [], - "source": [ - "%%capture --no-stderr\n", - "%pip install -U langchain langchain_openai langchain_experimental langsmith pandas" - ] - }, - { - "cell_type": "code", - "execution_count": 3, "id": "30c2f3de-c730-4aec-85a6-af2c2f058803", "metadata": {}, "outputs": [], @@ -54,6 +56,16 @@ "os.environ[\"LANGCHAIN_PROJECT\"] = \"Multi-agent Collaboration\"" ] }, + { + "cell_type": "markdown", + "id": "1ac25624-4d83-45a4-b9ef-a10589aacfb7", + "metadata": {}, + "source": [ + "## Create tools\n", + "\n", + "For this example, you will make an agent to do web research with a search engine, and one agent to create plots. Define the tools they'll use below:" + ] + }, { "cell_type": "code", "execution_count": 4, @@ -63,81 +75,43 @@ "source": [ "from typing import Annotated, List, Tuple, Union\n", "\n", - "import matplotlib.pyplot as plt\n", "from langchain_community.tools.tavily_search import TavilySearchResults\n", "from langchain_core.tools import tool\n", + "from langchain_experimental.tools import PythonREPLTool\n", "\n", "tavily_tool = TavilySearchResults(max_results=5)\n", "\n", + "# This executes code locally, which can be unsafe\n", + "python_repl_tool = PythonREPLTool()" + ] + }, + { + "cell_type": "markdown", + "id": "d58d1e85-22d4-4c22-9062-72a346a0d709", + "metadata": {}, + "source": [ + "## Helper Utilites\n", "\n", - "@tool\n", - "def create_plot(\n", - " data: Annotated[\n", - " Union[List[float], List[int]],\n", - " \"Numerical values for bar heights or line points.\",\n", - " ],\n", - " file_name: Annotated[str, \"File path to save the figure.\"],\n", - " labels: Annotated[\n", - " Union[List[str], None], \"Bar or point labels, defaults to None.\"\n", - " ] = None,\n", - " title: Annotated[str, \"Title of the plot.\"] = \"Plot\",\n", - " xlabel: Annotated[str, \"Label for the X-axis.\"] = \"X\",\n", - " ylabel: Annotated[str, \"Label for the Y-axis.\"] = \"Y\",\n", - " color: Annotated[Union[str, List[str]], \"Color(s) for the bars or line.\"] = \"blue\",\n", - " plot_type: Annotated[str, \"Type of plot ('bar' or 'line').\"] = \"bar\",\n", - ") -> Annotated[str, \"Path of the saved figure file.\"]:\n", - " \"\"\"Create a line or bar chart.\"\"\"\n", - " if plot_type not in [\"bar\", \"line\"]:\n", - " raise ValueError(\"Invalid plot_type. Expected 'bar' or 'line'.\")\n", - "\n", - " fig, ax = plt.subplots(figsize=(10, 6))\n", - " x_positions = range(len(data))\n", - "\n", - " if labels and len(labels) == len(data):\n", - " plt.xticks(x_positions, labels)\n", - "\n", - " if plot_type == \"bar\":\n", - " ax.bar(x_positions, data, color=color)\n", - " elif plot_type == \"line\":\n", - " ax.plot(x_positions, data, color=color, marker=\"o\") # 'o' for circular markers\n", - "\n", - " ax.set_title(title)\n", - " ax.set_xlabel(xlabel)\n", - " ax.set_ylabel(ylabel)\n", - " fig.savefig(file_name)\n", - " plt.close(fig)\n", - " return f'Saved \"{title}\" plot to {file_name}'" + "Define a helper function below, which make it easier to add new agent worker nodes." ] }, { "cell_type": "code", - "execution_count": 5, - "id": "6a430af7-8fce-4e66-ba9e-d940c1bc48e8", + "execution_count": 3, + "id": "c4823dd9-26bd-4e1a-8117-b97b2860211a", "metadata": {}, "outputs": [], "source": [ - "import operator\n", - "from typing import Annotated, Any, Dict, List, Optional, Sequence, TypedDict\n", - "\n", - "from langchain.agents import AgentExecutor, create_openai_functions_agent\n", "from langchain_core.messages import BaseMessage, HumanMessage\n", - "from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder\n", - "from langchain_core.tools import BaseTool\n", - "from langchain_experimental.tools import PythonREPLTool\n", "from langchain_openai import ChatOpenAI\n", "\n", "from langgraph.graph import END, StateGraph\n", "\n", "\n", - "class AgentState(TypedDict):\n", - " messages: Annotated[Sequence[BaseMessage], operator.add]\n", - " next: str\n", - "\n", - "\n", - "workflow = StateGraph(AgentState)\n", - "\n", - "\n", - "def create_worker_node(name: str, llm: ChatOpenAI, tools: list, system_prompt: str):\n", + "def create_worker_node(\n", + " workflow: StateGraph, name: str, llm: ChatOpenAI, tools: list, system_prompt: str\n", + "):\n", + " # Each worker node will be given a name and some tools.\n", " prompt = ChatPromptTemplate.from_messages(\n", " [\n", " (\n", @@ -151,22 +125,62 @@ " agent = create_openai_functions_agent(llm, tools, prompt)\n", " executor = AgentExecutor(agent=agent, tools=tools)\n", " chain = executor | (\n", + " # So the agents properly role-play in this simulation, we will\n", + " # tag their final message as a human message\n", " lambda x: {\"messages\": [HumanMessage(content=x[\"output\"], name=name)]}\n", " )\n", - " workflow.add_node(name, chain)\n", + " workflow.add_node(name, chain)" + ] + }, + { + "cell_type": "markdown", + "id": "a07d507f-34d1-4f1b-8dde-5e58d17b2166", + "metadata": {}, + "source": [ + "## Construct Graph\n", "\n", + "We're ready to start building the graph. Below, define the state and worker nodes using the function we just defined." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "6a430af7-8fce-4e66-ba9e-d940c1bc48e8", + "metadata": {}, + "outputs": [], + "source": [ + "import operator\n", + "from typing import Annotated, Any, Dict, List, Optional, Sequence, TypedDict\n", + "\n", + "from langchain.agents import AgentExecutor, create_openai_functions_agent\n", + "from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder\n", + "\n", + "\n", + "# The agent state is the input to each node in the graph\n", + "class AgentState(TypedDict):\n", + " # The annotation tells the graph that new messages will always\n", + " # be added to the current states\n", + " messages: Annotated[Sequence[BaseMessage], operator.add]\n", + " # The 'next' field indicates where to route to next\n", + " next: str\n", + "\n", + "\n", + "workflow = StateGraph(AgentState)\n", "\n", "llm = ChatOpenAI(model=\"gpt-4-1106-preview\")\n", "\n", - "# Note: these worker nodes don't _have_ to be agents. They can be any DAG, tool, or function\n", - "create_worker_node(\"Researcher\", llm, [tavily_tool], \"You are a web researcher.\")\n", - "create_worker_node(\"Chart Generator\", llm, [create_plot], \"You are a chart generator.\")\n", + "\n", + "create_worker_node(\n", + " workflow, \"Researcher\", llm, [tavily_tool], \"You are a web researcher.\"\n", + ")\n", "# NOTE: THIS PERFORMS ARBITRARY CODE EXECUTION. PROCEED WITH CAUTION\n", "create_worker_node(\n", + " workflow,\n", " \"Coder\",\n", " llm,\n", - " [PythonREPLTool()],\n", - " \"You may generate safe python code to analyze data.\",\n", + " [python_repl_tool],\n", + " \"You may generate safe python code to analyze data \"\n", + " \"and generate charts using matplotlib.\",\n", ")" ] }, @@ -175,126 +189,185 @@ "id": "d6374825-912f-40c9-910d-afa267b401bf", "metadata": {}, "source": [ - "Almost done, now we need to create the team supervisor." + "Almost done, now create create the team supervisor. It will use function calling to choose the next worker node OR finish processing." ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 19, "id": "17c108a0-6dc3-46fd-a5e6-a1fcfad5458a", "metadata": {}, "outputs": [], "source": [ - "# So the team supervisor is an LLM node. It just picks the next t\n", "from langchain.output_parsers.openai_functions import JsonOutputFunctionsParser\n", "\n", - "\n", - "def create_supervisor(members: List[str], llm: ChatOpenAI, system_prompt: str):\n", - " options = [\"FINISH\"] + members\n", - " function_def = {\n", - " \"name\": \"route\",\n", - " \"description\": \"Select the next role.\",\n", - " \"parameters\": {\n", - " \"title\": \"routeSchema\",\n", - " \"type\": \"object\",\n", - " \"properties\": {\n", - " \"next\": {\n", - " \"title\": \"Next\",\n", - " \"anyOf\": [\n", - " {\"enum\": options},\n", - " ],\n", - " }\n", - " },\n", - " \"required\": [\"next\"],\n", - " },\n", - " }\n", - " prompt = ChatPromptTemplate.from_messages(\n", - " [\n", - " (\"system\", system_prompt),\n", - " MessagesPlaceholder(variable_name=\"messages\"),\n", - " (\n", - " \"system\",\n", - " \"Given the conversation above, who should act next?\"\n", - " \" Or should we FINISH? Select one of: {options}\",\n", - " ),\n", - " ]\n", - " ).partial(options=str(options))\n", - " if \"members\" in prompt.input_variables:\n", - " prompt = prompt.partial(members=\", \".join(members))\n", - " chain = (\n", - " prompt\n", - " | llm.bind_functions(functions=[function_def], function_call=\"route\")\n", - " | JsonOutputFunctionsParser()\n", - " )\n", - " workflow.add_node(\"supervisor\", chain)\n", - " conditional_map = {k: k for k in members}\n", - " conditional_map[\"FINISH\"] = END\n", - "\n", - " for member in members:\n", - " workflow.add_edge(member, \"supervisor\")\n", - " workflow.add_conditional_edges(\"supervisor\", lambda x: x[\"next\"], conditional_map)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "14778e86-077b-4e6a-893c-400e59b0cdbf", - "metadata": {}, - "outputs": [], - "source": [ - "create_supervisor(\n", - " [\"Researcher\", \"Chart Generator\", \"Coder\"],\n", - " llm,\n", + "members = [\"Researcher\", \"Coder\"]\n", + "system_prompt = (\n", " \"You are a supervisor tasked with managing a conversation between the\"\n", " \" following workers: {members}. Given the following user request,\"\n", " \" respond with the worker to act next. Each worker will perform a\"\n", " \" task and respond with their results and status. When finished,\"\n", - " \" respond with FINISH.\",\n", + " \" respond with FINISH.\"\n", ")\n", + "# Our team supervisor is an LLM node. It just picks the next agent to process\n", + "# and decides when the work is completed\n", + "options = [\"FINISH\"] + members\n", + "# Using openai function calling can make output parsing easier for us\n", + "function_def = {\n", + " \"name\": \"route\",\n", + " \"description\": \"Select the next role.\",\n", + " \"parameters\": {\n", + " \"title\": \"routeSchema\",\n", + " \"type\": \"object\",\n", + " \"properties\": {\n", + " \"next\": {\n", + " \"title\": \"Next\",\n", + " \"anyOf\": [\n", + " {\"enum\": options},\n", + " ],\n", + " }\n", + " },\n", + " \"required\": [\"next\"],\n", + " },\n", + "}\n", + "prompt = ChatPromptTemplate.from_messages(\n", + " [\n", + " (\"system\", system_prompt),\n", + " MessagesPlaceholder(variable_name=\"messages\"),\n", + " (\n", + " \"system\",\n", + " \"Given the conversation above, who should act next?\"\n", + " \" Or should we FINISH? Select one of: {options}\",\n", + " ),\n", + " ]\n", + ").partial(options=str(options), members=\", \".join(members))\n", "\n", - "# Finally, add entrypoint\n", - "workflow.set_entry_point(\"supervisor\")\n", - "\n", - "\n", - "def enter(text: str) -> dict:\n", - " return {\"messages\": [HumanMessage(content=text)]}\n", - "\n", - "\n", - "graph = enter | workflow.compile()" + "supervisor_chain = (\n", + " prompt\n", + " | llm.bind_functions(functions=[function_def], function_call=\"route\")\n", + " | JsonOutputFunctionsParser()\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "2c1593d5-39f7-4819-96d2-4ad7d7991d72", + "metadata": {}, + "source": [ + "Now connect all the edges in the graph." ] }, { "cell_type": "code", - "execution_count": null, - "id": "56ba78e9-d9c1-457c-a073-d606d5d3e013", + "execution_count": 20, + "id": "14778e86-077b-4e6a-893c-400e59b0cdbf", "metadata": {}, "outputs": [], "source": [ - "results = graph.invoke(\"Code hello world and print it to the terminal\")\n", - "results[\"messages\"][-1].pretty_print()" + "workflow.add_node(\"supervisor\", supervisor_chain)\n", + "\n", + "\n", + "for member in members:\n", + " # We want our workers to ALWAYS \"report back\" to the supervisor when done\n", + " workflow.add_edge(member, \"supervisor\")\n", + "# The supervisor populates the \"next\" field in the graph state\n", + "# which routes to a node or finishes\n", + "conditional_map = {k: k for k in members}\n", + "conditional_map[\"FINISH\"] = END\n", + "workflow.add_conditional_edges(\"supervisor\", lambda x: x[\"next\"], conditional_map)\n", + "# Finally, add entrypoint\n", + "workflow.set_entry_point(\"supervisor\")\n", + "\n", + "graph = workflow.compile()" + ] + }, + { + "cell_type": "markdown", + "id": "d36496de-7121-4c49-8cb6-58c943c66628", + "metadata": {}, + "source": [ + "## Invoke the team\n", + "\n", + "With the graph created, we can now invoke it and see how it performs!" ] }, { "cell_type": "code", - "execution_count": 10, - "id": "45a92dfd-0e11-47f5-aad4-b68d24990e34", + "execution_count": 21, + "id": "56ba78e9-d9c1-457c-a073-d606d5d3e013", "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Python REPL can execute arbitrary code. Use with caution.\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ "================================\u001b[1m Human Message \u001b[0m=================================\n", "\n", - "The chart summarizing the data on the 2023 California wildfires has been created successfully. You can see the representation of the statistics mentioned in the summary including the total number of fires, total acres burned, comparison with the five-year average, the size of the largest wildfire, and the number of fatalities.\n", - "\n", - "![2023 California Wildfires Overview](sandbox:/ca_wildfires_2023_chart.png)\n" + "The \"Hello, World!\" message has been successfully printed to the terminal.\n" ] } ], "source": [ "results = graph.invoke(\n", - " \"Write a research summary of CA wildfires in 2023. Include a chart.\"\n", + " {\n", + " \"messages\": [\n", + " HumanMessage(content=\"Code hello world and print it to the terminal\")\n", + " ]\n", + " }\n", + ")\n", + "results[\"messages\"][-1].pretty_print()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "45a92dfd-0e11-47f5-aad4-b68d24990e34", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "================================\u001b[1m Human Message \u001b[0m=================================\n", + "\n", + "The chart has been successfully created and saved as \"california_wildfires_comparison.png\". This chart compares the acres burned by California wildfires in 2023 to the five-year average for each month. Unfortunately, I'm unable to display the image directly to you here, but the chart visualizes the data with the following characteristics:\n", + "\n", + "- The X-axis represents the months of the year from January to December.\n", + "- The Y-axis indicates the acres burned.\n", + "- A line graph shows the cumulative acres burned in 2023, marked with circles.\n", + "- Another line graph represents the five-year average cumulative acres burned by month, marked with x's and a dashed line.\n", + "- The chart includes a legend to distinguish between the two lines and is titled \"California Wildfires: Acres Burned in 2023 vs 5-Year Average\".\n", + "\n", + "You would need to view the \"california_wildfires_comparison.png\" file using an image viewer to see the actual chart.\n" + ] + } + ], + "source": [ + "results = graph.invoke(\n", + " {\n", + " \"messages\": [\n", + " HumanMessage(\n", + " content=\"Write a research summary of CA wildfires in 2023. Include a chart.\"\n", + " )\n", + " ]\n", + " }\n", ")\n", "results[\"messages\"][-1].pretty_print()" ]