cr

docs/modules/agents/agents/custom_agent.ipynb

@@ -12,48 +12,26 @@
     "An agent consists of three parts:\n",
     "    \n",
     "    - Tools: The tools the agent has available to use.\n",
-    "    - LLMChain: The LLMChain that produces the text that is parsed in a certain way to determine which action to take.\n",
-    "    - The agent class itself: this parses the output of the LLMChain to determin which action to take.\n",
+    "    - The agent class itself: this decides which action to take.\n",
     "        \n",
     "        \n",
-    "In this notebook we walk through two types of custom agents. The first type shows how to create a custom LLMChain, but still use an existing agent class to parse the output. The second shows how to create a custom agent class."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "6064f080",
-   "metadata": {},
-   "source": [
-    "### Custom LLMChain\n",
-    "\n",
-    "The first way to create a custom agent is to use an existing Agent class, but use a custom LLMChain. This is the simplest way to create a custom Agent. It is highly reccomended that you work with the `ZeroShotAgent`, as at the moment that is by far the most generalizable one. \n",
-    "\n",
-    "Most of the work in creating the custom LLMChain comes down to the prompt. Because we are using an existing agent class to parse the output, it is very important that the prompt say to produce text in that format. Additionally, we currently require an `agent_scratchpad` input variable to put notes on previous actions and observations. This should almost always be the final part of the prompt. However, besides those instructions, you can customize the prompt as you wish.\n",
-    "\n",
-    "To ensure that the prompt contains the appropriate instructions, we will utilize a helper method on that class. The helper method for the `ZeroShotAgent` takes the following arguments:\n",
-    "\n",
-    "- tools: List of tools the agent will have access to, used to format the prompt.\n",
-    "- prefix: String to put before the list of tools.\n",
-    "- suffix: String to put after the list of tools.\n",
-    "- input_variables: List of input variables the final prompt will expect.\n",
-    "\n",
-    "For this exercise, we will give our agent access to Google Search, and we will customize it in that we will have it answer as a pirate."
+    "In this notebook we walk through how to create a custom agent."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 1,
    "id": "9af9734e",
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.agents import ZeroShotAgent, Tool, AgentExecutor\n",
-    "from langchain import OpenAI, SerpAPIWrapper, LLMChain"
+    "from langchain.agents import Tool, AgentExecutor\n",
+    "from langchain import OpenAI, SerpAPIWrapper"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 2,
    "id": "becda2a1",
    "metadata": {},
    "outputs": [],
@@ -63,110 +41,83 @@
     "    Tool(\n",
     "        name = \"Search\",\n",
     "        func=search.run,\n",
-    "        description=\"useful for when you need to answer questions about current events\"\n",
+    "        description=\"useful for when you need to answer questions about current events\",\n",
+    "        return_direct=True\n",
     "    )\n",
     "]"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
-   "id": "339b1bb8",
+   "execution_count": 3,
+   "id": "eca724fc",
    "metadata": {},
    "outputs": [],
    "source": [
-    "prefix = \"\"\"Answer the following questions as best you can, but speaking as a pirate might speak. You have access to the following tools:\"\"\"\n",
-    "suffix = \"\"\"Begin! Remember to speak as a pirate when giving your final answer. Use lots of \"Args\"\n",
-    "\n",
-    "Question: {input}\n",
-    "{agent_scratchpad}\"\"\"\n",
-    "\n",
-    "prompt = ZeroShotAgent.create_prompt(\n",
-    "    tools, \n",
-    "    prefix=prefix, \n",
-    "    suffix=suffix, \n",
-    "    input_variables=[\"input\", \"agent_scratchpad\"]\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "59db7b58",
-   "metadata": {},
-   "source": [
-    "In case we are curious, we can now take a look at the final prompt template to see what it looks like when its all put together."
+    "from langchain.agents.agent import BaseAgent"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
-   "id": "e21d2098",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Answer the following questions as best you can, but speaking as a pirate might speak. You have access to the following tools:\n",
-      "\n",
-      "Search: useful for when you need to answer questions about current events\n",
-      "\n",
-      "Use the following format:\n",
-      "\n",
-      "Question: the input question you must answer\n",
-      "Thought: you should always think about what to do\n",
-      "Action: the action to take, should be one of [Search]\n",
-      "Action Input: the input to the action\n",
-      "Observation: the result of the action\n",
-      "... (this Thought/Action/Action Input/Observation can repeat N times)\n",
-      "Thought: I now know the final answer\n",
-      "Final Answer: the final answer to the original input question\n",
-      "\n",
-      "Begin! Remember to speak as a pirate when giving your final answer. Use lots of \"Args\"\n",
-      "\n",
-      "Question: {input}\n",
-      "{agent_scratchpad}\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(prompt.template)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "5e028e6d",
-   "metadata": {},
-   "source": [
-    "Note that we are able to feed agents a self-defined prompt template, i.e. not restricted to the prompt generated by the `create_prompt` function, assuming it meets the agent's requirements. \n",
-    "\n",
-    "For example, for `ZeroShotAgent`, we will need to ensure that it meets the following requirements. There should a string starting with \"Action:\" and a following string starting with \"Action Input:\", and both should be separated by a newline.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "id": "9b1cc2a2",
+   "execution_count": 4,
+   "id": "a33e2f7e",
    "metadata": {},
    "outputs": [],
    "source": [
-    "llm_chain = LLMChain(llm=OpenAI(temperature=0), prompt=prompt)"
+    "from typing import List, Tuple, Any, Union\n",
+    "from langchain.schema import AgentAction, AgentFinish\n",
+    "\n",
+    "class FakeAgent(BaseAgent):\n",
+    "    \"\"\"Fake Custom Agent.\"\"\"\n",
+    "    \n",
+    "    @property\n",
+    "    def input_keys(self):\n",
+    "        return [\"input\"]\n",
+    "    \n",
+    "    def plan(\n",
+    "        self, intermediate_steps: List[Tuple[AgentAction, str]], **kwargs: Any\n",
+    "    ) -> Union[AgentAction, AgentFinish]:\n",
+    "        \"\"\"Given input, decided what to do.\n",
+    "\n",
+    "        Args:\n",
+    "            intermediate_steps: Steps the LLM has taken to date,\n",
+    "                along with observations\n",
+    "            **kwargs: User inputs.\n",
+    "\n",
+    "        Returns:\n",
+    "            Action specifying what tool to use.\n",
+    "        \"\"\"\n",
+    "        return AgentAction(tool=\"Search\", tool_input=\"foo\", log=\"\")\n",
+    "\n",
+    "    async def aplan(\n",
+    "        self, intermediate_steps: List[Tuple[AgentAction, str]], **kwargs: Any\n",
+    "    ) -> Union[AgentAction, AgentFinish]:\n",
+    "        \"\"\"Given input, decided what to do.\n",
+    "\n",
+    "        Args:\n",
+    "            intermediate_steps: Steps the LLM has taken to date,\n",
+    "                along with observations\n",
+    "            **kwargs: User inputs.\n",
+    "\n",
+    "        Returns:\n",
+    "            Action specifying what tool to use.\n",
+    "        \"\"\"\n",
+    "        return AgentAction(tool=\"Search\", tool_input=\"foo\", log=\"\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
-   "id": "e4f5092f",
+   "execution_count": 5,
+   "id": "655d72f6",
    "metadata": {},
    "outputs": [],
    "source": [
-    "tool_names = [tool.name for tool in tools]\n",
-    "agent = ZeroShotAgent(llm_chain=llm_chain, allowed_tools=tool_names)"
+    "agent = FakeAgent()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 6,
    "id": "490604e9",
    "metadata": {},
    "outputs": [],
@@ -176,7 +127,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 7,
    "id": "653b1617",
    "metadata": {},
    "outputs": [
@@ -187,12 +138,7 @@
       "\n",
       "\n",
       "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3mThought: I need to find out the population of Canada\n",
-      "Action: Search\n",
-      "Action Input: Population of Canada 2023\u001b[0m\n",
-      "Observation: \u001b[36;1m\u001b[1;3mThe current population of Canada is 38,610,447 as of Saturday, February 18, 2023, based on Worldometer elaboration of the latest United Nations data. Canada 2020 population is estimated at 37,742,154 people at mid year according to UN data.\u001b[0m\n",
-      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
-      "Final Answer: Arrr, Canada be havin' 38,610,447 scallywags livin' there as of 2023!\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3m\u001b[0m\u001b[36;1m\u001b[1;3mFoo Fighters is an American rock band formed in Seattle in 1994. Foo Fighters was initially formed as a one-man project by former Nirvana drummer Dave Grohl. Following the success of the 1995 eponymous debut album, Grohl recruited a band consisting of Nate Mendel, William Goldsmith, and Pat Smear.\u001b[0m\u001b[32;1m\u001b[1;3m\u001b[0m\n",
       "\n",
       "\u001b[1m> Finished chain.\u001b[0m\n"
      ]
@@ -200,10 +146,10 @@
     {
      "data": {
       "text/plain": [
-       "\"Arrr, Canada be havin' 38,610,447 scallywags livin' there as of 2023!\""
+       "'Foo Fighters is an American rock band formed in Seattle in 1994. Foo Fighters was initially formed as a one-man project by former Nirvana drummer Dave Grohl. Following the success of the 1995 eponymous debut album, Grohl recruited a band consisting of Nate Mendel, William Goldsmith, and Pat Smear.'"
       ]
      },
-     "execution_count": 31,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -212,114 +158,6 @@
     "agent_executor.run(\"How many people live in canada as of 2023?\")"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "040eb343",
-   "metadata": {},
-   "source": [
-    "### Multiple inputs\n",
-    "Agents can also work with prompts that require multiple inputs."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 32,
-   "id": "43dbfa2f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "prefix = \"\"\"Answer the following questions as best you can. You have access to the following tools:\"\"\"\n",
-    "suffix = \"\"\"When answering, you MUST speak in the following language: {language}.\n",
-    "\n",
-    "Question: {input}\n",
-    "{agent_scratchpad}\"\"\"\n",
-    "\n",
-    "prompt = ZeroShotAgent.create_prompt(\n",
-    "    tools, \n",
-    "    prefix=prefix, \n",
-    "    suffix=suffix, \n",
-    "    input_variables=[\"input\", \"language\", \"agent_scratchpad\"]\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 33,
-   "id": "0f087313",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "llm_chain = LLMChain(llm=OpenAI(temperature=0), prompt=prompt)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 34,
-   "id": "92c75a10",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "agent = ZeroShotAgent(llm_chain=llm_chain, tools=tools)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "id": "ac5b83bf",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "agent_executor = AgentExecutor.from_agent_and_tools(agent=agent, tools=tools, verbose=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "id": "c960e4ff",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3mThought: I need to find out the population of Canada in 2023.\n",
-      "Action: Search\n",
-      "Action Input: Population of Canada in 2023\u001b[0m\n",
-      "Observation: \u001b[36;1m\u001b[1;3mThe current population of Canada is 38,610,447 as of Saturday, February 18, 2023, based on Worldometer elaboration of the latest United Nations data. Canada 2020 population is estimated at 37,742,154 people at mid year according to UN data.\u001b[0m\n",
-      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer.\n",
-      "Final Answer: La popolazione del Canada nel 2023 è stimata in 38.610.447 persone.\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "'La popolazione del Canada nel 2023 è stimata in 38.610.447 persone.'"
-      ]
-     },
-     "execution_count": 36,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "agent_executor.run(input=\"How many people live in canada as of 2023?\", language=\"italian\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "90171b2b",
-   "metadata": {},
-   "source": [
-    "### Custom Agent Class\n",
-    "\n",
-    "Coming soon."
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,

docs/modules/agents/agents/custom_llm_agent.ipynb

@@ -0,0 +1,219 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "ba5f8741",
+   "metadata": {},
+   "source": [
+    "# Custom LLLM Agent\n",
+    "\n",
+    "This notebook goes through how to create your own custom LLM agent.\n",
+    "\n",
+    "An LLM agent consists of three parts:\n",
+    "    \n",
+    "    - Tools: The tools the agent has available to use.\n",
+    "    - LLMChain: The LLMChain that produces the text that is parsed in a certain way to determine which action to take.\n",
+    "    - OutputParser: This determines how to parse the LLMOutput into \n",
+    "        \n",
+    "        \n",
+    "In this notebook we walk through how to create a custom LLM agent."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "9af9734e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.agents import Tool, AgentExecutor\n",
+    "from langchain.agents.agent import LLMAgent, AgentOutputParser\n",
+    "from langchain.prompts import StringPromptTemplate\n",
+    "from langchain import OpenAI, SerpAPIWrapper, LLMChain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "becda2a1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "search = SerpAPIWrapper()\n",
+    "tools = [\n",
+    "    Tool(\n",
+    "        name = \"Search\",\n",
+    "        func=search.run,\n",
+    "        description=\"useful for when you need to answer questions about current events\"\n",
+    "    )\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "339b1bb8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "template = \"\"\"Answer the following questions as best you can, but speaking as a pirate might speak. You have access to the following tools:\n",
+    "\n",
+    "Search: useful for when you need to answer questions about current events\n",
+    "\n",
+    "Use the following format:\n",
+    "\n",
+    "Question: the input question you must answer\n",
+    "Thought: you should always think about what to do\n",
+    "Action: the action to take, should be one of [Search]\n",
+    "Action Input: the input to the action\n",
+    "Observation: the result of the action\n",
+    "... (this Thought/Action/Action Input/Observation can repeat N times)\n",
+    "Thought: I now know the final answer\n",
+    "Final Answer: the final answer to the original input question\n",
+    "\n",
+    "Begin! Remember to speak as a pirate when giving your final answer. Use lots of \"Args\"\n",
+    "\n",
+    "Question: {input}\n",
+    "{agent_scratchpad}\"\"\"\n",
+    "\n",
+    "class CustomPromptTemplate(StringPromptTemplate):\n",
+    "    \n",
+    "    def format(self, **kwargs) -> str:\n",
+    "        intermediate_steps = kwargs.pop(\"intermediate_steps\")\n",
+    "        thoughts = \"\"\n",
+    "        for action, observation in intermediate_steps:\n",
+    "            thoughts += action.log\n",
+    "            thoughts += f\"\\nObservation: {observation}\\nThought: \"\n",
+    "        kwargs[\"agent_scratchpad\"] = thoughts\n",
+    "        return template.format(**kwargs)\n",
+    "\n",
+    "prompt = CustomPromptTemplate(input_variables=[\"input\", \"intermediate_steps\"])\n",
+    "\n",
+    "FINAL_ANSWER_ACTION = \"Final Answer:\"\n",
+    "from langchain.schema import AgentAction, AgentFinish\n",
+    "import re\n",
+    "class CustomOutputParser(AgentOutputParser):\n",
+    "    \n",
+    "    def parse(self, llm_output):\n",
+    "        if FINAL_ANSWER_ACTION in llm_output:\n",
+    "            return AgentFinish(\n",
+    "                return_values={\"output\": llm_output.split(FINAL_ANSWER_ACTION)[-1].strip()},\n",
+    "                log=llm_output,\n",
+    "            )\n",
+    "        # \\s matches against tab/newline/whitespace\n",
+    "        regex = r\"Action: (.*?)[\\n]*Action Input:[\\s]*(.*)\"\n",
+    "        match = re.search(regex, llm_output, re.DOTALL)\n",
+    "        if not match:\n",
+    "            raise ValueError(f\"Could not parse LLM output: `{llm_output}`\")\n",
+    "        action = match.group(1).strip()\n",
+    "        action_input = match.group(2)\n",
+    "        return AgentAction(tool=action, tool_input=action_input.strip(\" \").strip('\"'), log=llm_output)\n",
+    "\n",
+    "output_parser = CustomOutputParser()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "9b1cc2a2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm_chain = LLMChain(llm=OpenAI(temperature=0), prompt=prompt)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "e4f5092f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tool_names = [tool.name for tool in tools]\n",
+    "agent = LLMAgent(llm_chain=llm_chain, output_parser=output_parser, stop=[\"\\nObservation:\"], allowed_tools=tool_names)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "490604e9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent_executor = AgentExecutor.from_agent_and_tools(agent=agent, tools=tools, verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "653b1617",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3mThought: I need to find out the population of Canada in 2023\n",
+      "Action: Search\n",
+      "Action Input: Population of Canada in 2023\u001b[0m\n",
+      "\n",
+      "Observation:\u001b[36;1m\u001b[1;3mThe current population of Canada is 38,644,767 as of Tuesday, March 28, 2023, based on Worldometer elaboration of the latest United Nations data.\u001b[0m\u001b[32;1m\u001b[1;3m I now know the final answer\n",
+      "Final Answer: Arrr, Canada be havin' 38,644,767 people livin' there as of 2023!\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\"Arrr, Canada be havin' 38,644,767 people livin' there as of 2023!\""
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent_executor.run(\"How many people live in canada as of 2023?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "adefb4c2",
+   "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.9.1"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "18784188d7ecd866c0586ac068b02361a6896dc3a29b64f5cc957f09c590acef"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/modules/agents/agents/custom_mrkl_agent.ipynb

@@ -0,0 +1,348 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "ba5f8741",
+   "metadata": {},
+   "source": [
+    "# Custom MRKL Agent\n",
+    "\n",
+    "This notebook goes through how to create your own custom MRKL agent.\n",
+    "\n",
+    "A MRKL agent consists of three parts:\n",
+    "    \n",
+    "    - Tools: The tools the agent has available to use.\n",
+    "    - LLMChain: The LLMChain that produces the text that is parsed in a certain way to determine which action to take.\n",
+    "    - The agent class itself: this parses the output of the LLMChain to determin which action to take.\n",
+    "        \n",
+    "        \n",
+    "In this notebook we walk through how to create a custom MRKL agent by creating a custom LLMChain."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6064f080",
+   "metadata": {},
+   "source": [
+    "### Custom LLMChain\n",
+    "\n",
+    "The first way to create a custom agent is to use an existing Agent class, but use a custom LLMChain. This is the simplest way to create a custom Agent. It is highly reccomended that you work with the `ZeroShotAgent`, as at the moment that is by far the most generalizable one. \n",
+    "\n",
+    "Most of the work in creating the custom LLMChain comes down to the prompt. Because we are using an existing agent class to parse the output, it is very important that the prompt say to produce text in that format. Additionally, we currently require an `agent_scratchpad` input variable to put notes on previous actions and observations. This should almost always be the final part of the prompt. However, besides those instructions, you can customize the prompt as you wish.\n",
+    "\n",
+    "To ensure that the prompt contains the appropriate instructions, we will utilize a helper method on that class. The helper method for the `ZeroShotAgent` takes the following arguments:\n",
+    "\n",
+    "- tools: List of tools the agent will have access to, used to format the prompt.\n",
+    "- prefix: String to put before the list of tools.\n",
+    "- suffix: String to put after the list of tools.\n",
+    "- input_variables: List of input variables the final prompt will expect.\n",
+    "\n",
+    "For this exercise, we will give our agent access to Google Search, and we will customize it in that we will have it answer as a pirate."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "9af9734e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.agents import ZeroShotAgent, Tool, AgentExecutor\n",
+    "from langchain import OpenAI, SerpAPIWrapper, LLMChain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "becda2a1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "search = SerpAPIWrapper()\n",
+    "tools = [\n",
+    "    Tool(\n",
+    "        name = \"Search\",\n",
+    "        func=search.run,\n",
+    "        description=\"useful for when you need to answer questions about current events\"\n",
+    "    )\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "339b1bb8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prefix = \"\"\"Answer the following questions as best you can, but speaking as a pirate might speak. You have access to the following tools:\"\"\"\n",
+    "suffix = \"\"\"Begin! Remember to speak as a pirate when giving your final answer. Use lots of \"Args\"\n",
+    "\n",
+    "Question: {input}\n",
+    "{agent_scratchpad}\"\"\"\n",
+    "\n",
+    "prompt = ZeroShotAgent.create_prompt(\n",
+    "    tools, \n",
+    "    prefix=prefix, \n",
+    "    suffix=suffix, \n",
+    "    input_variables=[\"input\", \"agent_scratchpad\"]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "59db7b58",
+   "metadata": {},
+   "source": [
+    "In case we are curious, we can now take a look at the final prompt template to see what it looks like when its all put together."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "e21d2098",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Answer the following questions as best you can, but speaking as a pirate might speak. You have access to the following tools:\n",
+      "\n",
+      "Search: useful for when you need to answer questions about current events\n",
+      "\n",
+      "Use the following format:\n",
+      "\n",
+      "Question: the input question you must answer\n",
+      "Thought: you should always think about what to do\n",
+      "Action: the action to take, should be one of [Search]\n",
+      "Action Input: the input to the action\n",
+      "Observation: the result of the action\n",
+      "... (this Thought/Action/Action Input/Observation can repeat N times)\n",
+      "Thought: I now know the final answer\n",
+      "Final Answer: the final answer to the original input question\n",
+      "\n",
+      "Begin! Remember to speak as a pirate when giving your final answer. Use lots of \"Args\"\n",
+      "\n",
+      "Question: {input}\n",
+      "{agent_scratchpad}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(prompt.template)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5e028e6d",
+   "metadata": {},
+   "source": [
+    "Note that we are able to feed agents a self-defined prompt template, i.e. not restricted to the prompt generated by the `create_prompt` function, assuming it meets the agent's requirements. \n",
+    "\n",
+    "For example, for `ZeroShotAgent`, we will need to ensure that it meets the following requirements. There should a string starting with \"Action:\" and a following string starting with \"Action Input:\", and both should be separated by a newline.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "9b1cc2a2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm_chain = LLMChain(llm=OpenAI(temperature=0), prompt=prompt)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "e4f5092f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tool_names = [tool.name for tool in tools]\n",
+    "agent = ZeroShotAgent(llm_chain=llm_chain, allowed_tools=tool_names)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "490604e9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent_executor = AgentExecutor.from_agent_and_tools(agent=agent, tools=tools, verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "653b1617",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3mThought: I need to find out the population of Canada\n",
+      "Action: Search\n",
+      "Action Input: Population of Canada 2023\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3mThe current population of Canada is 38,610,447 as of Saturday, February 18, 2023, based on Worldometer elaboration of the latest United Nations data. Canada 2020 population is estimated at 37,742,154 people at mid year according to UN data.\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
+      "Final Answer: Arrr, Canada be havin' 38,610,447 scallywags livin' there as of 2023!\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\"Arrr, Canada be havin' 38,610,447 scallywags livin' there as of 2023!\""
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent_executor.run(\"How many people live in canada as of 2023?\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "040eb343",
+   "metadata": {},
+   "source": [
+    "### Multiple inputs\n",
+    "Agents can also work with prompts that require multiple inputs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "43dbfa2f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prefix = \"\"\"Answer the following questions as best you can. You have access to the following tools:\"\"\"\n",
+    "suffix = \"\"\"When answering, you MUST speak in the following language: {language}.\n",
+    "\n",
+    "Question: {input}\n",
+    "{agent_scratchpad}\"\"\"\n",
+    "\n",
+    "prompt = ZeroShotAgent.create_prompt(\n",
+    "    tools, \n",
+    "    prefix=prefix, \n",
+    "    suffix=suffix, \n",
+    "    input_variables=[\"input\", \"language\", \"agent_scratchpad\"]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "0f087313",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm_chain = LLMChain(llm=OpenAI(temperature=0), prompt=prompt)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "92c75a10",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent = ZeroShotAgent(llm_chain=llm_chain, tools=tools)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "id": "ac5b83bf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent_executor = AgentExecutor.from_agent_and_tools(agent=agent, tools=tools, verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "c960e4ff",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
+      "\u001b[32;1m\u001b[1;3mThought: I need to find out the population of Canada in 2023.\n",
+      "Action: Search\n",
+      "Action Input: Population of Canada in 2023\u001b[0m\n",
+      "Observation: \u001b[36;1m\u001b[1;3mThe current population of Canada is 38,610,447 as of Saturday, February 18, 2023, based on Worldometer elaboration of the latest United Nations data. Canada 2020 population is estimated at 37,742,154 people at mid year according to UN data.\u001b[0m\n",
+      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer.\n",
+      "Final Answer: La popolazione del Canada nel 2023 è stimata in 38.610.447 persone.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'La popolazione del Canada nel 2023 è stimata in 38.610.447 persone.'"
+      ]
+     },
+     "execution_count": 36,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent_executor.run(input=\"How many people live in canada as of 2023?\", language=\"italian\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "adefb4c2",
+   "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.9.1"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "18784188d7ecd866c0586ac068b02361a6896dc3a29b64f5cc957f09c590acef"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

langchain/agents/agent.py

@@ -19,13 +19,183 @@ from langchain.llms.base import BaseLLM
 from langchain.prompts.base import BasePromptTemplate
 from langchain.prompts.few_shot import FewShotPromptTemplate
 from langchain.prompts.prompt import PromptTemplate
-from langchain.schema import AgentAction, AgentFinish, BaseMessage
+from langchain.schema import AgentAction, AgentFinish, BaseMessage, BaseOutputParser
 from langchain.tools.base import BaseTool
 
 logger = logging.getLogger()
 
 
-class Agent(BaseModel):
+class BaseSingleActionAgent(BaseModel):
+    """Base Agent class."""
+
+    @property
+    def return_values(self) -> List[str]:
+        """Return values of the agent."""
+        return ["output"]
+
+    def get_allowed_tools(self) -> Optional[List[str]]:
+        return None
+
+    @abstractmethod
+    def plan(
+        self, intermediate_steps: List[Tuple[AgentAction, str]], **kwargs: Any
+    ) -> Union[AgentAction, AgentFinish]:
+        """Given input, decided what to do.
+
+        Args:
+            intermediate_steps: Steps the LLM has taken to date,
+                along with observations
+            **kwargs: User inputs.
+
+        Returns:
+            Action specifying what tool to use.
+        """
+
+    @abstractmethod
+    async def aplan(
+        self, intermediate_steps: List[Tuple[AgentAction, str]], **kwargs: Any
+    ) -> Union[AgentAction, AgentFinish]:
+        """Given input, decided what to do.
+
+        Args:
+            intermediate_steps: Steps the LLM has taken to date,
+                along with observations
+            **kwargs: User inputs.
+
+        Returns:
+            Action specifying what tool to use.
+        """
+
+    @property
+    @abstractmethod
+    def input_keys(self) -> List[str]:
+        """Return the input keys.
+
+        :meta private:
+        """
+
+    def return_stopped_response(
+        self,
+        early_stopping_method: str,
+        intermediate_steps: List[Tuple[AgentAction, str]],
+        **kwargs: Any,
+    ) -> AgentFinish:
+        """Return response when agent has been stopped due to max iterations."""
+        if early_stopping_method == "force":
+            # `force` just returns a constant string
+            return AgentFinish({"output": "Agent stopped due to max iterations."}, "")
+        else:
+            raise ValueError(
+                f"Got unsupported early_stopping_method `{early_stopping_method}`"
+            )
+
+    @property
+    def _agent_type(self) -> str:
+        """Return Identifier of agent type."""
+        raise NotImplementedError
+
+    def dict(self, **kwargs: Any) -> Dict:
+        """Return dictionary representation of agent."""
+        _dict = super().dict()
+        _dict["_type"] = self._agent_type
+        return _dict
+
+    def save(self, file_path: Union[Path, str]) -> None:
+        """Save the agent.
+
+        Args:
+            file_path: Path to file to save the agent to.
+
+        Example:
+        .. code-block:: python
+
+            # If working with agent executor
+            agent.agent.save(file_path="path/agent.yaml")
+        """
+        # Convert file to Path object.
+        if isinstance(file_path, str):
+            save_path = Path(file_path)
+        else:
+            save_path = file_path
+
+        directory_path = save_path.parent
+        directory_path.mkdir(parents=True, exist_ok=True)
+
+        # Fetch dictionary to save
+        agent_dict = self.dict()
+
+        if save_path.suffix == ".json":
+            with open(file_path, "w") as f:
+                json.dump(agent_dict, f, indent=4)
+        elif save_path.suffix == ".yaml":
+            with open(file_path, "w") as f:
+                yaml.dump(agent_dict, f, default_flow_style=False)
+        else:
+            raise ValueError(f"{save_path} must be json or yaml")
+
+    def tool_run_logging_kwargs(self) -> Dict:
+        return {}
+
+
+class AgentOutputParser(BaseOutputParser):
+    @abstractmethod
+    def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
+        """Parse text into agent action/finish."""
+
+
+class LLMSingleActionAgent(BaseSingleActionAgent):
+    llm_chain: LLMChain
+    output_parser: AgentOutputParser
+    stop: List[str]
+
+    @property
+    def input_keys(self) -> List[str]:
+        return list(set(self.llm_chain.input_keys) - {"intermediate_steps"})
+
+    def plan(
+        self, intermediate_steps: List[Tuple[AgentAction, str]], **kwargs: Any
+    ) -> Union[AgentAction, AgentFinish]:
+        """Given input, decided what to do.
+
+        Args:
+            intermediate_steps: Steps the LLM has taken to date,
+                along with observations
+            **kwargs: User inputs.
+
+        Returns:
+            Action specifying what tool to use.
+        """
+        output = self.llm_chain.run(
+            intermediate_steps=intermediate_steps, stop=self.stop, **kwargs
+        )
+        return self.output_parser.parse(output)
+
+    async def aplan(
+        self, intermediate_steps: List[Tuple[AgentAction, str]], **kwargs: Any
+    ) -> Union[AgentAction, AgentFinish]:
+        """Given input, decided what to do.
+
+        Args:
+            intermediate_steps: Steps the LLM has taken to date,
+                along with observations
+            **kwargs: User inputs.
+
+        Returns:
+            Action specifying what tool to use.
+        """
+        output = await self.llm_chain.arun(
+            intermediate_steps=intermediate_steps, stop=self.stop, **kwargs
+        )
+        return self.output_parser.parse(output)
+
+    def tool_run_logging_kwargs(self) -> Dict:
+        return {
+            "llm_prefix": "",
+            "observation_prefix": "" if len(self.stop) == 0 else self.stop[0],
+        }
+
+
+class Agent(BaseSingleActionAgent):
     """Class responsible for calling the language model and deciding the action.
 
     This is driven by an LLMChain. The prompt in the LLMChain MUST include
@@ -35,7 +205,13 @@ class Agent(BaseModel):
 
     llm_chain: LLMChain
     allowed_tools: Optional[List[str]] = None
-    return_values: List[str] = ["output"]
+
+    def get_allowed_tools(self) -> Optional[List[str]]:
+        return self.allowed_tools
+
+    @property
+    def return_values(self) -> List[str]:
+        return ["output"]
 
     @abstractmethod
     def _extract_tool_and_input(self, text: str) -> Optional[Tuple[str, str]]:
@@ -248,55 +424,17 @@ class Agent(BaseModel):
                 f"got {early_stopping_method}"
             )
 
-    @property
-    @abstractmethod
-    def _agent_type(self) -> str:
-        """Return Identifier of agent type."""
-
-    def dict(self, **kwargs: Any) -> Dict:
-        """Return dictionary representation of agent."""
-        _dict = super().dict()
-        _dict["_type"] = self._agent_type
-        return _dict
-
-    def save(self, file_path: Union[Path, str]) -> None:
-        """Save the agent.
-
-        Args:
-            file_path: Path to file to save the agent to.
-
-        Example:
-        .. code-block:: python
-
-            # If working with agent executor
-            agent.agent.save(file_path="path/agent.yaml")
-        """
-        # Convert file to Path object.
-        if isinstance(file_path, str):
-            save_path = Path(file_path)
-        else:
-            save_path = file_path
-
-        directory_path = save_path.parent
-        directory_path.mkdir(parents=True, exist_ok=True)
-
-        # Fetch dictionary to save
-        agent_dict = self.dict()
-
-        if save_path.suffix == ".json":
-            with open(file_path, "w") as f:
-                json.dump(agent_dict, f, indent=4)
-        elif save_path.suffix == ".yaml":
-            with open(file_path, "w") as f:
-                yaml.dump(agent_dict, f, default_flow_style=False)
-        else:
-            raise ValueError(f"{save_path} must be json or yaml")
+    def tool_run_logging_kwargs(self) -> Dict:
+        return {
+            "llm_prefix": self.llm_prefix,
+            "observation_prefix": self.observation_prefix,
+        }
 
 
 class AgentExecutor(Chain, BaseModel):
     """Consists of an agent using tools."""
 
-    agent: Agent
+    agent: BaseSingleActionAgent
     tools: Sequence[BaseTool]
     return_intermediate_steps: bool = False
     max_iterations: Optional[int] = 15
@@ -305,7 +443,7 @@ class AgentExecutor(Chain, BaseModel):
     @classmethod
     def from_agent_and_tools(
         cls,
-        agent: Agent,
+        agent: BaseSingleActionAgent,
         tools: Sequence[BaseTool],
         callback_manager: Optional[BaseCallbackManager] = None,
         **kwargs: Any,
@@ -320,10 +458,11 @@ class AgentExecutor(Chain, BaseModel):
         """Validate that tools are compatible with agent."""
         agent = values["agent"]
         tools = values["tools"]
-        if agent.allowed_tools is not None:
-            if set(agent.allowed_tools) != set([tool.name for tool in tools]):
+        allowed_tools = agent.get_allowed_tools()
+        if allowed_tools is not None:
+            if set(allowed_tools) != set([tool.name for tool in tools]):
                 raise ValueError(
-                    f"Allowed tools ({agent.allowed_tools}) different than "
+                    f"Allowed tools ({allowed_tools}) different than "
                     f"provided tools ({[tool.name for tool in tools]})"
                 )
         return values
@@ -418,22 +557,17 @@ class AgentExecutor(Chain, BaseModel):
             tool = name_to_tool_map[output.tool]
             return_direct = tool.return_direct
             color = color_mapping[output.tool]
-            llm_prefix = "" if return_direct else self.agent.llm_prefix
+            tool_run_kwargs = self.agent.tool_run_logging_kwargs()
+            if return_direct:
+                tool_run_kwargs["llm_prefix"] = ""
             # We then call the tool on the tool input to get an observation
             observation = tool.run(
-                output.tool_input,
-                verbose=self.verbose,
-                color=color,
-                llm_prefix=llm_prefix,
-                observation_prefix=self.agent.observation_prefix,
+                output.tool_input, verbose=self.verbose, color=color, **tool_run_kwargs
             )
         else:
+            tool_run_kwargs = self.agent.tool_run_logging_kwargs()
             observation = InvalidTool().run(
-                output.tool,
-                verbose=self.verbose,
-                color=None,
-                llm_prefix="",
-                observation_prefix=self.agent.observation_prefix,
+                output.tool, verbose=self.verbose, color=None, **tool_run_kwargs
             )
         return output, observation
 
@@ -467,22 +601,17 @@ class AgentExecutor(Chain, BaseModel):
             tool = name_to_tool_map[output.tool]
             return_direct = tool.return_direct
             color = color_mapping[output.tool]
-            llm_prefix = "" if return_direct else self.agent.llm_prefix
+            tool_run_kwargs = self.agent.tool_run_logging_kwargs()
+            if return_direct:
+                tool_run_kwargs["llm_prefix"] = ""
             # We then call the tool on the tool input to get an observation
             observation = await tool.arun(
-                output.tool_input,
-                verbose=self.verbose,
-                color=color,
-                llm_prefix=llm_prefix,
-                observation_prefix=self.agent.observation_prefix,
+                output.tool_input, verbose=self.verbose, color=color, **tool_run_kwargs
             )
         else:
+            tool_run_kwargs = self.agent.tool_run_logging_kwargs()
             observation = await InvalidTool().arun(
-                output.tool,
-                verbose=self.verbose,
-                color=None,
-                llm_prefix="",
-                observation_prefix=self.agent.observation_prefix,
+                output.tool, verbose=self.verbose, color=None, **tool_run_kwargs
             )
             return_direct = False
         return output, observation

langchain/agents/tools.py

@@ -40,11 +40,11 @@ class InvalidTool(BaseTool):
 
     def _run(self, tool_name: str) -> str:
         """Use the tool."""
-        return f"{tool_name} is not a valid tool, try another one."
+        return f"{tool_name} is not a valid tool, try another one. Reminder to only use allowed tool names!"
 
     async def _arun(self, tool_name: str) -> str:
         """Use the tool asynchronously."""
-        return f"{tool_name} is not a valid tool, try another one."
+        return f"{tool_name} is not a valid tool, try another one. Reminder to only use allowed tool names!"
 
 
 def tool(*args: Union[str, Callable], return_direct: bool = False) -> Callable:

langchain/callbacks/stdout.py

@@ -74,9 +74,11 @@ class StdOutCallbackHandler(BaseCallbackHandler):
         **kwargs: Any,
     ) -> None:
         """If not the final action, print out observation."""
-        print_text(f"\n{observation_prefix}")
+        if observation_prefix:
+            print_text(f"\n{observation_prefix}")
         print_text(output, color=color if color else self.color)
-        print_text(f"\n{llm_prefix}")
+        if llm_prefix:
+            print_text(f"\n{llm_prefix}")
 
     def on_tool_error(
         self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any

langchain/callbacks/tracers/langchain.py

@@ -35,7 +35,6 @@ class BaseLangChainTracer(BaseTracer, ABC):
             endpoint = f"{self._endpoint}/chain-runs"
         else:
             endpoint = f"{self._endpoint}/tool-runs"
-
         try:
             requests.post(
                 endpoint,

langchain/chains/base.py

@@ -199,7 +199,7 @@ class Chain(BaseModel, ABC):
         """Call the chain on all inputs in the list."""
         return [self(inputs) for inputs in input_list]
 
-    def run(self, *args: str, **kwargs: str) -> str:
+    def run(self, *args: Any, **kwargs: Any) -> str:
         """Run the chain as text in, text out or multiple variables, text out."""
         if len(self.output_keys) != 1:
             raise ValueError(
@@ -220,7 +220,7 @@ class Chain(BaseModel, ABC):
             f" but not both. Got args: {args} and kwargs: {kwargs}."
         )
 
-    async def arun(self, *args: str, **kwargs: str) -> str:
+    async def arun(self, *args: Any, **kwargs: Any) -> str:
         """Run the chain as text in, text out or multiple variables, text out."""
         if len(self.output_keys) != 1:
             raise ValueError(

langchain/chains/openapi_chain.py

@@ -0,0 +1,60 @@
+from typing import Dict, List
+
+from langchain.chains.base import Chain
+from langchain.requests import RequestsWrapper
+from langchain.prompts.prompt import PromptTemplate
+from langchain.schema import BaseLanguageModel
+from langchain.chains.llm import LLMChain
+from langchain.schema import BaseOutputParser
+
+prompt = """Here is an API:
+
+{api_spec}
+
+Your job is to answer questions by returning valid JSON to send to this API in order to answer the user's question. 
+Response with valid markdown, eg in the format:
+
+[JSON BEGIN]
+```json
+...
+```
+[JSON END]
+
+Here is the question you are trying to answer:
+
+{question}"""
+PROMPT = PromptTemplate.from_template(prompt)
+
+class OpenAPIChain(Chain):
+
+    endpoint_spec: str
+    llm_chain: LLMChain
+    output_parser: BaseOutputParser
+    url: str
+    requests_method: str
+    requests_wrapper: RequestsWrapper
+
+    @classmethod
+    def from_llm(cls, llm: BaseLanguageModel, endpoint_spec: str, output_parser: BaseOutputParser, **kwargs):
+        chain = LLMChain(llm=llm, prompt=PROMPT)
+        return cls(llm_chain=chain, endpoint_spec=endpoint_spec, output_parser=output_parser, **kwargs)
+
+
+    @property
+    def input_keys(self) -> List[str]:
+        return ["input"]
+
+    @property
+    def output_keys(self) -> List[str]:
+        return ["response"]
+
+    def _call(self, inputs: Dict[str, str]) -> Dict[str, str]:
+        question = inputs["input"]
+        response = self.llm_chain.run(question=question, api_spec=self.endpoint_spec)
+        parsed = self.output_parser.parse(response)
+        requst_fn = getattr(self.requests_wrapper, self.requests_method)
+        result = requst_fn(
+            self.url,
+            params=parsed,
+        )
+        return {"response": result}

langchain/prompts/base.py

@@ -144,9 +144,9 @@ class BasePromptTemplate(BaseModel, ABC):
         """
 
     @property
-    @abstractmethod
     def _prompt_type(self) -> str:
         """Return the prompt type key."""
+        raise NotImplementedError
 
     def dict(self, **kwargs: Any) -> Dict:
         """Return dictionary representation of prompt."""

langchain/requests.py

@@ -18,9 +18,9 @@ class RequestsWrapper(BaseModel):
         extra = Extra.forbid
         arbitrary_types_allowed = True
 
-    def get(self, url: str) -> str:
+    def get(self, url: str, **kwargs: Any) -> str:
         """GET the URL and return the text."""
-        return requests.get(url, headers=self.headers).text
+        return requests.get(url, headers=self.headers, **kwargs).json()
 
     def post(self, url: str, data: Dict[str, Any]) -> str:
         """POST to the URL and return the text."""

tests/unit_tests/agents/test_agent.py

@@ -149,7 +149,7 @@ def test_agent_with_callbacks_local() -> None:
         callback_manager=manager,
     )
 
-    agent.agent.llm_chain.verbose = True
+    agent.agent.llm_chain.verbose = True  # type: ignore
 
     output = agent.run("when was langchain made")
     assert output == "curses foiled again"
@@ -285,8 +285,8 @@ def test_agent_with_new_prefix_suffix() -> None:
     )
 
     # avoids "BasePromptTemplate" has no attribute "template" error
-    assert hasattr(agent.agent.llm_chain.prompt, "template")
-    prompt_str = agent.agent.llm_chain.prompt.template
+    assert hasattr(agent.agent.llm_chain.prompt, "template")  # type: ignore
+    prompt_str = agent.agent.llm_chain.prompt.template  # type: ignore
     assert prompt_str.startswith(prefix), "Prompt does not start with prefix"
     assert prompt_str.endswith(suffix), "Prompt does not end with suffix"