examples/multi_agent/hierarchical_agent_teams.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a3e3ebc4-57af-4fe4-bdd3-36aff67bf276",
   "metadata": {},
   "source": [
    "# Hierarchical Agent Teams\n",
    "\n",
    "In our previous example ([Agent Supervisor](./agent_supervisor.ipynb)), we introduced the concept of a single supervisor node to route work between different worker nodes.\n",
    "\n",
    "But what if the job for a single worker becomes too complex? What if the number of workers becomes too large?\n",
    "\n",
    "For some applications, the system may be more effective if work is distributed _hierarchically_.\n",
    "\n",
    "You can do this by composing different subgraphs and creating a top-level supervisor, along with mid-level supervisors.\n",
    "\n",
    "To do this, let's build a simple research assistant! The graph will look something like the following:\n",
    "\n",
    "![diagram](./img/hierarchical-diagram.png)\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. In the rest of this notebook, you will:\n",
    "\n",
    "1. Define the agents' tools to access the web and write files\n",
    "2. Define some utilities to help create the graph and agents\n",
    "3. Create and define each team (web research + doc writing)\n",
    "4. Compose everything together.\n",
    "\n",
    "But before all of that, some setup:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "30c2f3de-c730-4aec-85a6-af2c2f058803",
   "metadata": {},
   "outputs": [],
   "source": [
    "// Deno.env.set(\"OPENAI_API_KEY\", \"sk_...\");\n",
    "// Deno.env.set(\"TAVILY_API_KEY\", \"sk_...\");\n",
    "\n",
    "// Optional, add tracing in LangSmith\n",
    "// Deno.env.set(\"LANGCHAIN_API_KEY\", \"sk_...\");\n",
    "// Deno.env.set(\"LANGCHAIN_TRACING_V2\", \"true\");\n",
    "// Deno.env.set(\"LANGCHAIN_PROJECT\", \"Multi-agent Collaboration: LangGraphJS\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "54be179b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Module: null prototype] { default: {} }"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import \"dotenv/config\";"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "354568e2-aef0-4af9-8a79-e64d3eea752f",
   "metadata": {},
   "source": [
    "## Create Tools\n",
    "\n",
    "Each team will be composed of one or more agents each with one or more tools. Below, define all the tools to be used by your different teams.\n",
    "\n",
    "We'll start with the research team.\n",
    "\n",
    "**Research team tools**\n",
    "\n",
    "The research team can use a search engine and url scraper to find information on the web. Feel free to add additional functionality below to boost the team performance!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "4024eb89-843d-4cc3-ab3f-e1eb4d031179",
   "metadata": {},
   "outputs": [],
   "source": [
    "import { TavilySearchResults } from \"@langchain/community/tools/tavily_search\";\n",
    "import { CheerioWebBaseLoader } from \"langchain/document_loaders/web/cheerio\";\n",
    "import { DynamicStructuredTool } from \"@langchain/core/tools\";\n",
    "import { z } from \"zod\";\n",
    "\n",
    "const tavilyTool = new TavilySearchResults();\n",
    "\n",
    "// Note: to run this in jupyter, will need to set an import map in deno.json\n",
    "const scrapeWebpage = new DynamicStructuredTool({\n",
    "  name: \"scrape_webpage\",\n",
    "  description: \"Scrape the contents of a webpage.\",\n",
    "  schema: z.object({\n",
    "    url: z.string(),\n",
    "  }),\n",
    "  func: async ({ url }) => {\n",
    "    const loader = new CheerioWebBaseLoader(url);\n",
    "    const docs  = await loader.load();\n",
    "    const formattedDocs = docs.map(\n",
    "      (doc) =>\n",
    "        `<Document name=\"${doc.metadata?.title}\">\\n${doc.pageContent}\\n</Document>`\n",
    "    );\n",
    "    return formattedDocs.join(\"\\n\\n\");\n",
    "  },\n",
    "});\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c427982-fadf-4721-a77e-2465df9fc6bc",
   "metadata": {},
   "source": [
    "**Document writing team tools**\n",
    "\n",
    "Next up, we will give some tools for the doc writing team to use.\n",
    "We define some bare-bones file-access tools below.\n",
    "\n",
    "Note that this gives the agents access to your file-system, which can be unsafe. We also haven't optimized the tool descriptions for performance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f20a18ca-2709-4c12-84f3-88678591a9fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "import * as d3 from \"d3\";\n",
    "import { createCanvas } from \"https://deno.land/x/skia_canvas/mod.ts\";\n",
    "\n",
    "const WORKING_DIRECTORY = Deno.makeTempDirSync();\n",
    "\n",
    "const createOutlineTool = new DynamicStructuredTool({\n",
    "  name: \"create_outline\",\n",
    "  description: \"Create and save an outline.\",\n",
    "  schema: z.object({\n",
    "    points: z\n",
    "      .array(z.string())\n",
    "      .nonempty(\"List of main points or sections must not be empty.\"),\n",
    "    file_name: z.string(),\n",
    "  }),\n",
    "  func: async ({ points, file_name }) => {\n",
    "    const filePath = `${WORKING_DIRECTORY}/${file_name}`;\n",
    "    const data = points\n",
    "      .map((point, index) => `${index + 1}. ${point}\\n`)\n",
    "      .join(\"\");\n",
    "    await Deno.writeTextFile(filePath, data);\n",
    "    return `Outline saved to ${file_name}`;\n",
    "  },\n",
    "});\n",
    "\n",
    "const readDocumentTool = new DynamicStructuredTool({\n",
    "  name: \"read_document\",\n",
    "  description: \"Read the specified document.\",\n",
    "  schema: z.object({\n",
    "    file_name: z.string(),\n",
    "    start: z.number().optional(),\n",
    "    end: z.number().optional(),\n",
    "  }),\n",
    "  func: async ({ file_name, start, end }) => {\n",
    "    const filePath = `${WORKING_DIRECTORY}/${file_name}`;\n",
    "    const data = await Deno.readTextFile(filePath);\n",
    "    const lines = data.split(\"\\n\");\n",
    "    return lines.slice(start ?? 0, end).join(\"\\n\");\n",
    "  },\n",
    "});\n",
    "\n",
    "const writeDocumentTool = new DynamicStructuredTool({\n",
    "  name: \"write_document\",\n",
    "  description: \"Create and save a text document.\",\n",
    "  schema: z.object({\n",
    "    content: z.string(),\n",
    "    file_name: z.string(),\n",
    "  }),\n",
    "  func: async ({ content, file_name }) => {\n",
    "    const filePath = `${WORKING_DIRECTORY}/${file_name}`;\n",
    "    await Deno.writeTextFile(filePath, content);\n",
    "    return `Document saved to ${file_name}`;\n",
    "  },\n",
    "});\n",
    "\n",
    "const editDocumentTool = new DynamicStructuredTool({\n",
    "  name: \"edit_document\",\n",
    "  description: \"Edit a document by inserting text at specific line numbers.\",\n",
    "  schema: z.object({\n",
    "    file_name: z.string(),\n",
    "    inserts: z.record(z.number(), z.string()),\n",
    "  }),\n",
    "  func: async ({ file_name, inserts }) => {\n",
    "    const filePath = `${WORKING_DIRECTORY}/${file_name}`;\n",
    "    const data = await Deno.readTextFile(filePath);\n",
    "    let lines = data.split(\"\\n\");\n",
    "\n",
    "    const sortedInserts = Object.entries(inserts).sort(\n",
    "      ([a], [b]) => parseInt(a) - parseInt(b)\n",
    "    );\n",
    "\n",
    "    for (const [line_number_str, text] of sortedInserts) {\n",
    "      const line_number = parseInt(line_number_str);\n",
    "      if (1 <= line_number && line_number <= lines.length + 1) {\n",
    "        lines.splice(line_number - 1, 0, text);\n",
    "      } else {\n",
    "        return `Error: Line number ${line_number} is out of range.`;\n",
    "      }\n",
    "    }\n",
    "\n",
    "    await Deno.writeTextFile(filePath, lines.join(\"\\n\"));\n",
    "    return `Document edited and saved to ${file_name}`;\n",
    "  },\n",
    "});\n",
    "\n",
    "const chartTool = new DynamicStructuredTool({\n",
    "  name: \"generate_bar_chart\",\n",
    "  description:\n",
    "    \"Generates a bar chart from an array of data points using D3.js and displays it for the user.\",\n",
    "  schema: z.object({\n",
    "    data: z\n",
    "      .object({\n",
    "        label: z.string(),\n",
    "        value: z.number(),\n",
    "      })\n",
    "      .array(),\n",
    "  }),\n",
    "  func: async ({data}) => {\n",
    "    // const data = input.data;\n",
    "    const width = 500;\n",
    "    const height = 500;\n",
    "    const margin = { top: 20, right: 30, bottom: 30, left: 40 };\n",
    "\n",
    "    const canvas = createCanvas(width, height);\n",
    "    const ctx = canvas.getContext(\"2d\");\n",
    "\n",
    "    const x = d3\n",
    "      .scaleBand()\n",
    "      .domain(data.map((d) => d.label))\n",
    "      .range([margin.left, width - margin.right])\n",
    "      .padding(0.1);\n",
    "\n",
    "    const y = d3\n",
    "      .scaleLinear()\n",
    "      .domain([0, d3.max(data, (d) => d.value)])\n",
    "      .nice()\n",
    "      .range([height - margin.bottom, margin.top]);\n",
    "\n",
    "    const colorPalette = [\n",
    "      \"#e6194B\",\n",
    "      \"#3cb44b\",\n",
    "      \"#ffe119\",\n",
    "      \"#4363d8\",\n",
    "      \"#f58231\",\n",
    "      \"#911eb4\",\n",
    "      \"#42d4f4\",\n",
    "      \"#f032e6\",\n",
    "      \"#bfef45\",\n",
    "      \"#fabebe\",\n",
    "    ];\n",
    "\n",
    "    data.forEach((d, idx) => {\n",
    "      ctx.fillStyle = colorPalette[idx % colorPalette.length];\n",
    "      ctx.fillRect(\n",
    "        x(d.label),\n",
    "         y(d.value),\n",
    "        x.bandwidth(),\n",
    "        height - margin.bottom - y(d.value),\n",
    "      );\n",
    "    });\n",
    "\n",
    "    ctx.beginPath();\n",
    "    ctx.strokeStyle = \"black\";\n",
    "    ctx.moveTo(margin.left, height - margin.bottom);\n",
    "    ctx.lineTo(width - margin.right, height - margin.bottom);\n",
    "    ctx.stroke();\n",
    "\n",
    "    ctx.textAlign = \"center\";\n",
    "    ctx.textBaseline = \"top\";\n",
    "    x.domain().forEach((d) => {\n",
    "      const xCoord = x(d) + x.bandwidth() / 2;\n",
    "      ctx.fillText(d, xCoord, height - margin.bottom + 6);\n",
    "    });\n",
    "\n",
    "    ctx.beginPath();\n",
    "    ctx.moveTo(margin.left, height - margin.top);\n",
    "    ctx.lineTo(margin.left, height - margin.bottom);\n",
    "    ctx.stroke();\n",
    "\n",
    "    ctx.textAlign = \"right\";\n",
    "    ctx.textBaseline = \"middle\";\n",
    "    const ticks = y.ticks();\n",
    "    ticks.forEach((d) => {\n",
    "      const yCoord = y(d); // height - margin.bottom - y(d);\n",
    "      ctx.moveTo(margin.left, yCoord);\n",
    "      ctx.lineTo(margin.left - 6, yCoord);\n",
    "      ctx.stroke();\n",
    "      ctx.fillText(d, margin.left - 8, yCoord);\n",
    "    });\n",
    "\n",
    "    await Deno.jupyter.display(canvas);\n",
    "    return \"Chart has been generated and displayed to the user!\";\n",
    "  },\n",
    "});"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "b83582a2-1a8b-4017-a069-00d8af0b52f5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[32m\"Document saved to hello.txt\"\u001b[39m"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// Example invocation\n",
    "await writeDocumentTool.invoke({content: \"Hello from LangGraph!\", file_name: \"hello.txt\"});"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "8ecf26c2-c908-4b10-bbf0-f57aa65a6c71",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[32m\"Hello from LangGraph!\"\u001b[39m"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "await readDocumentTool.invoke({file_name: \"hello.txt\"});"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "2cbb7525-e113-40cf-8271-147d1e4b137a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "\u001b[32m\"Chart has been generated and displayed to the user!\"\u001b[39m"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "await chartTool.invoke({data: [{label: \"People who like graphs\", value: 5000}, {label: \"People who like LangGraph\", value: 10000}]});"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "504ee1c6-2b6a-439d-9046-df54e1e15698",
   "metadata": {},
   "source": [
    "## Helper Utilities\n",
    "\n",
    "We are going to create a few utility functions to make it more concise when we want to:\n",
    "\n",
    "1. Create a worker agent.\n",
    "2. Create a supervisor for the sub-graph.\n",
    "\n",
    "These will simplify the graph compositional code at the end for us so it's easier to see what's going on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "e09fb60f-1aac-455b-b67d-8d2e4ccfd747",
   "metadata": {},
   "outputs": [],
   "source": [
    "import { AgentExecutor, createOpenAIToolsAgent } from \"langchain/agents\";\n",
    "import { HumanMessage } from \"@langchain/core/messages\";\n",
    "import { ChatPromptTemplate, MessagesPlaceholder } from \"@langchain/core/prompts\";\n",
    "import { JsonOutputToolsParser } from \"langchain/output_parsers\";\n",
    "import { ChatOpenAI } from \"@langchain/openai\";\n",
    "import { Runnable } from \"@langchain/core/runnables\";\n",
    "import { BaseTool } from \"@langchain/core/tools\";\n",
    "\n",
    "async function createAgent(\n",
    "  llm: ChatOpenAI, \n",
    "  tools: BaseTool[], \n",
    "  systemPrompt: string\n",
    "): Promise<Runnable> {\n",
    "  const combinedPrompt = (\n",
    "    systemPrompt + \n",
    "    \"\\nWork autonomously according to your specialty, using the tools available to you.\" + \n",
    "        \" Do not ask for clarification.\" +\n",
    "      \" Your other team members (and other teams) will collaborate with you with their own specialties.\" +\n",
    "      \" You are chosen for a reason! You are one of the following team members: {team_members}.\"\n",
    "  );\n",
    "  const toolNames = tools.map((t) => t.name).join(\", \");\n",
    "  const prompt = await ChatPromptTemplate.fromMessages([\n",
    "    [\"system\", combinedPrompt],\n",
    "    new MessagesPlaceholder(\"messages\"),\n",
    "    new MessagesPlaceholder(\"agent_scratchpad\"),\n",
    "    [\n",
    "      \"system\", \n",
    "      [\n",
    "        \"Supervisor instructions: {instructions}\\n\" +\n",
    "        `Remember, you individually can only use these tools: ${toolNames}`+\n",
    "        \"\\n\\nEnd if you have already completed the requested task. Communicate the work completed.\" \n",
    "      ].join(\"\\n\")\n",
    "    ],\n",
    "  ]);\n",
    "  const agent = await createOpenAIToolsAgent({ llm, tools, prompt });\n",
    "  return new AgentExecutor({ agent, tools });\n",
    "}\n",
    "\n",
    "async function runAgentNode(\n",
    "  { state, agent, name }: { state: any, agent: AgentExecutor, name: string }\n",
    ") {\n",
    "  const result = await agent.invoke(state);\n",
    "  return {\n",
    "    messages: [\n",
    "      new HumanMessage({ content: result.output, name }),\n",
    "    ]\n",
    "  };\n",
    "}\n",
    "\n",
    "async function createTeamSupervisor(\n",
    "  llm: ChatOpenAI,\n",
    "  systemPrompt: string, \n",
    "  members: string[]\n",
    "): Promise<Runnable> {\n",
    "  const options = [\"FINISH\", ...members];\n",
    "  const functionDef = {\n",
    "    name: \"route\",\n",
    "    description: \"Select the next role.\",\n",
    "    parameters: {\n",
    "      title: \"routeSchema\",\n",
    "      type: \"object\",\n",
    "      properties: {\n",
    "        reasoning: {\n",
    "          title: \"Reasoning\",\n",
    "          type: \"string\",\n",
    "        },\n",
    "        next: {\n",
    "          title: \"Next\",\n",
    "          anyOf: [\n",
    "            { enum: options },\n",
    "          ],\n",
    "        },\n",
    "        instructions: {\n",
    "          title: \"Instructions\",\n",
    "          type: \"string\",\n",
    "          description: \"The specific instructions of the sub-task the next role should accomplish.\",\n",
    "        },\n",
    "      },\n",
    "      required: [\"reasoning\", \"next\", \"instructions\"],\n",
    "    },\n",
    "  };\n",
    "  const toolDef = {\n",
    "    type: \"function\",\n",
    "    function: functionDef,\n",
    "  };\n",
    "  let prompt = await ChatPromptTemplate.fromMessages([\n",
    "    [\"system\", systemPrompt],\n",
    "    new MessagesPlaceholder(\"messages\"),\n",
    "    [\n",
    "      \"system\",\n",
    "      \"Given the conversation above, who should act next? Or should we FINISH? Select one of: {options}\",\n",
    "    ],\n",
    "  ])\n",
    "  prompt = await prompt.partial({ options: options.join(\", \"), team_members: members.join(\", \") });\n",
    "\n",
    "  const supervisor = prompt\n",
    "    .pipe(llm.bind({\n",
    "      tools: [toolDef],\n",
    "      tool_choice: {\"type\": \"function\", \"function\": {\"name\": \"route\"}}\n",
    "    }))\n",
    "    .pipe(new JsonOutputToolsParser())\n",
    "    // select the first one\n",
    "    .pipe((x) => ({\n",
    "      next: x[0].args.next,\n",
    "      instructions: x[0].args.instructions,\n",
    "    }));\n",
    "  \n",
    "  return supervisor; \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00282b1f-bb4d-4ee7-9bae-e8e6f586f12e",
   "metadata": {},
   "source": [
    "## Define Agent Teams\n",
    "\n",
    "Now we can get to define our hierachical teams. \"Choose your player!\"\n",
    "\n",
    "### Research Team\n",
    "\n",
    "The research team will have a search agent and a web scraping \"research_agent\" as the two worker nodes. Let's create those, as well as the team supervisor. (Note: If you are running deno in a jupyter notebook, the web scraper won't work out of the box. We have commented out this code to accomodate this challenge)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "952d334b-19cf-4014-bd65-79235c3c10e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "import { BaseMessage } from \"@langchain/core/messages\";\n",
    "import { ChatOpenAI } from \"@langchain/openai\";\n",
    "\n",
    "// Define the ResearchTeamState type\n",
    "interface ResearchTeamState {\n",
    "  messages: BaseMessage[];\n",
    "  team_members: string[];\n",
    "  next: string;\n",
    "  instructions: string\n",
    "}\n",
    "\n",
    "// This defines the agent state for the research team\n",
    "const researchTeamState: ResearchTeamState = {\n",
    "  messages: {\n",
    "    value: (x: BaseMessage[], y: BaseMessage[]) => x.concat(y),\n",
    "    default: () => [],\n",
    "  },\n",
    "  team_members: [],\n",
    "  next: \"initialValueForNext\",\n",
    "  instructions: \"Solve the human's question.\",\n",
    "};\n",
    "\n",
    "const llm = new ChatOpenAI({modelName: \"gpt-4-1106-preview\"});\n",
    "\n",
    "// Assuming createAgent and createTeamSupervisor are the same functions you defined earlier\n",
    "const searchAgent = await createAgent(\n",
    "  llm,\n",
    "  [tavilyTool],\n",
    "  \"You are a research assistant who can search for up-to-date info using the tavily search engine.\"\n",
    ");\n",
    "const searchNode = (state: ResearchTeamState) => {\n",
    "  return runAgentNode({ state, agent: searchAgent, name: \"Search\" });\n",
    "};\n",
    "\n",
    "// Uncomment if you have your import map set up correctly\n",
    "// const researchAgent = await createAgent(\n",
    "//   llm,\n",
    "//   [scrapeWebpages],\n",
    "//   \"You are a research assistant who can scrape specified urls for more detailed information using the scrapeWebpages function.\"\n",
    "// );\n",
    "// const researchNode = (state: ResearchTeamState) =>\n",
    "//   agentNode({ state, agent: researchAgent, name: \"Web Scraper\" });\n",
    "\n",
    "const supervisorAgent = await createTeamSupervisor(\n",
    "  llm,\n",
    "  \"You are a supervisor tasked with managing a conversation between the\" +\n",
    "    \" following workers:  {team_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\\n\" + \n",
    "    \" Select strategically to minimize the number of steps taken.\",\n",
    "      [\"Search\"] // , \"Web Scraper\"]\n",
    ");\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b01c6ee8-a461-4081-8a97-a3a06ec0f994",
   "metadata": {},
   "source": [
    "Now that we've created the necessary components, defining their interactions is easy. Add the nodes to the team graph, and define the edges, which determine the transition criteria."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "1a7a1260-d9f6-4011-b2b1-13fab5126997",
   "metadata": {},
   "outputs": [],
   "source": [
    "import { StateGraph, END } from \"@langchain/langgraph\";\n",
    "\n",
    "const researchGraph = new StateGraph({\n",
    "  channels: researchTeamState,\n",
    "});\n",
    "\n",
    "researchGraph.addNode(\"Search\", searchNode);\n",
    "researchGraph.addNode(\"supervisor\", supervisorAgent);\n",
    "\n",
    "// Define the control flow\n",
    "researchGraph.addEdge(\"Search\", \"supervisor\");\n",
    "researchGraph.addConditionalEdges(\n",
    "  \"supervisor\",\n",
    "  ((x) => x.next),\n",
    "  {\n",
    "    Search: \"Search\",\n",
    "    FINISH: END\n",
    "  }\n",
    ");\n",
    "\n",
    "researchGraph.setEntryPoint(\"supervisor\");\n",
    "const researchChain = researchGraph.compile();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a75b4355-f130-40b3-b6dd-5f36296c6e81",
   "metadata": {},
   "source": [
    "Since each team is itself a complete computational graph, you can directly query it like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "57e3c36b-024b-46f8-bb9b-0b46b4c5b79e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  supervisor: {\n",
      "    next: \"Search\",\n",
      "    instructions: \"Please find the current price of a Big Mac in Argentina.\"\n",
      "  }\n",
      "}\n",
      "----\n",
      "{\n",
      "  Search: {\n",
      "    messages: [\n",
      "      HumanMessage {\n",
      "        lc_serializable: true,\n",
      "        lc_kwargs: {\n",
      "          content: \"The current price of a Big Mac in Argentina is 6.11 USD as of December 2023.\",\n",
      "          name: \"Search\",\n",
      "          additional_kwargs: {}\n",
      "        },\n",
      "        lc_namespace: [ \"langchain_core\", \"messages\" ],\n",
      "        content: \"The current price of a Big Mac in Argentina is 6.11 USD as of December 2023.\",\n",
      "        name: \"Search\",\n",
      "        additional_kwargs: {}\n",
      "      }\n",
      "    ]\n",
      "  }\n",
      "}\n",
      "----\n",
      "{\n",
      "  supervisor: {\n",
      "    next: \"FINISH\",\n",
      "    instructions: \"The information requested by the user has been provided.\"\n",
      "  }\n",
      "}\n",
      "----\n"
     ]
    }
   ],
   "source": [
    "const streamResults = researchChain.stream(\n",
    "  { messages: [new HumanMessage(\"What's the price of a big mac in Argentina?\")] },\n",
    "  { recursionLimit: 100 },\n",
    ")\n",
    "for await (const output of await streamResults) {\n",
    "  if (!output?.__end__){\n",
    "    console.log(output);\n",
    "    console.log('----');\n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e41222e",
   "metadata": {},
   "source": [
    "You can [click here](https://smith.langchain.com/public/6d9bf294-960d-407f-81fe-2dc1838add4f/r) to see a LangSmith trace of the above run."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "749b99ab-f6f0-4c5d-a90b-10102465d186",
   "metadata": {},
   "source": [
    "### Document Writing Team\n",
    "\n",
    "Create the document writing team below using a similar approach. This time, we will give each agent access to different file-writing tools.\n",
    "\n",
    "Note that we are giving file-system access to our agent here, which is not safe in all cases. \n",
    "\n",
    "For the doc writing team, each agent will be writing to the same workspace. We don't want them to waste time checking which files are available, so we will force a call to a \"prelude\" function before an agent is invoked to populate the\n",
    "prompt template with the current directory's contents."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "42437e7f-b3e8-481b-bed8-472e8179ab15",
   "metadata": {},
   "outputs": [],
   "source": [
    "import { RunnableLambda } from \"@langchain/core/runnables\";\n",
    "\n",
    "const prelude = new RunnableLambda({\n",
    "  func: async (state) => {\n",
    "    let writtenFiles: string[] = [];\n",
    "    if (\n",
    "      !(await Deno.stat(WORKING_DIRECTORY)\n",
    "        .then(() => true)\n",
    "        .catch(() => false))\n",
    "    ) {\n",
    "      await Deno.mkdir(WORKING_DIRECTORY, { recursive: true });\n",
    "    }\n",
    "    try {\n",
    "      for await (const dirEntry of Deno.readDir(WORKING_DIRECTORY)) {\n",
    "        writtenFiles.push(dirEntry.name);\n",
    "      }\n",
    "    } catch (error) {\n",
    "      console.error(error);\n",
    "    }\n",
    "    const filesList =\n",
    "      writtenFiles.length > 0\n",
    "        ? \"\\nBelow are files your team has written to the directory:\\n\" +\n",
    "          writtenFiles.map((f) => ` - ${f}`).join(\"\\n\")\n",
    "        : \"No files written.\";\n",
    "    return { ...state, current_files: filesList };\n",
    "  },\n",
    "});\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c82a6ed1-c334-48b5-8122-aa7f1e6f53ad",
   "metadata": {},
   "source": [
    "The doc writing state then is similar to that of the research team. We will add the additional `current_files` state variable\n",
    "to reflect the shared workspace."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "274f01f2-6d5a-4c99-b451-c62f80dafb7a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import { BaseMessage } from \"@langchain/core/messages\";\n",
    "\n",
    "// Define the DocWritingState type\n",
    "interface DocWritingState {\n",
    "  messages: BaseMessage[];\n",
    "  team_members: string;\n",
    "  next: string;\n",
    "  current_files: string;\n",
    "  instructions: string;\n",
    "}\n",
    "\n",
    "// This defines the agent state for the document writing team\n",
    "const docWritingState: DocWritingState = {\n",
    "  messages: {\n",
    "    value: (x: BaseMessage[], y: BaseMessage[]) => x.concat(y),\n",
    "    default: () => [],\n",
    "  },\n",
    "  team_members: \"DocWriter, NoteTaker, ChartGenerator\",\n",
    "  next: \"Doc Writer\",\n",
    "  current_files: \"No files written.\",\n",
    "  instructions: \"Resolve the user's request.\"\n",
    "};\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2871d192-05be-4996-868c-4cb0500b4928",
   "metadata": {},
   "source": [
    "The team will be comprised of three agents:\n",
    "- A doc writing agent\n",
    "- A note taking agent\n",
    "- A chart generating agent\n",
    "\n",
    "Note this isn't optimized for performance, but is illustrative of the pattern."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "1bcdbf44-9481-430c-8429-fa142ed8a626",
   "metadata": {},
   "outputs": [],
   "source": [
    "const llm = new ChatOpenAI({modelName: \"gpt-4-1106-preview\"});\n",
    "\n",
    "const docWriterAgent = await createAgent(\n",
    "  llm,\n",
    "  [writeDocumentTool, editDocumentTool, readDocumentTool],\n",
    "  \"You are an expert writing a research document.\\nBelow are files currently in your directory:\\n{current_files}\"\n",
    ");\n",
    "const contextAwareDocWriterAgent = prelude.pipe(docWriterAgent);\n",
    "const docWritingNode = (\n",
    "  state: DocWritingState,\n",
    "  config: RunnableConfig\n",
    ") => runAgentNode({\n",
    "  state,\n",
    "  agent: contextAwareDocWriterAgent,\n",
    "  name: \"DocWriter\",\n",
    "});\n",
    "\n",
    "const noteTakingAgent = await createAgent(\n",
    "  llm,\n",
    "  [createOutlineTool, readDocumentTool],\n",
    "  \"You are an expert senior researcher tasked with writing a paper outline and\" +\n",
    "    \" taking notes to craft a perfect paper.{current_files}\"\n",
    ");\n",
    "const contextAwareNoteTakingAgent = prelude.pipe(noteTakingAgent);\n",
    "const noteTakingNode = (\n",
    "  state: DocWritingState\n",
    ") => runAgentNode({\n",
    "  state,\n",
    "  agent: contextAwareNoteTakingAgent,\n",
    "  name: \"NoteTaker\",\n",
    "});\n",
    "\n",
    "const chartGeneratingAgent = await createAgent(\n",
    "  llm,\n",
    "  [readDocumentTool, chartTool],\n",
    "  \"You are a data viz expert tasked with generating charts for a research project.\" +\n",
    "    \"{current_files}\"\n",
    ");\n",
    "const contextAwareChartGeneratingAgent = prelude.pipe(chartGeneratingAgent);\n",
    "const chartGeneratingNode = async (\n",
    "  state: DocWritingState,\n",
    "  config: RunnableConfig\n",
    ") => runAgentNode({\n",
    "  state,\n",
    "  agent: contextAwareChartGeneratingAgent,\n",
    "  name: \"ChartGenerator\",\n",
    "});\n",
    "\n",
    "const docTeamMembers = [\"DocWriter\", \"NoteTaker\", \"ChartGenerator\"];\n",
    "const docWritingSupervisor = await createTeamSupervisor(\n",
    "  llm,\n",
    "  \"You are a supervisor tasked with managing a conversation between the\" +\n",
    "    \" following workers:  {team_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\\n\" + \n",
    "    \" Select strategically to minimize the number of steps taken.\",\n",
    "  docTeamMembers\n",
    ");\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aee2cd9b-29aa-458e-903d-4e49179e5d59",
   "metadata": {},
   "source": [
    "With the objects themselves created, we can form the graph. Start by creating the \"nodes\", which will do the actual work,\n",
    "then define the edges to control how the program will progress."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "9c5c644f-8966-4d2e-98d2-80d73520e9fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "// Create the graph here:\n",
    "// Note that we have unrolled the loop for the sake of this doc\n",
    "const authoringGraph = new StateGraph({\n",
    "  channels: docWritingState\n",
    "});\n",
    "\n",
    "authoringGraph.addNode(\"Doc Writer\", docWritingNode);\n",
    "authoringGraph.addNode(\"Note Taker\", noteTakingNode);\n",
    "authoringGraph.addNode(\"Chart Generator\", chartGeneratingNode);\n",
    "authoringGraph.addNode(\"supervisor\", docWritingSupervisor);\n",
    "\n",
    "// Add the edges that always occur\n",
    "authoringGraph.addEdge(\"Doc Writer\", \"supervisor\");\n",
    "authoringGraph.addEdge(\"Note Taker\", \"supervisor\");\n",
    "authoringGraph.addEdge(\"Chart Generator\", \"supervisor\");\n",
    "\n",
    "// Add the edges where routing applies\n",
    "authoringGraph.addConditionalEdges(\n",
    "  \"supervisor\",\n",
    "  (x) => x.next,\n",
    "  {\n",
    "    \"DocWriter\": \"Doc Writer\",\n",
    "    \"NoteTaker\": \"Note Taker\",\n",
    "    \"ChartGenerator\": \"Chart Generator\",\n",
    "    \"FINISH\": END\n",
    "  }\n",
    ");\n",
    "\n",
    "authoringGraph.setEntryPoint(\"supervisor\");\n",
    "\n",
    "const enterAuthoringChain = RunnableLambda.from(\n",
    "  ({ messages }) => {\n",
    "    return {\n",
    "      messages: messages,\n",
    "      team_members: [\"Doc Writer\", \"Note Taker\", \"Chart Generator\"]\n",
    "    };\n",
    "  }\n",
    ");\n",
    "const authoringChain = enterAuthoringChain.pipe(authoringGraph.compile());"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "9860fd46-c24d-40a5-a6ba-e8fddcd43369",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  supervisor: {\n",
      "    next: \"DocWriter\",\n",
      "    instructions: \"Write a limerick. The limerick should follow the traditional structure of five lines with a rhyme sc\"... 14 more characters\n",
      "  }\n",
      "}\n",
      "---\n",
      "{\n",
      "  \"Doc Writer\": {\n",
      "    messages: [\n",
      "      HumanMessage {\n",
      "        lc_serializable: true,\n",
      "        lc_kwargs: {\n",
      "          content: 'I have written and saved a limerick to the document named \"limerick.txt\".',\n",
      "          name: \"DocWriter\",\n",
      "          additional_kwargs: {}\n",
      "        },\n",
      "        lc_namespace: [ \"langchain_core\", \"messages\" ],\n",
      "        content: 'I have written and saved a limerick to the document named \"limerick.txt\".',\n",
      "        name: \"DocWriter\",\n",
      "        additional_kwargs: {}\n",
      "      }\n",
      "    ]\n",
      "  }\n",
      "}\n",
      "---\n",
      "{\n",
      "  supervisor: {\n",
      "    next: \"NoteTaker\",\n",
      "    instructions: \"Please extract all characters used in the limerick from the document 'limerick.txt' and tally their \"... 12 more characters\n",
      "  }\n",
      "}\n",
      "---\n",
      "{\n",
      "  \"Note Taker\": {\n",
      "    messages: [\n",
      "      HumanMessage {\n",
      "        lc_serializable: true,\n",
      "        lc_kwargs: {\n",
      "          content: 'I have extracted the limerick from the \"limerick.txt\" file and tallied the occurrences of each chara'... 736 more characters,\n",
      "          name: \"NoteTaker\",\n",
      "          additional_kwargs: {}\n",
      "        },\n",
      "        lc_namespace: [ \"langchain_core\", \"messages\" ],\n",
      "        content: 'I have extracted the limerick from the \"limerick.txt\" file and tallied the occurrences of each chara'... 736 more characters,\n",
      "        name: \"NoteTaker\",\n",
      "        additional_kwargs: {}\n",
      "      }\n",
      "    ]\n",
      "  }\n",
      "}\n",
      "---\n",
      "{\n",
      "  supervisor: {\n",
      "    next: \"ChartGenerator\",\n",
      "    instructions: \"Please create a bar chart representing the frequency of each character's appearance in the limerick \"... 27 more characters\n",
      "  }\n",
      "}\n",
      "---\n"
     ]
    },
    {
     "data": {
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  \"Chart Generator\": {\n",
      "    messages: [\n",
      "      HumanMessage {\n",
      "        lc_serializable: true,\n",
      "        lc_kwargs: {\n",
      "          content: \"The bar chart representing the frequency of each character's appearance in the provided limerick has\"... 136 more characters,\n",
      "          name: \"ChartGenerator\",\n",
      "          additional_kwargs: {}\n",
      "        },\n",
      "        lc_namespace: [ \"langchain_core\", \"messages\" ],\n",
      "        content: \"The bar chart representing the frequency of each character's appearance in the provided limerick has\"... 136 more characters,\n",
      "        name: \"ChartGenerator\",\n",
      "        additional_kwargs: {}\n",
      "      }\n",
      "    ]\n",
      "  }\n",
      "}\n",
      "---\n",
      "{\n",
      "  supervisor: {\n",
      "    next: \"FINISH\",\n",
      "    instructions: \"The conversation has concluded with all tasks completed successfully.\"\n",
      "  }\n",
      "}\n",
      "---\n"
     ]
    }
   ],
   "source": [
    "const resultStream = authoringChain.stream(\n",
    "  { messages: [new HumanMessage(\"Write a limerick and make a bar chart of the characters used.\")] },\n",
    "  { recursionLimit: 100 }\n",
    ");\n",
    "\n",
    "for await (const step of await resultStream) {\n",
    "  if (!step?.__end__){\n",
    "    console.log(step);\n",
    "    console.log(\"---\");\n",
    "  }\n",
    "}\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9dd93a49",
   "metadata": {},
   "source": [
    "You can [click here](https://smith.langchain.com/public/ee1549c6-0095-4806-9259-ead0946503f5/r) to see a representative LangSmith trace of the above run."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4b5b08d-9a9a-474a-94b4-f7aaa8ff19e6",
   "metadata": {},
   "source": [
    "## Add Layers\n",
    "\n",
    "In this design, we are enforcing a top-down planning policy. We've created two graphs already, but we have to decide how to route work between the two.\n",
    "\n",
    "We'll create a _third_ graph to orchestrate the previous two, and add some connectors to define how this top-level state is shared between the different graphs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "4880e573-612f-4d24-97c1-2079382a4a2f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import { BaseMessage } from \"@langchain/core/messages\";\n",
    "import { ChatOpenAI } from \"@langchain/openai\";\n",
    "import { RunnableLambda } from \"@langchain/core/runnables\";\n",
    "\n",
    "// Define the top-level State type\n",
    "interface State {\n",
    "  messages: BaseMessage[];\n",
    "  next: string;\n",
    "  instructions: string;\n",
    "}\n",
    "\n",
    "const llm = new ChatOpenAI({ modelName: \"gpt-4-1106-preview\" });\n",
    "\n",
    "const supervisorNode = await createTeamSupervisor(\n",
    "  llm,\n",
    "  \"You are a supervisor tasked with managing a conversation between the\" +\n",
    "    \" following teams: {team_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\\n\" + \n",
    "    \" Select strategically to minimize the number of steps taken.\",\n",
    "  [\"Research team\", \"Paper writing team\"],\n",
    ");\n",
    "\n",
    "const getMessages = RunnableLambda.from((state: State) => {\n",
    "  return { messages: state.messages }\n",
    "});\n",
    "\n",
    "const joinGraph = RunnableLambda.from((response: any) => {\n",
    "  return {\n",
    "    messages: [response.messages[response.messages.length - 1]]\n",
    "  };\n",
    "});\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d175d163-66b9-4e43-959a-755b977ab655",
   "metadata": {},
   "source": [
    "Now we can finally create the top-level graph below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "42293488-4cbd-4cf4-8b46-53b98b6a1ff6",
   "metadata": {},
   "outputs": [],
   "source": [
    "const superGraph = new StateGraph<State>({\n",
    "  channels: {\n",
    "    messages: {\n",
    "      value: (x: BaseMessage[], y: BaseMessage[]) => x.concat(y),\n",
    "      default: () => [],\n",
    "    },\n",
    "    next: \"Research team\",\n",
    "    instructions: \"Solve the user's request.\"\n",
    "  }\n",
    "});\n",
    "\n",
    "superGraph.addNode(\"Research team\", getMessages.pipe(researchChain).pipe(joinGraph));\n",
    "superGraph.addNode(\"Paper writing team\", getMessages.pipe(authoringChain).pipe(joinGraph));\n",
    "superGraph.addNode(\"supervisor\", supervisorNode);\n",
    "\n",
    "superGraph.addEdge(\"Research team\", \"supervisor\");\n",
    "superGraph.addEdge(\"Paper writing team\", \"supervisor\");\n",
    "superGraph.addConditionalEdges(\n",
    "  \"supervisor\",\n",
    "  (x) => x.next,\n",
    "  {\n",
    "    \"Paper writing team\": \"Paper writing team\",\n",
    "    \"Research team\": \"Research team\",\n",
    "    \"FINISH\": END\n",
    "  }\n",
    ");\n",
    "\n",
    "superGraph.setEntryPoint(\"supervisor\");\n",
    "const compiledSuperGraph = superGraph.compile();"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f901583-5476-44b4-ab6a-7048893dc1ef",
   "metadata": {},
   "source": [
    "With the full graph defined, try invoking it!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "6b8badbf-d728-44bd-a2a7-5b4e587c92fe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  supervisor: {\n",
      "    next: \"Research team\",\n",
      "    instructions: \"Look up a current event that is relevant and can be used as a topic for writing a poem.\"\n",
      "  }\n",
      "}\n",
      "---\n",
      "{\n",
      "  \"Research team\": {\n",
      "    messages: [\n",
      "      HumanMessage {\n",
      "        lc_serializable: true,\n",
      "        lc_kwargs: {\n",
      "          content: \"The task of writing a poem inspired by the recent current event of the Mississippi tornado on April \"... 290 more characters,\n",
      "          name: \"Search\",\n",
      "          additional_kwargs: {}\n",
      "        },\n",
      "        lc_namespace: [ \"langchain_core\", \"messages\" ],\n",
      "        content: \"The task of writing a poem inspired by the recent current event of the Mississippi tornado on April \"... 290 more characters,\n",
      "        name: \"Search\",\n",
      "        additional_kwargs: {}\n",
      "      }\n",
      "    ]\n",
      "  }\n",
      "}\n",
      "---\n",
      "{\n",
      "  supervisor: {\n",
      "    next: \"Paper writing team\",\n",
      "    instructions: \"Plot a bar chart of the distribution of words in the poem written about the Mississippi tornado even\"... 2 more characters\n",
      "  }\n",
      "}\n",
      "---\n"
     ]
    },
    {
     "data": {
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  \"Paper writing team\": {\n",
      "    messages: [\n",
      "      HumanMessage {\n",
      "        lc_serializable: true,\n",
      "        lc_kwargs: {\n",
      "          content: \"The requested task of creating a bar chart that represents the distribution of word frequencies from\"... 104 more characters,\n",
      "          name: \"ChartGenerator\",\n",
      "          additional_kwargs: {}\n",
      "        },\n",
      "        lc_namespace: [ \"langchain_core\", \"messages\" ],\n",
      "        content: \"The requested task of creating a bar chart that represents the distribution of word frequencies from\"... 104 more characters,\n",
      "        name: \"ChartGenerator\",\n",
      "        additional_kwargs: {}\n",
      "      }\n",
      "    ]\n",
      "  }\n",
      "}\n",
      "---\n",
      "{\n",
      "  supervisor: {\n",
      "    next: \"FINISH\",\n",
      "    instructions: \"All parts of the task have been completed, and no further action is needed.\"\n",
      "  }\n",
      "}\n",
      "---\n"
     ]
    }
   ],
   "source": [
    "const resultStream = compiledSuperGraph.stream(\n",
    "  {\n",
    "    messages: [\n",
    "      new HumanMessage(\n",
    "        \"Look up a current event, write a poem about it, then plot a bar chart of the distribution of words therein.\"\n",
    "      )\n",
    "    ],\n",
    "  },\n",
    "  { recursionLimit: 150 }\n",
    ");\n",
    "\n",
    "for await (const step of await resultStream) {\n",
    "  if (!step.__end__) {\n",
    "    console.log(step);\n",
    "    console.log(\"---\");\n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0129279f",
   "metadata": {},
   "source": [
    "As before, you can [click here](https://smith.langchain.com/public/067e1ef5-f48a-4f44-8750-c5ef5da4fdb4/r) to see a LangSmith run of the above graph."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Deno",
   "language": "typescript",
   "name": "deno"
  },
  "language_info": {
   "file_extension": ".ts",
   "mimetype": "text/x.typescript",
   "name": "typescript",
   "nb_converter": "script",
   "pygments_lexer": "typescript",
   "version": "5.3.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}