langchain-agents.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1571b632",
   "metadata": {
    "id": "1571b632"
   },
   "source": [
    "# LangChain Agents 🤖\n",
    "\n",
    "Agents are like \"tools\" for LLMs. They allow a LLM to access Google search, perform complex calculations with Python, and even make SQL queries.\n",
    "\n",
    "In this notebook we'll explore agents and how to use them in LangChain.\n",
    "\n",
    "We'll start by installing the prerequisite libraries that we'll be using in this example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "uZR3iGJJtdDE",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "uZR3iGJJtdDE",
    "outputId": "0119ff4e-61fc-4d5f-9292-a719c54b8cb5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.5/1.5 MB\u001b[0m \u001b[31m10.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m75.5/75.5 kB\u001b[0m \u001b[31m6.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
      "\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
      "  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m49.4/49.4 kB\u001b[0m \u001b[31m4.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
      "\u001b[?25h  Building wheel for google-search-results (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
      "  Building wheel for wikipedia (setup.py) ... \u001b[?25l\u001b[?25hdone\n"
     ]
    }
   ],
   "source": [
    "!pip install -qU langchain openai google-search-results wikipedia sqlalchemy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "wPdWz1IdxyBR",
   "metadata": {
    "id": "wPdWz1IdxyBR"
   },
   "source": [
    "To run this notebook, we will need to use an OpenAI LLM. Here we will setup the LLM we will use for the whole notebook, just input your openai api key when prompted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c02c4fa2",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "c02c4fa2",
    "outputId": "ad22dddc-6180-48ac-86dd-265b6b7afa57",
    "tags": []
   },
   "outputs": [],
   "source": [
    "from dotenv import load_dotenv, find_dotenv\n",
    "import os\n",
    "_ = load_dotenv(find_dotenv())\n",
    "\n",
    "OPENAI_API_KEY  = os.getenv('OPENAI_API_KEY')\n",
    "HUGGINGFACEHUB_API_TOKEN = os.getenv('HUGGINGFACEHUB_API_TOKEN')\n",
    "\n",
    "# initialize connection to pinecone (get API key at app.pinecone.io)\n",
    "PINECONE_API_KEY = os.getenv(\"PINECONE_API_KEY\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "73bfcbb6",
   "metadata": {
    "id": "73bfcbb6",
    "tags": []
   },
   "outputs": [],
   "source": [
    "from langchain_openai import OpenAI\n",
    "\n",
    "llm = OpenAI(\n",
    "    openai_api_key=OPENAI_API_KEY,\n",
    "    temperature=0\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "309g_2pqxzzB",
   "metadata": {
    "id": "309g_2pqxzzB"
   },
   "source": [
    "As we did before, we will be counting our tokens in each call."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "DsC3szr6yP3L",
   "metadata": {
    "id": "DsC3szr6yP3L",
    "tags": []
   },
   "outputs": [],
   "source": [
    "from langchain.callbacks import get_openai_callback\n",
    "\n",
    "def count_tokens(agent, query):\n",
    "    with get_openai_callback() as cb:\n",
    "        result = agent.invoke(query)\n",
    "        print(f'Spent a total of {cb.total_tokens} tokens')\n",
    "\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd60a97c",
   "metadata": {
    "id": "bd60a97c"
   },
   "source": [
    "With all of that set up, let's jump into **Agents**."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "101eac3d-e3a8-42ce-a5c9-9fe6d025446c",
   "metadata": {},
   "source": [
    "Large Language Models (LLMs) are incredibly powerful, yet they lack particular abilities that the “dumbest” computer programs can handle with ease. Logic, calculation, and search are examples of where computers typically excel, but LLMs struggle.\n",
    "\n",
    "Computers can solve incredibly complex math problems, yet if we ask GPT-4 to tell us the answer to 4.1 * 7.9, it fails:\n",
    "\n",
    "<div>\n",
    "<img src=\"https://education-team-2020.s3.eu-west-1.amazonaws.com/ai-eng/images-langchain-agents/agent_math_fails.webp\" alt='chart' width=\"1000\"/>\n",
    "</div>\n",
    "Asking GPT-4 to perform a simple calculation often results in an incorrect answer. A simple calculator can perform this same calculation without issue."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc33edce-ecdc-4bb9-8b6d-0f0b1ee74530",
   "metadata": {},
   "source": [
    "With significant weaknesses in today’s generation of LLMs, we must find solutions to these problems. One “suite” of potential solutions comes in the form of “agents”.\n",
    "\n",
    "These agents don’t just solve the problems we saw above but many others. In fact, adding agents has an almost unlimited upside in their LLM-enhancing abilities\n",
    "<div>\n",
    "<img src=\"https://education-team-2020.s3.eu-west-1.amazonaws.com/ai-eng/images-langchain-agents/agent.webp\" alt='chart' width=\"1000\"/>\n",
    "</div>\n",
    "Agents are LLMs that can use tools like calculators, search, or executing code."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e1f31b4",
   "metadata": {
    "id": "6e1f31b4"
   },
   "source": [
    "## What is an agent?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b919c3a",
   "metadata": {
    "id": "5b919c3a"
   },
   "source": [
    "**Definition**: The key behind agents is giving LLM's the possibility of using tools in their workflow. This is where langchain departs from the popular chatgpt implementation and we can start to get a glimpse of what it offers us as builders. Until now, we covered several building blocks in isolation. Let's see them come to life.\n",
    "\n",
    "The official definition of agents is the following:\n",
    "\n",
    "\n",
    "> Agents use an LLM to determine which actions to take and in what order. An action can either be using a tool and observing its output, or returning to the user."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cfc3041-7d50-40e0-b66e-657355927e5b",
   "metadata": {},
   "source": [
    "We can think of agents as enabling “tools” for LLMs. Like how a human would use a calculator for maths or perform a Google search for information — agents allow an LLM to do the same thing."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c9c13e9",
   "metadata": {
    "id": "6c9c13e9"
   },
   "source": [
    "In this edition we will cover what we may call 'generic' agents which really able to perform many meta tasks. There are other more specific agents that are tuned for different tasks (called 'agent-toolkits'), but we will cover those in a future edition."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a93dc920",
   "metadata": {
    "id": "a93dc920"
   },
   "source": [
    "## Create database"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b601f903",
   "metadata": {
    "id": "b601f903"
   },
   "source": [
    "We will use the agents to interact with a small sample database of stocks. We will not dive into the details because this is just a dummy tool we will build for illustrative purposes. Let's create it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "61b1f17c",
   "metadata": {
    "id": "61b1f17c",
    "tags": []
   },
   "outputs": [],
   "source": [
    "from sqlalchemy import MetaData\n",
    "\n",
    "metadata_obj = MetaData()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "3cc1d80e",
   "metadata": {
    "id": "3cc1d80e",
    "tags": []
   },
   "outputs": [],
   "source": [
    "from sqlalchemy import Column, Integer, String, Table, Date, Float\n",
    "\n",
    "stocks = Table(\n",
    "    \"stocks\",\n",
    "    metadata_obj,\n",
    "    Column(\"obs_id\", Integer, primary_key=True),\n",
    "    Column(\"stock_ticker\", String(4), nullable=False),\n",
    "    Column(\"price\", Float, nullable=False),\n",
    "    Column(\"date\", Date, nullable=False),\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "c9a9571a",
   "metadata": {
    "id": "c9a9571a",
    "tags": []
   },
   "outputs": [],
   "source": [
    "from sqlalchemy import create_engine\n",
    "\n",
    "engine = create_engine(\"sqlite:///:memory:\")\n",
    "metadata_obj.create_all(engine)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "81c3081f",
   "metadata": {
    "id": "81c3081f",
    "tags": []
   },
   "outputs": [],
   "source": [
    "from datetime import datetime\n",
    "\n",
    "observations = [\n",
    "    [1, 'ABC', 200, datetime(2023, 1, 1)],\n",
    "    [2, 'ABC', 208, datetime(2023, 1, 2)],\n",
    "    [3, 'ABC', 232, datetime(2023, 1, 3)],\n",
    "    [4, 'ABC', 225, datetime(2023, 1, 4)],\n",
    "    [5, 'ABC', 226, datetime(2023, 1, 5)],\n",
    "    [6, 'XYZ', 810, datetime(2023, 1, 1)],\n",
    "    [7, 'XYZ', 803, datetime(2023, 1, 2)],\n",
    "    [8, 'XYZ', 798, datetime(2023, 1, 3)],\n",
    "    [9, 'XYZ', 795, datetime(2023, 1, 4)],\n",
    "    [10, 'XYZ', 791, datetime(2023, 1, 5)],\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "85fd20fa",
   "metadata": {
    "id": "85fd20fa",
    "tags": []
   },
   "outputs": [],
   "source": [
    "from sqlalchemy import insert\n",
    "\n",
    "def insert_obs(obs):\n",
    "    stmt = insert(stocks).values(\n",
    "    obs_id=obs[0],\n",
    "    stock_ticker=obs[1],\n",
    "    price=obs[2],\n",
    "    date=obs[3]\n",
    "    )\n",
    "\n",
    "    with engine.begin() as conn:\n",
    "        conn.execute(stmt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "6766f1f7",
   "metadata": {
    "id": "6766f1f7",
    "tags": []
   },
   "outputs": [],
   "source": [
    "for obs in observations:\n",
    "    insert_obs(obs)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "H3_tIYndeNAt",
   "metadata": {
    "id": "H3_tIYndeNAt"
   },
   "source": [
    "We are installing the `langchain_experimental` library here, since the `SQLDatabaseChain` is located there. This might be changed in the future and moved into official `langchain` library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "KJJz9xXvb1Ej",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "KJJz9xXvb1Ej",
    "outputId": "9533f802-804d-4c4c-c19f-87827bbc178c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m70.7/70.7 kB\u001b[0m \u001b[31m2.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
      "\u001b[?25h"
     ]
    }
   ],
   "source": [
    "#!pip install langchain_experimental -qU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "9721648e",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "9721648e",
    "outputId": "9e77c155-c662-47c2-b585-deb88e8ad51b",
    "tags": []
   },
   "outputs": [],
   "source": [
    "from langchain.utilities import SQLDatabase\n",
    "from langchain_experimental.sql import SQLDatabaseChain\n",
    "\n",
    "db = SQLDatabase(engine)\n",
    "# sql_chain = SQLDatabaseChain(llm=llm, database=db, verbose=True)\n",
    "sql_chain = SQLDatabaseChain.from_llm(llm, db)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6325f758",
   "metadata": {
    "id": "6325f758"
   },
   "source": [
    "## Agent types"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d732b7a",
   "metadata": {
    "id": "4d732b7a"
   },
   "source": [
    "In this section we will review several agents and see how they 'think' and what they can do."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ee98631",
   "metadata": {
    "id": "8ee98631"
   },
   "source": [
    "Using one of langchain's pre-built agents involves three variables:\n",
    "* defining the tools or the toolkit\n",
    "* defining the llm\n",
    "* defining the agent type\n",
    "\n",
    "This is all really easy to do in langchain, as we will see in the following example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1eaf306a",
   "metadata": {
    "id": "1eaf306a"
   },
   "source": [
    "### Agent type #1: Zero Shot React"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "Tgn6dRLEcxli",
   "metadata": {
    "id": "Tgn6dRLEcxli"
   },
   "source": [
    "In this first example we will use slightly different type of agent - SQL Agent which can be instantiated with it's own method `create_sql_agent`. Other agents will be instantiated in more generic way as we will see below in other examples.\n",
    "<br><br>\n",
    "This method uses *toolkit* instead of simple list of `tools`. You can read more about them in the [documentation](https://python.langchain.com/docs/modules/agents/toolkits/). For this use case, we will use `SQLDatabaseToolkit`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "mie_37ERl_ac",
   "metadata": {
    "id": "mie_37ERl_ac"
   },
   "source": [
    "As the name suggests, we will use this agent to perform 'zero shot' tasks on the input. That means that we will not have several, interdependent interactions but only one. In other words, this agent will have no memory."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "O_pYBlCcl11l",
   "metadata": {
    "id": "O_pYBlCcl11l"
   },
   "source": [
    "Now we are ready to initialize the agent! We will use `verbose` in `True` so we can see what is our agent's 'thinking' process."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "GtSMUCaIlupp",
   "metadata": {
    "id": "GtSMUCaIlupp"
   },
   "source": [
    "**Important Note:** *When interacting with agents it is really important to set the `max_iterations` parameters because agents can get stuck in infinite loops that consume plenty of tokens. The default value is 15 to allow for many tools and complex reasoning but for most applications you should keep it much lower.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "5Z4EmMmqiOvZ",
   "metadata": {
    "id": "5Z4EmMmqiOvZ",
    "tags": []
   },
   "outputs": [],
   "source": [
    "from langchain.agents import create_sql_agent\n",
    "from langchain.agents.agent_toolkits import SQLDatabaseToolkit\n",
    "from langchain.agents.agent_types import AgentType\n",
    "\n",
    "agent_executor = create_sql_agent(\n",
    "    llm=llm,\n",
    "    toolkit=SQLDatabaseToolkit(db=db, llm=llm),\n",
    "    verbose=True,\n",
    "    agent_type=AgentType.ZERO_SHOT_REACT_DESCRIPTION,\n",
    "    max_iterations=3\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "iBqz6aFzj-2d",
   "metadata": {
    "id": "iBqz6aFzj-2d"
   },
   "source": [
    "Let's see our newly created agent in action! We will ask it a question that involves a math operation over the stock prices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "MdvgpwHRic3W",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "MdvgpwHRic3W",
    "outputId": "5e63199b-2d92-404a-c712-5e8f4f55e23d",
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\u001b[1m> Entering new SQL Agent Executor chain...\u001b[0m\n",
      "\u001b[32;1m\u001b[1;3m I need to get the stock prices for 'ABC' and 'XYZ' for January 3rd and January 4th.\n",
      "Action: sql_db_query\n",
      "Action Input: SELECT stock_price FROM stock_table WHERE stock_name = 'ABC' AND date = 'January 3rd'\u001b[0m\u001b[36;1m\u001b[1;3mError: (sqlite3.OperationalError) no such table: stock_table\n",
      "[SQL: SELECT stock_price FROM stock_table WHERE stock_name = 'ABC' AND date = 'January 3rd']\n",
      "(Background on this error at: https://sqlalche.me/e/20/e3q8)\u001b[0m\u001b[32;1m\u001b[1;3mI need to use sql_db_list_tables to see what tables are available.\n",
      "Action: sql_db_list_tables\n",
      "Action Input: \"\"\u001b[0m\u001b[38;5;200m\u001b[1;3mstocks\u001b[0m\u001b[32;1m\u001b[1;3mI need to use sql_db_schema to see the schema for the stocks table.\n",
      "Action: sql_db_schema\n",
      "Action Input: stocks\u001b[0m\u001b[33;1m\u001b[1;3m\n",
      "CREATE TABLE stocks (\n",
      "\tobs_id INTEGER NOT NULL, \n",
      "\tstock_ticker VARCHAR(4) NOT NULL, \n",
      "\tprice FLOAT NOT NULL, \n",
      "\tdate DATE NOT NULL, \n",
      "\tPRIMARY KEY (obs_id)\n",
      ")\n",
      "\n",
      "/*\n",
      "3 rows from stocks table:\n",
      "obs_id\tstock_ticker\tprice\tdate\n",
      "1\tABC\t200.0\t2023-01-01\n",
      "2\tABC\t208.0\t2023-01-02\n",
      "3\tABC\t232.0\t2023-01-03\n",
      "*/\u001b[0m\u001b[32;1m\u001b[1;3m\u001b[0m\n",
      "\n",
      "\u001b[1m> Finished chain.\u001b[0m\n",
      "Spent a total of 0 tokens\n"
     ]
    }
   ],
   "source": [
    "result = count_tokens(\n",
    "    agent_executor,\n",
    "    \"What is the multiplication of the ratio between stock \" +\n",
    "    \"prices for 'ABC' and 'XYZ' in January 3rd and the ratio \" +\n",
    "    \"between the same stock prices in January the 4th?\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "LqzuNMgWmFXS",
   "metadata": {
    "id": "LqzuNMgWmFXS"
   },
   "source": [
    "As always, let's see what the prompt is here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "ny7m_wMCmF4b",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ny7m_wMCmF4b",
    "outputId": "ab8fdf8a-6f83-4f3f-e9dc-7313b48f81ef",
    "tags": []
   },
   "outputs": [],
   "source": [
    "# print(agent_executor.agent.llm_chain.prompt.template)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b2b47ed",
   "metadata": {
    "id": "5b2b47ed"
   },
   "source": [
    "The question we must ask ourselves here is: how are agents different than chains?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f73aaf07",
   "metadata": {
    "id": "f73aaf07"
   },
   "source": [
    "If we look at the agent's logic and the prompt we have just printed we will see some clear differences. First, we have the tools which are included in the prompt. Second we have a thought process which was before was immediate in chains but now involves a 'thought', 'action', 'action input', 'observation' sequence. What is this all about?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a698f78",
   "metadata": {
    "id": "3a698f78"
   },
   "source": [
    "Suffice it to say for now that **the LLM now has the ability to 'reason' on how to best use tools** to solve our query and can combine them in intelligent ways with just a brief description of each of them. If you want to learn more about this paradigm (MRKL) in detail, please refer to [this](https://arxiv.org/pdf/2205.00445.pdf) paper."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aff9e65d",
   "metadata": {
    "id": "aff9e65d"
   },
   "source": [
    "Finally, let's pay attention to the 'agent_scratchpad'. What is that? Well, that is where we will be appending every thought or action that the agent has already performed. In this way, at each point in time, the agent will know what it has found out and will be able to continue its thought process. In other words, after using a tool it adds its thoughts and observations to the scratchpad and picks up from there."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04d70642",
   "metadata": {
    "id": "04d70642"
   },
   "source": [
    "### Agent type #2: Conversational React"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ec589b1",
   "metadata": {
    "id": "1ec589b1"
   },
   "source": [
    "The zero shot agent is really interesting but, as we said before, it has no memory. What if we want an assistant that remembers things we have talked about and can also reason about them and use tools? For that we have the conversational react agent."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c26c50f",
   "metadata": {
    "id": "5c26c50f"
   },
   "source": [
    "We will use the math tool in this example and load it as below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "4b6faff3",
   "metadata": {
    "id": "4b6faff3",
    "tags": []
   },
   "outputs": [],
   "source": [
    "from langchain.agents import load_tools\n",
    "\n",
    "tools = load_tools(\n",
    "    [\"llm-math\"],\n",
    "    llm=llm\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be45b903",
   "metadata": {
    "id": "be45b903"
   },
   "source": [
    "The memory type being used here is a simple buffer memory to allow us to remember previous steps in the reasoning chain. For more information on memory, please refer to the previous course on Langchain memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "0aff4edf",
   "metadata": {
    "id": "0aff4edf",
    "tags": []
   },
   "outputs": [],
   "source": [
    "from langchain.memory import ConversationBufferMemory\n",
    "\n",
    "memory = ConversationBufferMemory(memory_key=\"chat_history\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "6579cef0",
   "metadata": {
    "id": "6579cef0",
    "tags": []
   },
   "outputs": [],
   "source": [
    "from langchain.agents import initialize_agent, create_react_agent\n",
    "\n",
    "conversational_agent = initialize_agent(\n",
    "    agent=AgentType.CONVERSATIONAL_REACT_DESCRIPTION,\n",
    "    tools=tools,\n",
    "    llm=llm,\n",
    "    verbose=True,\n",
    "    max_iterations=3,\n",
    "    memory=memory,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "cabbea50",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "cabbea50",
    "outputId": "760bde78-a553-46e0-da3b-433cd0196613",
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
      "\u001b[32;1m\u001b[1;3m\n",
      "Thought: Do I need to use a tool? Yes\n",
      "Action: Calculator\n",
      "Action Input: $10,000, 8%, 5 years, compound interest\u001b[0m\n",
      "Observation: \u001b[36;1m\u001b[1;3mAnswer: 14693.280768000006\u001b[0m\n",
      "Thought:\u001b[32;1m\u001b[1;3m Do I need to use a tool? No\n",
      "AI: The result of an investment of $10,000 growing at 8% annually for 5 years with compound interest is $14,693.28.\u001b[0m\n",
      "\n",
      "\u001b[1m> Finished chain.\u001b[0m\n",
      "Spent a total of 1152 tokens\n"
     ]
    }
   ],
   "source": [
    "result = count_tokens(\n",
    "    conversational_agent,\n",
    "    \"What's the result of an investment of $10,000 growing at 8% annually for 5 years with compound interest?\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdcd9847",
   "metadata": {
    "id": "bdcd9847"
   },
   "source": [
    "As we can see below, the prompt is similar but it includes a great prelude of instructions that make it an effective assistant as well + a spot for including the chat history from the memory component:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "de413fd3",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "de413fd3",
    "outputId": "f79dc083-db80-4dbb-8fb6-da5f6f603645",
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Assistant is a large language model trained by OpenAI.\n",
      "\n",
      "Assistant is designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, Assistant is able to generate human-like text based on the input it receives, allowing it to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.\n",
      "\n",
      "Assistant is constantly learning and improving, and its capabilities are constantly evolving. It is able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. Additionally, Assistant is able to generate its own text based on the input it receives, allowing it to engage in discussions and provide explanations and descriptions on a wide range of topics.\n",
      "\n",
      "Overall, Assistant is a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether you need help with a specific question or just want to have a conversation about a particular topic, Assistant is here to assist.\n",
      "\n",
      "TOOLS:\n",
      "------\n",
      "\n",
      "Assistant has access to the following tools:\n",
      "\n",
      "> Calculator: Useful for when you need to answer questions about math.\n",
      "\n",
      "To use a tool, please use the following format:\n",
      "\n",
      "```\n",
      "Thought: Do I need to use a tool? Yes\n",
      "Action: the action to take, should be one of [Calculator]\n",
      "Action Input: the input to the action\n",
      "Observation: the result of the action\n",
      "```\n",
      "\n",
      "When you have a response to say to the Human, or if you do not need to use a tool, you MUST use the format:\n",
      "\n",
      "```\n",
      "Thought: Do I need to use a tool? No\n",
      "AI: [your response here]\n",
      "```\n",
      "\n",
      "Begin!\n",
      "\n",
      "Previous conversation history:\n",
      "{chat_history}\n",
      "\n",
      "New input: {input}\n",
      "{agent_scratchpad}\n"
     ]
    }
   ],
   "source": [
    "print(conversational_agent.agent.llm_chain.prompt.template)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32ee8041",
   "metadata": {
    "id": "32ee8041"
   },
   "source": [
    "Let's see what happens if we try to answer the question that is related to the previous one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "5e109878",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "5e109878",
    "outputId": "51a80167-1e1b-4717-e3bc-bf25ad1c6cb7",
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
      "\u001b[32;1m\u001b[1;3mThought: Do I need to use a tool? Yes\n",
      "Action: Calculator\n",
      "Action Input: $15,000 * (1 + 0.08)^5 - $10,000 * (1 + 0.08)^5\u001b[0m\n",
      "Observation: \u001b[36;1m\u001b[1;3mAnswer: 7346.640384000004\u001b[0m\n",
      "Thought:\u001b[32;1m\u001b[1;3m Do I need to use a tool? No\n",
      "AI: You would have $7,346.64 more compared to the previous scenario.\u001b[0m\n",
      "\n",
      "\u001b[1m> Finished chain.\u001b[0m\n",
      "Spent a total of 1355 tokens\n"
     ]
    }
   ],
   "source": [
    "result = count_tokens(\n",
    "    conversational_agent,\n",
    "    \"If we start with $15,000 instead and follow the same 8% annual growth for 5 years with compound interest, how much more would we have compared to the previous scenario?\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44135b8d",
   "metadata": {
    "id": "44135b8d"
   },
   "source": [
    "### Agent type #3: React Docstore"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e6d0d13",
   "metadata": {
    "id": "1e6d0d13"
   },
   "source": [
    "This type of agent is similar to the ones we have seen so far but it includes the interaction with a docstore. It will have two and only two tools at its disposal: 'Search' and 'Lookup'."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d569fd41",
   "metadata": {
    "id": "d569fd41"
   },
   "source": [
    "With 'Search' it will bring up a relevant article and with 'Lookup' the agent will find the right piece of information in the article. This is probably easiest to see in an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "ecc452af",
   "metadata": {
    "id": "ecc452af",
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/anaconda3/lib/python3.11/site-packages/langchain_core/_api/deprecation.py:119: LangChainDeprecationWarning: The class `DocstoreExplorer` was deprecated in LangChain 0.1.0 and will be removed in 0.2.0\n",
      "  warn_deprecated(\n"
     ]
    }
   ],
   "source": [
    "from langchain import Wikipedia\n",
    "from langchain.agents.react.base import DocstoreExplorer, Tool\n",
    "\n",
    "docstore=DocstoreExplorer(Wikipedia())\n",
    "tools = [\n",
    "    Tool(\n",
    "        name=\"Search\",\n",
    "        func=docstore.search,\n",
    "        description='search wikipedia'\n",
    "    ),\n",
    "    Tool(\n",
    "        name=\"Lookup\",\n",
    "        func=docstore.lookup,\n",
    "        description='lookup a term in wikipedia'\n",
    "    )\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "595938a1",
   "metadata": {
    "id": "595938a1",
    "tags": []
   },
   "outputs": [],
   "source": [
    "docstore_agent = initialize_agent(\n",
    "    tools,\n",
    "    llm,\n",
    "    agent=\"react-docstore\",\n",
    "    verbose=True,\n",
    "    max_iterations=3\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "bba6b065",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "bba6b065",
    "outputId": "52d4f8f6-b56b-4894-9f18-dc126be884b4",
    "tags": []
   },
   "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 search Archimedes and find his last words.\n",
      "Action: Search[Archimedes]\u001b[0m\n",
      "Observation: \u001b[36;1m\u001b[1;3mArchimedes of Syracuse ( AR-kim-EE-deez; c. 287 – c. 212 BC) was an Ancient Greek mathematician, physicist, engineer, astronomer, and inventor from the ancient city of Syracuse in Sicily. Although few details of his life are known, he is regarded as one of the leading scientists in classical antiquity. Considered the greatest mathematician of ancient history, and one of the greatest of all time, Archimedes anticipated modern calculus and analysis by applying the concept of the infinitely small and the method of exhaustion to derive and rigorously prove a range of geometrical theorems. These include the area of a circle, the surface area and volume of a sphere, the area of an ellipse, the area under a parabola, the volume of a segment of a paraboloid of revolution, the volume of a segment of a hyperboloid of revolution, and the area of a spiral.\n",
      "Archimedes' other mathematical achievements include deriving an approximation of pi, defining and investigating the Archimedean spiral, and devising a system using exponentiation for expressing very large numbers. He was also one of the first to apply mathematics to physical phenomena, working on statics and hydrostatics. Archimedes' achievements in this area include a proof of the law of the lever, the widespread use of the concept of center of gravity, and the enunciation of the law of buoyancy known as Archimedes' principle. He is also credited with designing innovative machines, such as his screw pump, compound pulleys, and defensive war machines to protect his native Syracuse from invasion.\n",
      "Archimedes died during the siege of Syracuse, when he was killed by a Roman soldier despite orders that he should not be harmed. Cicero describes visiting Archimedes' tomb, which was surmounted by a sphere and a cylinder that Archimedes requested be placed there to represent his mathematical discoveries.\n",
      "Unlike his inventions, Archimedes' mathematical writings were little known in antiquity. Mathematicians from Alexandria read and quoted him, but the first comprehensive compilation was not made until c. 530 AD by Isidore of Miletus in Byzantine Constantinople, while commentaries on the works of Archimedes by Eutocius in the 6th century opened them to wider readership for the first time. The relatively few copies of Archimedes' written work that survived through the Middle Ages were an influential source of ideas for scientists during the Renaissance and again in the 17th century, while the discovery in 1906 of previously lost works by Archimedes in the Archimedes Palimpsest has provided new insights into how he obtained mathematical results.\u001b[0m\n",
      "Thought:\u001b[32;1m\u001b[1;3m Archimedes' last words are not mentioned in the paragraph. I need to search \"Archimedes' last words\".\n",
      "Action: Search[Archimedes' last words]\u001b[0m\n",
      "Observation: \u001b[36;1m\u001b[1;3mA person's last words, their final articulated words stated prior to death or as death approaches, are often recorded because of the decedent's fame, but sometimes because of interest in the statement itself. (People dying of illness are frequently inarticulate at the end, and in such cases their actual last utterances may not be recorded or considered very important.) Last words may be recorded accurately, or, for a variety of reasons, may not. Reasons can include simple error or deliberate intent. Even if reported wrongly, putative last words can constitute an important part of the perceived historical records or demonstration of cultural attitudes toward death at the time.\n",
      "Charles Darwin, for example, was reported to have disavowed his theory of evolution in favor of traditional religious faith at his death. This widely disseminated report served the interests of those who opposed Darwin's theory on religious grounds. However, the putative witness had not been at Darwin's deathbed or seen him at any time near the end of his life.\n",
      "Both Eastern and Western cultural traditions ascribe special significance to words uttered at or near death, but the form and content of reported last words may depend on cultural context. There is a tradition in Hindu and Buddhist cultures of an expectation of a meaningful farewell statement; Zen monks by long custom are expected to compose a poem on the spot and recite it with their last breath. In Western culture particular attention has been paid to last words which demonstrate deathbed salvation – the repentance of sins and affirmation of faith.\u001b[0m\n",
      "Thought:\u001b[32;1m\u001b[1;3m The paragraph does not mention Archimedes' last words. I need to search for a reliable source that states his last words.\n",
      "Action: Search[Archimedes' last words reliable source]\u001b[0m\n",
      "Observation: \u001b[36;1m\u001b[1;3mA person's last words, their final articulated words stated prior to death or as death approaches, are often recorded because of the decedent's fame, but sometimes because of interest in the statement itself. (People dying of illness are frequently inarticulate at the end, and in such cases their actual last utterances may not be recorded or considered very important.) Last words may be recorded accurately, or, for a variety of reasons, may not. Reasons can include simple error or deliberate intent. Even if reported wrongly, putative last words can constitute an important part of the perceived historical records or demonstration of cultural attitudes toward death at the time.\n",
      "Charles Darwin, for example, was reported to have disavowed his theory of evolution in favor of traditional religious faith at his death. This widely disseminated report served the interests of those who opposed Darwin's theory on religious grounds. However, the putative witness had not been at Darwin's deathbed or seen him at any time near the end of his life.\n",
      "Both Eastern and Western cultural traditions ascribe special significance to words uttered at or near death, but the form and content of reported last words may depend on cultural context. There is a tradition in Hindu and Buddhist cultures of an expectation of a meaningful farewell statement; Zen monks by long custom are expected to compose a poem on the spot and recite it with their last breath. In Western culture particular attention has been paid to last words which demonstrate deathbed salvation – the repentance of sins and affirmation of faith.\u001b[0m\n",
      "Thought:\u001b[32;1m\u001b[1;3m\u001b[0m\n",
      "\n",
      "\u001b[1m> Finished chain.\u001b[0m\n",
      "Spent a total of 5722 tokens\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'input': \"What were Archimedes' last words?\",\n",
       " 'output': 'Agent stopped due to iteration limit or time limit.'}"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "count_tokens(docstore_agent, \"What were Archimedes' last words?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a5f77ac",
   "metadata": {
    "id": "6a5f77ac"
   },
   "source": [
    "We will not print the prompt here because it is too large, but you can see it yourself if you want to (we know how to already).\n",
    "\n",
    "In short, it contains several examples of the `Question` > `Thought` > `Action` > `Observation` loop, that include the `Search` and `Lookup` tools.\n",
    "\n",
    "If you want to learn more about this approach [this](https://arxiv.org/pdf/2210.03629.pdf) is the paper for ReAct"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4aae3b5b",
   "metadata": {
    "id": "4aae3b5b"
   },
   "source": [
    "### Agent type #4: Self Ask with Search"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c07039e5",
   "metadata": {
    "id": "c07039e5"
   },
   "source": [
    "This is the first-choice agent to use when using LLM's to extract information with a search engine. The agent will ask follow-up questions and use the search functionality to get intermediate answers that help it get to a final answer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "903660b2",
   "metadata": {
    "id": "903660b2",
    "tags": []
   },
   "outputs": [],
   "source": [
    "from langchain import OpenAI, SerpAPIWrapper\n",
    "from langchain.agents import initialize_agent, Tool\n",
    "\n",
    "search = SerpAPIWrapper(serpapi_api_key='api_key')\n",
    "tools = [\n",
    "    Tool(\n",
    "        name=\"Intermediate Answer\",\n",
    "        func=search.run,\n",
    "        description='google search'\n",
    "    )\n",
    "]\n",
    "\n",
    "self_ask_with_search = initialize_agent(tools, llm, agent=\"self-ask-with-search\", verbose=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ec1c4c8",
   "metadata": {
    "id": "0ec1c4c8"
   },
   "source": [
    "We will not interact with this agent because for that we would need a serpapi key. However, by checking out the prompt we can see a few examples of how it works:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "e4134930",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "e4134930",
    "outputId": "2f58884d-0c4e-4b40-de45-6928e0c60ef4",
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Question: Who lived longer, Muhammad Ali or Alan Turing?\n",
      "Are follow up questions needed here: Yes.\n",
      "Follow up: How old was Muhammad Ali when he died?\n",
      "Intermediate answer: Muhammad Ali was 74 years old when he died.\n",
      "Follow up: How old was Alan Turing when he died?\n",
      "Intermediate answer: Alan Turing was 41 years old when he died.\n",
      "So the final answer is: Muhammad Ali\n",
      "\n",
      "Question: When was the founder of craigslist born?\n",
      "Are follow up questions needed here: Yes.\n",
      "Follow up: Who was the founder of craigslist?\n",
      "Intermediate answer: Craigslist was founded by Craig Newmark.\n",
      "Follow up: When was Craig Newmark born?\n",
      "Intermediate answer: Craig Newmark was born on December 6, 1952.\n",
      "So the final answer is: December 6, 1952\n",
      "\n",
      "Question: Who was the maternal grandfather of George Washington?\n",
      "Are follow up questions needed here: Yes.\n",
      "Follow up: Who was the mother of George Washington?\n",
      "Intermediate answer: The mother of George Washington was Mary Ball Washington.\n",
      "Follow up: Who was the father of Mary Ball Washington?\n",
      "Intermediate answer: The father of Mary Ball Washington was Joseph Ball.\n",
      "So the final answer is: Joseph Ball\n",
      "\n",
      "Question: Are both the directors of Jaws and Casino Royale from the same country?\n",
      "Are follow up questions needed here: Yes.\n",
      "Follow up: Who is the director of Jaws?\n",
      "Intermediate answer: The director of Jaws is Steven Spielberg.\n",
      "Follow up: Where is Steven Spielberg from?\n",
      "Intermediate answer: The United States.\n",
      "Follow up: Who is the director of Casino Royale?\n",
      "Intermediate answer: The director of Casino Royale is Martin Campbell.\n",
      "Follow up: Where is Martin Campbell from?\n",
      "Intermediate answer: New Zealand.\n",
      "So the final answer is: No\n",
      "\n",
      "Question: {input}\n",
      "Are followup questions needed here:{agent_scratchpad}\n"
     ]
    }
   ],
   "source": [
    "print(self_ask_with_search.agent.llm_chain.prompt.template)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e7790ae",
   "metadata": {
    "id": "3e7790ae"
   },
   "source": [
    "As we can see, the prompt is basically a series of many examples to show the LLM how to ask follow up questions to a search tool until it can get to the final answer."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5df324ba",
   "metadata": {
    "id": "5df324ba"
   },
   "source": [
    "And.. again [here](https://arxiv.org/pdf/2210.03350.pdf) you have the paper to dive deeper!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cd80a08",
   "metadata": {
    "id": "4cd80a08"
   },
   "source": [
    "### Wrapping up"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97d108e2",
   "metadata": {
    "id": "97d108e2"
   },
   "source": [
    "And that all for agents! There's many other things you can do with agents, just to name a few:\n",
    "* Create your own custom agent\n",
    "* Use them with many other tools (even custom ones)\n",
    "* Trace every call an agent makes through a convinient UI interface"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.8"
  },
  "vscode": {
   "interpreter": {
    "hash": "578e1e8dce4dc6c542f1ea2d66a2d9db6ef592936dcc314004bdae386f827d38"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}