{ "cells": [ { "cell_type": "markdown", "id": "39fd1948-b5c3-48c4-b10e-2ae7e8c83334", "metadata": {}, "source": [ "# Basic Multi-agent Collaboration\n", "\n", "A single agent can usually operate effectively using a handful of tools and a scoped domain, but even using powerful models like `gpt-4`, it can be less effective at using many tools. One way to improve your system's performance is through multi-agent collaboration. Each agent can specialize in a task or domain, and LangGraph can effectively orchestrate them to accomplish a larger goal. \n", "\n", "This notebook is inspired by the paper [AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation](https://arxiv.org/abs/2308.08155), by Wu, et. al.\n", "\n", "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." ] }, { "cell_type": "code", "execution_count": 1, "id": "0d7b6dcc-c985-46e2-8457-7e6b0298b950", "metadata": {}, "outputs": [], "source": [ "# %pip install -U langchain langchain_openai langsmith pandas" ] }, { "cell_type": "code", "execution_count": 2, "id": "743c19df-6da9-4d1e-b2d2-ea40080b9fdc", "metadata": {}, "outputs": [], "source": [ "import getpass\n", "import os\n", "\n", "\n", "def _set_if_undefined(var: str):\n", " if not os.environ.get(var):\n", " os.environ[var] = getpass(f\"Please provide your {var}\")\n", "\n", "\n", "_set_if_undefined(\"OPENAI_API_KEY\")\n", "_set_if_undefined(\"LANGCHAIN_API_KEY\")\n", "_set_if_undefined(\"TAVILY_API_KEY\")\n", "\n", "# Optional, add tracing in LangSmith\n", "os.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\n", "os.environ[\"LANGCHAIN_PROJECT\"] = \"Multi-agent Collaboration\"" ] }, { "cell_type": "markdown", "id": "7d5fc0f3-5d9e-4e72-a281-177f101c2a7d", "metadata": {}, "source": [ "## Create tools\n", "\n", "We will make 2 agents, 1 for plotting, and another for searching information on the web. Below are their tools:" ] }, { "cell_type": "code", "execution_count": 3, "id": "075c91c3-c249-471d-b259-41975faa83fb", "metadata": {}, "outputs": [], "source": [ "from typing import 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", "\n", "tavily_tool = TavilySearchResults(max_results=5)\n", "\n", "\n", "@tool\n", "def create_plot(\n", " data: list,\n", " labels: Union[List[str], None] = None,\n", " title: str = \"Plot\",\n", " xlabel: str = \"X\",\n", " ylabel: str = \"Y\",\n", " color: Union[str, List[str]] = \"blue\",\n", " plot_type: str = \"bar\",\n", ") -> str:\n", " \"\"\"\n", " Generates a bar or line plot from the provided data and returns the figure and axis objects.\n", "\n", " :param data: A list of numerical values for the bar heights or line points.\n", " :param labels: A list of strings for the bar or point labels. Default is None.\n", " :param title: Title of the plot. Default is 'Plot'.\n", " :param xlabel: Label for the X-axis. Default is 'X'.\n", " :param ylabel: Label for the Y-axis. Default is 'Y'.\n", " :param color: Color of the bars or line. Can be a single color or a list of colors. Default is 'blue'.\n", " :param figsize: Size of the figure as a tuple (width, height). Default is (10, 6).\n", " :param plot_type: Type of plot ('bar' or 'line'). Default is 'bar'.\n", " :return: Tuple containing the figure and axes objects.\n", " \"\"\"\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", "\n", " return \"Chart generated!\"" ] }, { "cell_type": "markdown", "id": "5e4344a7-21df-4d54-90d2-9d19b3416ffb", "metadata": {}, "source": [ "## Create graph utilites\n", "\n", "The following helper functions will simplify the code when it comes to actually constructing the graph.\n", "\n", "You can skip ahead if you just want to see what the graph looks like." ] }, { "cell_type": "code", "execution_count": 4, "id": "4325a10e-38dc-4a98-9004-e1525eaba377", "metadata": {}, "outputs": [], "source": [ "import json\n", "\n", "from langchain_core.messages import (\n", " AIMessage,\n", " BaseMessage,\n", " ChatMessage,\n", " FunctionMessage,\n", " HumanMessage,\n", ")\n", "\n", "from langgraph.graph import END, StateGraph\n", "from langgraph.prebuilt.tool_executor import ToolExecutor, ToolInvocation\n", "\n", "\n", "def _update_state(ai_message, name: str) -> dict:\n", " \"\"\"The graph routes the logic based on the message type\n", " and the sender origin. We nee\"\"\"\n", " if isinstance(ai_message, FunctionMessage):\n", " result = ai_message\n", " else:\n", " result = HumanMessage(**ai_message.dict(exclude={\"type\", \"name\"}), name=name)\n", " return {\n", " \"messages\": [result],\n", " # Since we have a strict workflow, we can\n", " # track the sender so we know who to pass to next.\n", " \"sender\": name,\n", " }\n", "\n", "\n", "def add_agent_node(workflow: StateGraph, name: str, llm, tools):\n", " \"\"\"Create an agent and add it to the graph builder.\"\"\"\n", " functions = [format_tool_to_openai_function(t) for t in tools]\n", "\n", " prompt = ChatPromptTemplate.from_messages(\n", " [\n", " (\n", " \"system\",\n", " \"You are a helpful AI assistant, collaborating with other assistants.\"\n", " \" Use the provided tools to progress towards answering the question.\"\n", " \" If you are unable to fully answer, that's OK, another assistant with different tools \"\n", " \" will help where you left off. Execute what you can to make progress.\"\n", " \" If you have the final answer, prefix your response with FINAL ANSWER.\"\n", " \" You have access to the following tools: {tool_names}.\",\n", " ),\n", " MessagesPlaceholder(variable_name=\"messages\"),\n", " ]\n", " )\n", "\n", " chain = (\n", " (lambda x: {**x, \"intermediate_steps\": []})\n", " | prompt.partial(tool_names=\", \".join([tool.name for tool in tools]))\n", " | llm.bind_functions(functions)\n", " | (lambda x: _update_state(x, name=name))\n", " )\n", " workflow.add_node(name, chain)\n", "\n", "\n", "def call_tool(state):\n", " \"\"\"This a helper class we have that is useful for running tools\n", "\n", " It takes in an agent action and calls that tool and returns the result.\"\"\"\n", " messages = state[\"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(\n", " last_message.additional_kwargs[\"function_call\"][\"arguments\"]\n", " ),\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 {\"messages\": [function_message]}" ] }, { "cell_type": "markdown", "id": "f1b54c0c-0b09-408b-abc5-86308929afb6", "metadata": {}, "source": [ "## Create graph\n", "\n", "Now that we've defined our tools and made some helper functions, will create the individual agents below and tell them how to talk to each other using LangGraph." ] }, { "cell_type": "code", "execution_count": 5, "id": "4dce3901-6ad5-4df5-8528-6e865cf96cb0", "metadata": {}, "outputs": [], "source": [ "import operator\n", "from typing import Annotated, Sequence, TypedDict\n", "\n", "from langchain.agents import create_openai_functions_agent\n", "from langchain.tools.render import format_tool_to_openai_function\n", "from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder\n", "from langchain_openai import ChatOpenAI\n", "from typing_extensions import TypedDict\n", "\n", "\n", "# This defines the object that is passed between each node\n", "# in the graph. We will create different nodes for each agent and tool\n", "class AgentState(TypedDict):\n", " messages: Annotated[Sequence[BaseMessage], operator.add]\n", " sender: str\n", "\n", "\n", "tools = [tavily_tool, create_plot]\n", "tool_executor = ToolExecutor(tools)\n", "\n", "\n", "workflow = StateGraph(AgentState)\n", "llm = ChatOpenAI(model=\"gpt-4-1106-preview\")\n", "add_agent_node(\n", " workflow,\n", " \"Researcher\",\n", " llm,\n", " [tavily_tool],\n", ")\n", "add_agent_node(workflow, \"Chart Generator\", llm, [create_plot])\n", "workflow.add_node(\"call_tool\", call_tool)\n", "\n", "\n", "# Either agent can decide to end\n", "def should_continue(state):\n", " # This is the router\n", " messages = state[\"messages\"]\n", " last_message = messages[-1]\n", " if \"function_call\" in last_message.additional_kwargs:\n", " return \"call_tool\"\n", " if \"FINAL ANSWER\" in last_message.content:\n", " return \"end\"\n", " return \"continue\"\n", "\n", "\n", "workflow.add_conditional_edges(\n", " \"Researcher\",\n", " should_continue,\n", " {\"continue\": \"Chart Generator\", \"call_tool\": \"call_tool\", \"end\": END},\n", ")\n", "workflow.add_conditional_edges(\n", " \"Chart Generator\",\n", " should_continue,\n", " {\"continue\": \"Researcher\", \"call_tool\": \"call_tool\", \"end\": END},\n", ")\n", "# We will assume that any time a tool is called, the researcher will choose what to do next\n", "workflow.add_edge(\"call_tool\", \"Researcher\")\n", "workflow.set_entry_point(\"Researcher\")\n", "graph = workflow.compile()" ] }, { "cell_type": "markdown", "id": "8c9447e7-9ab6-43eb-8ae6-9b52f8ba8425", "metadata": {}, "source": [ "## Invoke\n", "\n", "With the graph created, you can invoke it!" ] }, { "cell_type": "code", "execution_count": 6, "id": "176a99b0-b457-45cf-8901-90facaa852da", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "HumanMessage(content=\"FINAL ANSWER:\\n\\nThe line graph of the UK's GDP over the past five years has been generated based on the estimated and provided figures:\\n\\n1. 2019: 2.238 trillion GBP\\n2. 2020: 2.018 trillion GBP\\n3. 2021: 2.14 trillion GBP\\n4. 2022: 2.2 trillion GBP\\n5. 2023: GDP growth of 0.1% in Q1 (Jan to Mar) - Note that the full-year value for 2023 is an estimate based on Q1 data and should be treated with caution.\\n\\nPlease note that the 2023 figure is not the full-year GDP but rather the growth rate for the first quarter. The actual GDP value for 2023 will be determined at the end of the year. The graph provides a visual representation of the GDP trend over the past five years, with an observable dip in 2020 due to the economic impact of the COVID-19 pandemic, followed by a recovery in subsequent years.\", name='Chart Generator')" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "result = graph.invoke(\n", " {\n", " \"messages\": [\n", " HumanMessage(\n", " content=\"Fetch the UK's GDP over the past 5 years, then draw a line graph of it.\"\n", " )\n", " ],\n", " },\n", " # Maximum number of steps to take in the graph\n", " {\"recursion_limit\": 150},\n", ")\n", "result[\"messages\"][-1]" ] } ], "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.2" } }, "nbformat": 4, "nbformat_minor": 5 }