examples/agent_executor/base.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f725852e-71ef-4615-8cac-011a516fbe72",
   "metadata": {},
   "source": [
    "# Agent Executor From Scratch\n",
    "\n",
    "In this notebook we will go over how to build a basic agent executor from\n",
    "scratch.\n",
    "\n",
    "![diagram](./img/agent-executor-diagram.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0860511-03c2-49bb-937b-035f84142b7e",
   "metadata": {},
   "source": [
    "## Setup¶\n",
    "\n",
    "First we need to install the packages required\n",
    "\n",
    "```bash\n",
    "yarn add langchain @langchain/openai @langchain/langgraph\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f4179ce-48fa-4aaf-a5a1-027b5229be1a",
   "metadata": {},
   "source": [
    "Next, we need to set API keys for OpenAI (the LLM we will use) and Tavily (the\n",
    "search tool we will use)\n",
    "\n",
    "```bash\n",
    "export OPENAI_API_KEY=\n",
    "export TAVILY_API_KEY=\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37943b1c-2b0a-4c09-bfbd-5dc24b839e3c",
   "metadata": {},
   "source": [
    "Optionally, we can set API key for\n",
    "[LangSmith tracing](https://smith.langchain.com/), which will give us\n",
    "best-in-class observability.\n",
    "\n",
    "```bash\n",
    "export LANGCHAIN_TRACING_V2=true\n",
    "export LANGCHAIN_API_KEY=\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5dace4a9-7c9e-4da2-bf7b-e58d0d05581e",
   "metadata": {},
   "source": [
    "## Create the LangChain agent\n",
    "\n",
    "First, we will create the LangChain agent. For more information on LangChain\n",
    "agents, see [this documentation](https://js.langchain.com/docs/modules/agents/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "fd5db1ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "// Deno.env.set(\"OPENAI_API_KEY\", \"YOUR_API_KEY\")\n",
    "// Deno.env.set(\"TAVILY_API_KEY\", \"YOUR_API_KEY\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4499eb16-bca8-4a60-9a3a-2f34ae3f7078",
   "metadata": {},
   "outputs": [],
   "source": [
    "import { pull } from \"langchain/hub\";\n",
    "import { createOpenAIFunctionsAgent } from \"langchain/agents\";\n",
    "import { ChatOpenAI } from \"@langchain/openai\";\n",
    "import { TavilySearchResults } from \"@langchain/community/tools/tavily_search\";\n",
    "import { ChatPromptTemplate } from \"@langchain/core/prompts\";\n",
    "\n",
    "const tools = [new TavilySearchResults({ maxResults: 1 })];\n",
    "\n",
    "// Get the prompt to use - you can modify this!\n",
    "const prompt = await pull<ChatPromptTemplate>(\n",
    "  \"hwchase17/openai-functions-agent\",\n",
    ");\n",
    "\n",
    "// Choose the LLM that will drive the agent\n",
    "const llm = new ChatOpenAI({\n",
    "  modelName: \"gpt-4-1106-preview\",\n",
    "  temperature: 0,\n",
    "});\n",
    "\n",
    "// Construct the OpenAI Functions agent\n",
    "const agentRunnable = await createOpenAIFunctionsAgent({\n",
    "  llm,\n",
    "  tools,\n",
    "  prompt,\n",
    "});"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "972e58b3-fe3c-449d-b3c4-8fa2217afd07",
   "metadata": {},
   "source": [
    "## Define the graph schema\n",
    "\n",
    "We now define the graph state. The state for the traditional LangChain agent has\n",
    "a few attributes:\n",
    "\n",
    "1. `input`: This is the input string representing the main ask from the user,\n",
    "   passed in as input.\n",
    "2. `steps`: This is list of actions and corresponding observations that the\n",
    "   agent takes over time. This is updated each iteration of the agent.\n",
    "3. `agentOutcome`: This is the response from the agent, either an AgentAction or\n",
    "   AgentFinish. The AgentExecutor should finish when this is an AgentFinish,\n",
    "   otherwise it should call the requested tools."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c941fb10-dbe5-4d6a-ab7d-133d01c33cc4",
   "metadata": {},
   "outputs": [],
   "source": [
    "const agentState = {\n",
    "  input: {\n",
    "    value: null,\n",
    "  },\n",
    "  steps: {\n",
    "    value: (x, y) => x.concat(y),\n",
    "    default: () => [],\n",
    "  },\n",
    "  agentOutcome: {\n",
    "    value: null,\n",
    "  },\n",
    "};"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd27b281-cc9a-49c9-be78-8b98a7d905c4",
   "metadata": {},
   "source": [
    "## Define the nodes\n",
    "\n",
    "We now need to define a few different nodes in our graph. In `langgraph`, a node\n",
    "can be either a function or a\n",
    "[runnable](https://js.langchain.com/docs/expression_language/). There are two\n",
    "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\n",
    "   will then execute that action.\n",
    "\n",
    "We will also need to define some edges. Some of these edges may be conditional.\n",
    "The reason they are conditional is that based on the output of a node, one of\n",
    "several paths may be taken. The path that is taken is not known until that node\n",
    "is run (the LLM decides).\n",
    "\n",
    "1. Conditional Edge: after the agent is called, we should either: a. If the\n",
    "   agent said to take an action, then the function to invoke tools should be\n",
    "   called 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\n",
    "   agent to decide what to do next\n",
    "\n",
    "Let's define the nodes, as well as a function to decide how what conditional\n",
    "edge to take."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d61a970d-edf4-4eef-9678-28bab7c72331",
   "metadata": {},
   "outputs": [],
   "source": [
    "import { BaseMessage } from \"@langchain/core/messages\";\n",
    "import { AgentAction, AgentFinish, AgentStep } from \"@langchain/core/agents\";\n",
    "import { ToolExecutor } from \"@langchain/langgraph/prebuilt\";\n",
    "import type { RunnableConfig } from \"@langchain/core/runnables\";\n",
    "\n",
    "interface AgentStateBase {\n",
    "  agentOutcome?: AgentAction | AgentFinish;\n",
    "  steps: Array<AgentStep>;\n",
    "}\n",
    "\n",
    "interface AgentState extends AgentStateBase {\n",
    "  input: string;\n",
    "  chatHistory?: BaseMessage[];\n",
    "}\n",
    "\n",
    "const toolExecutor = new ToolExecutor({\n",
    "  tools,\n",
    "});\n",
    "\n",
    "// Define logic that will be used to determine which conditional edge to go down\n",
    "const shouldContinue = (data: AgentState) => {\n",
    "  if (data.agentOutcome && \"returnValues\" in data.agentOutcome) {\n",
    "    return \"end\";\n",
    "  }\n",
    "  return \"continue\";\n",
    "};\n",
    "\n",
    "const runAgent = async (data: AgentState, config?: RunnableConfig) => {\n",
    "  const agentOutcome = await agentRunnable.invoke(data, config);\n",
    "  return {\n",
    "    agentOutcome,\n",
    "  };\n",
    "};\n",
    "\n",
    "const executeTools = async (data: AgentState, config?: RunnableConfig) => {\n",
    "  const agentAction = data.agentOutcome;\n",
    "  if (!agentAction || \"returnValues\" in agentAction) {\n",
    "    throw new Error(\"Agent has not been run yet\");\n",
    "  }\n",
    "  const output = await toolExecutor.invoke(agentAction, config);\n",
    "  return {\n",
    "    steps: [{ action: agentAction, observation: JSON.stringify(output) }],\n",
    "  };\n",
    "};"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0b211f4-0c5c-4792-b18d-cd70907c71e7",
   "metadata": {},
   "source": [
    "## Define the graph\n",
    "\n",
    "We can now put it all together and define the graph!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "c4054dde-4618-49b7-998a-daa0c1d6d6c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "import { RunnableLambda } from \"@langchain/core/runnables\";\n",
    "import { END, StateGraph } from \"@langchain/langgraph\";\n",
    "\n",
    "// Define a new graph\n",
    "const workflow = new StateGraph({\n",
    "  channels: agentState,\n",
    "});\n",
    "\n",
    "// Define the two nodes we will cycle between\n",
    "workflow.addNode(\"agent\", new RunnableLambda({ func: runAgent }));\n",
    "workflow.addNode(\"action\", new RunnableLambda({ func: executeTools }));\n",
    "\n",
    "// Set the entrypoint as `agent`\n",
    "// This means that this node is the first one called\n",
    "workflow.setEntryPoint(\"agent\");\n",
    "\n",
    "// We now add a conditional edge\n",
    "workflow.addConditionalEdges(\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",
    "  shouldContinue,\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.addEdge(\"action\", \"agent\");\n",
    "\n",
    "const app = workflow.compile();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "214ae46e-c297-465d-86db-2b0312ed3530",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  agent: {\n",
      "    agentOutcome: {\n",
      "      tool: \"tavily_search_results_json\",\n",
      "      toolInput: { input: \"current weather in San Francisco\" },\n",
      "      log: 'Invoking \"tavily_search_results_json\" with {\"input\":\"current weather in San Francisco\"}\\n',\n",
      "      messageLog: [\n",
      "        AIMessage {\n",
      "          lc_serializable: true,\n",
      "          lc_kwargs: [Object],\n",
      "          lc_namespace: [Array],\n",
      "          content: \"\",\n",
      "          name: undefined,\n",
      "          additional_kwargs: [Object]\n",
      "        }\n",
      "      ]\n",
      "    }\n",
      "  }\n",
      "}\n",
      "----\n",
      "\n",
      "{\n",
      "  action: {\n",
      "    steps: [\n",
      "      {\n",
      "        action: {\n",
      "          tool: \"tavily_search_results_json\",\n",
      "          toolInput: [Object],\n",
      "          log: 'Invoking \"tavily_search_results_json\" with {\"input\":\"current weather in San Francisco\"}\\n',\n",
      "          messageLog: [Array]\n",
      "        },\n",
      "        observation: '\"[{\\\\\"title\\\\\":\\\\\"Weather in San Francisco\\\\\",\\\\\"url\\\\\":\\\\\"https://www.weatherapi.com/\\\\\",\\\\\"content\\\\\":\\\\\"Weat'... 839 more characters\n",
      "      }\n",
      "    ]\n",
      "  }\n",
      "}\n",
      "----\n",
      "\n",
      "{\n",
      "  agent: {\n",
      "    agentOutcome: {\n",
      "      returnValues: {\n",
      "        output: \"The current weather in San Francisco is partly cloudy with a temperature of 11.7°C (53.1°F). The win\"... 278 more characters\n",
      "      },\n",
      "      log: \"The current weather in San Francisco is partly cloudy with a temperature of 11.7°C (53.1°F). The win\"... 278 more characters\n",
      "    }\n",
      "  }\n",
      "}\n",
      "----\n",
      "\n",
      "{\n",
      "  __end__: {\n",
      "    input: \"what is the weather in sf\",\n",
      "    steps: [\n",
      "      {\n",
      "        action: {\n",
      "          tool: \"tavily_search_results_json\",\n",
      "          toolInput: [Object],\n",
      "          log: 'Invoking \"tavily_search_results_json\" with {\"input\":\"current weather in San Francisco\"}\\n',\n",
      "          messageLog: [Array]\n",
      "        },\n",
      "        observation: '\"[{\\\\\"title\\\\\":\\\\\"Weather in San Francisco\\\\\",\\\\\"url\\\\\":\\\\\"https://www.weatherapi.com/\\\\\",\\\\\"content\\\\\":\\\\\"Weat'... 839 more characters\n",
      "      }\n",
      "    ],\n",
      "    agentOutcome: {\n",
      "      returnValues: {\n",
      "        output: \"The current weather in San Francisco is partly cloudy with a temperature of 11.7°C (53.1°F). The win\"... 278 more characters\n",
      "      },\n",
      "      log: \"The current weather in San Francisco is partly cloudy with a temperature of 11.7°C (53.1°F). The win\"... 278 more characters\n",
      "    }\n",
      "  }\n",
      "}\n",
      "----\n",
      "\n"
     ]
    }
   ],
   "source": [
    "const inputs = { input: \"what is the weather in sf\" };\n",
    "for await (const s of await app.stream(inputs)) {\n",
    "  console.log(s);\n",
    "  console.log(\"----\\n\");\n",
    "}"
   ]
  }
 ],
 "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
}