10-API-Search.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "66ab3cc5-aee4-415a-9391-1e5d37ccaf1d",
   "metadata": {},
   "source": [
    "# Skill 5: API Search - Make our bot to talk to any API"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "306fc0a9-4044-441d-9ba7-f54f32e6ea9f",
   "metadata": {},
   "source": [
    "We have observed the remarkable synergy created by combining **GPT llms with intelligent agents and detailed prompts**. This powerful combination has consistently delivered impressive results. To further capitalize on this capability, we should aim to integrate it with various systems through API communication. Essentially, we can develop within this notebook what is referred to in OpenAI's ChatGPT as 'GPTs.'\n",
    "\n",
    "Envision a bot that seamlessly integrates with:\n",
    "\n",
    "- **CRM Systems:** Including Dynamics, Salesforce, and HubSpot.\n",
    "- **ERP Systems:** Such as SAP, Dynamics, and Oracle.\n",
    "- **CMS Systems:** Including Adobe, Oracle, and other content management platforms.\n",
    "\n",
    "The objective is to connect our bot with data repositories, minimizing data duplication as much as possible. These systems typically offer APIs, facilitating programmatic data access.\n",
    "\n",
    "In this notebook, we plan to develop an agent capable of querying an API to retrieve information and effectively answer questions.\n",
    "This time we are going to use an open API for currency and digital coins pricing: https://docs.kraken.com/rest/#tag/Market-Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c1fb79a3-4856-4721-988c-112813690a90",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import json\n",
    "import requests\n",
    "from time import sleep\n",
    "from typing import Dict, List\n",
    "from pydantic import BaseModel, Extra, root_validator\n",
    "\n",
    "from langchain_openai import AzureChatOpenAI\n",
    "from langchain.agents import AgentExecutor, create_openai_tools_agent\n",
    "from langchain.callbacks.manager import CallbackManager\n",
    "from langchain.agents import initialize_agent, AgentType\n",
    "from langchain.tools import BaseTool\n",
    "from langchain.requests import RequestsWrapper\n",
    "from langchain.chains import APIChain\n",
    "\n",
    "from common.callbacks import StdOutCallbackHandler\n",
    "from common.utils import num_tokens_from_string, reduce_openapi_spec\n",
    "from common.prompts import APISEARCH_PROMPT\n",
    "\n",
    "from IPython.display import Markdown, HTML, display  \n",
    "\n",
    "from dotenv import load_dotenv\n",
    "load_dotenv(\"credentials.env\")\n",
    "\n",
    "def printmd(string):\n",
    "    display(Markdown(string.replace(\"$\",\"USD \")))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "258a6e99-2d4f-4147-b8ee-c64c85296181",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set the ENV variables that Langchain needs to connect to Azure OpenAI\n",
    "os.environ[\"OPENAI_API_VERSION\"] = os.environ[\"AZURE_OPENAI_API_VERSION\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9d3daf03-77e2-466e-a255-2f06bee3561b",
   "metadata": {},
   "outputs": [],
   "source": [
    "cb_handler = StdOutCallbackHandler()\n",
    "cb_manager = CallbackManager(handlers=[cb_handler])\n",
    "\n",
    "COMPLETION_TOKENS = 2000\n",
    "\n",
    "\n",
    "# This notebook needs GPT-4-Turbo (context size of 128k tokens)\n",
    "llm = AzureChatOpenAI(deployment_name=os.environ[\"GPT4_DEPLOYMENT_NAME\"], \n",
    "                      temperature=0.5, max_tokens=COMPLETION_TOKENS, \n",
    "                      streaming=True, callback_manager=cb_manager)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9cc03401-a5a9-455b-bf17-07da2005e61f",
   "metadata": {},
   "source": [
    "## The Logic"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ebe42eda-3e74-4114-bd25-2473593cc1b4",
   "metadata": {},
   "source": [
    "By now, you must infer that the solution for an API Agent has to be something like: give the API specification as part of the system prompt to the LLM , then have an agent plan for the right steps to formulate the API call.<br>\n",
    "\n",
    "Let's do that. But we must first understand the industry standards of Swagger/OpenAPI\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e8e0b32-a6b5-4b1c-943d-e57b737213fa",
   "metadata": {},
   "source": [
    "## Introduction to OpenAPI (formerly Swagger)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "003327ac-2851-48ef-8a6b-2d8c2004bb2e",
   "metadata": {},
   "source": [
    "The OpenAPI Specification, previously known as the Swagger Specification, is a specification for a machine-readable interface definition language for describing, producing, consuming and visualizing web services. Previously part of the Swagger framework, it became a separate project in 2016, overseen by the OpenAPI Initiative, an open-source collaboration project of the Linux Foundation.\n",
    "\n",
    "OpenAPI Specification is an API description format for REST APIs. An OpenAPI file allows you to describe your entire API, including: Available endpoints (/users for example) and operations on each endpoint ( GET /users, POST /users), description, contact information, license, terms of use and other information."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1902af5-f889-4bcf-85e0-1b601bd2ce47",
   "metadata": {},
   "source": [
    "### Let's get the OpenAPI (Swagger) spec from our desired API that we want to talk to\n",
    "You can also download it from the Kraken website: https://docs.kraken.com/rest/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8efd8698-aea1-4de3-b810-e9c4782f04c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "url = \"https://datasetsgptsmartsearch.blob.core.windows.net/apispecs/openapi_kraken.json\"\n",
    "response = requests.get(url + os.environ['BLOB_SAS_TOKEN'])\n",
    "\n",
    "# Check if the request was successful\n",
    "if response.status_code == 200:\n",
    "    spec = response.json()\n",
    "else:\n",
    "    spec = None\n",
    "    print(f\"Failed to retrieve data: Status code {response.status_code}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd3cab16-e71d-4652-ab27-7b0704365454",
   "metadata": {},
   "source": [
    "Let's see how big is this API specification:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "94503afc-c398-458a-b369-610c5dbe682d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can check the function \"reduce_openapi_spec()\" in utils.py\n",
    "reduced_api_spec = reduce_openapi_spec(spec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "57d77e9b-6f3f-4ec4-bc01-baac18984937",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "API spec size in tokens: 66625\n",
      "Reduced API spec size in tokens: 57394\n"
     ]
    }
   ],
   "source": [
    "api_tokens = num_tokens_from_string(str(spec))\n",
    "print(\"API spec size in tokens:\",api_tokens)\n",
    "api_tokens = num_tokens_from_string(str(reduced_api_spec))\n",
    "print(\"Reduced API spec size in tokens:\",api_tokens)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8b95356-587d-43ca-982f-500779078482",
   "metadata": {},
   "source": [
    "Sometimes it makes sense to reduce the size of the API Specs by using the `reduce_openapi_spec` function. It's optional."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd8c3b3e-959e-4b19-b34d-66de3501b1b1",
   "metadata": {},
   "source": [
    "#### NOTE: As you can see, a large context LLM is needed. `GPT4-turbo` is necessary for this notebook to run succesfully."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a945386-39eb-405d-9310-3b67c9af77bb",
   "metadata": {},
   "source": [
    "## Question\n",
    "Let's make a complicated question that requires two distinct API calls to different endpoints:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d020b5de-7ebe-4fb9-9b71-f6c71956149d",
   "metadata": {},
   "outputs": [],
   "source": [
    "QUESTION = \"\"\"\n",
    "Tell me the price of bitcoin against USD , also the latest OHLC values for Ethereum,\n",
    "also me also the bid and ask for Euro\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d467f57a-7a03-431a-abe9-ca552e71aed0",
   "metadata": {},
   "source": [
    "## Use a chain to convert the natural language question to an API request using the API specification in the prompt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "695c47b3-191a-430d-8691-a255152ffee9",
   "metadata": {},
   "source": [
    "We can use a nice chain in langchain called APIChain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "96731b5f-988b-49ec-a5c3-3a344b7085da",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Most of APIs require Authorization tokens, so we construct the headers using a lightweight python request wrapper called RequestsWrapper\n",
    "access_token = \"ABCDEFG123456\" \n",
    "headers = {\"Authorization\": f\"Bearer {access_token}\"}\n",
    "requests_wrapper = RequestsWrapper(headers=headers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "426fab6f-ea04-4c07-8211-d9cc5c70ac8e",
   "metadata": {},
   "outputs": [],
   "source": [
    "chain = APIChain.from_llm_and_api_docs(\n",
    "    llm=llm,\n",
    "    api_docs=str(reduced_api_spec),\n",
    "    headers=headers,\n",
    "    verbose=False,\n",
    "    limit_to_domains=None,\n",
    "    callback_manager=cb_manager\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1707e590-809b-4391-bdcd-c7d285ec8fb1",
   "metadata": {},
   "source": [
    "These are the prompts on the APIChain class (one to create the URL endpoint and the other one to use it and get the answer):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "9f80d2bb-e285-4d30-88c8-5677e86cebe2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'You are given the below API Documentation:\\n{api_docs}\\nUsing this documentation, generate the full API url to call for answering the user question.\\nYou should build the API url in order to get a response that is as short as possible, while still getting the necessary information to answer the question. Pay attention to deliberately exclude any unnecessary pieces of data in the API call.\\n\\nQuestion:{question}\\nAPI url:'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chain.api_request_chain.prompt.template"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ccc7e9dc-f36b-45e1-867a-1b92d639e941",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'You are given the below API Documentation:\\n{api_docs}\\nUsing this documentation, generate the full API url to call for answering the user question.\\nYou should build the API url in order to get a response that is as short as possible, while still getting the necessary information to answer the question. Pay attention to deliberately exclude any unnecessary pieces of data in the API call.\\n\\nQuestion:{question}\\nAPI url: {api_url}\\n\\nHere is the response from the API:\\n\\n{api_response}\\n\\nSummarize this response to answer the original question.\\n\\nSummary:'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chain.api_answer_chain.prompt.template"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "d7f60335-5551-4ee0-ba4e-1cd84f3a9f48",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "To get the price of Bitcoin against USD, we will use the `Ticker` endpoint. The `pair` parameter should specify `XXBTZUSD` which is the pair for Bitcoin against USD.\n",
      "\n",
      "For the latest OHLC values for Ethereum, we will use the `OHLC` endpoint. The `pair` parameter should specify `XETHZUSD` which is the pair for Ethereum against USD.\n",
      "\n",
      "For the bid and ask for Euro, we will use the `Ticker` endpoint again. The `pair` parameter should specify `ZEURZUSD` which is the pair for Euro against USD.\n",
      "\n",
      "Since we want to make the response as short as possible, we will only include the necessary pairs in the `pair` parameter for each call.\n",
      "\n",
      "API url for Bitcoin price against USD (Ticker):\n",
      "```\n",
      "https://api.kraken.com/0/public/Ticker?pair=XXBTZUSD\n",
      "```\n",
      "\n",
      "API url for the latest OHLC values for Ethereum (OHLC):\n",
      "```\n",
      "https://api.kraken.com/0/public/OHLC?pair=XETHZUSD&interval=1\n",
      "```\n",
      "\n",
      "API url for the bid and ask for Euro (Ticker):\n",
      "```\n",
      "https://api.kraken.com/0/public/Ticker?pair=ZEURZUSD\n",
      "```\n",
      "\n",
      "Please note that these URLs should be used with a `GET` request."
     ]
    }
   ],
   "source": [
    "try:\n",
    "    chain.invoke(QUESTION)\n",
    "except Exception as e:\n",
    "    response = str(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70d364b5-b7f8-4f14-8501-187fdda97ecd",
   "metadata": {},
   "source": [
    "As we have seen before in prior notebooks, a single chain cannot reason/observe/think/retry, so it cannot call multiple endpoints and it doesn't retry or reflect on errors."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ccdb128-7700-4e37-b378-490051348daa",
   "metadata": {},
   "source": [
    "## Creating a custom agent that uses the APIChain as a tool\n",
    "\n",
    "To solve the avobe problem, we can build a REACT Agent that uses the APIChain as a tool to get the information. This agent will create as many calls as needed (using the chain tool) until it answers the question"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "d3d155ae-16eb-458a-b2ed-5aa9a9b84ed8",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyAPISearch(BaseTool):\n",
    "    \"\"\"APIChain as an agent tool\"\"\"\n",
    "    \n",
    "    name = \"apisearch\"\n",
    "    description = \"useful when the questions includes the term: apisearch.\\n\"\n",
    "\n",
    "    llm: AzureChatOpenAI\n",
    "    api_spec: str\n",
    "    headers: dict = {}\n",
    "    limit_to_domains: list = None\n",
    "    verbose: bool = False\n",
    "    \n",
    "    def _run(self, query: str) -> str:\n",
    "        \n",
    "        chain = APIChain.from_llm_and_api_docs(\n",
    "                            llm=self.llm,\n",
    "                            api_docs=self.api_spec,\n",
    "                            headers=self.headers,\n",
    "                            verbose=self.verbose,\n",
    "                            limit_to_domains=self.limit_to_domains\n",
    "                            )\n",
    "        try:\n",
    "            sleep(2) # This is optional to avoid possible TPM rate limits\n",
    "            response = chain.invoke(query)\n",
    "        except Exception as e:\n",
    "            response = e\n",
    "        \n",
    "        return response\n",
    "            \n",
    "    async def _arun(self, query: str) -> str:\n",
    "        \"\"\"Use the tool asynchronously.\"\"\"\n",
    "        raise NotImplementedError(\"This Tool does not support async\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b553cd34-d9c1-4ec8-858f-f6cc0126bc1e",
   "metadata": {},
   "source": [
    "Notice below that we are using GPT-35-Turbo-16k (llm_2) for the Tool and GPT-4-turbo (llm_1) for the Agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "2c6cf721-76bb-47b6-aeeb-9ff4ff92b1f4",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "tools = [MyAPISearch(llm=llm, api_spec=str(reduced_api_spec), limit_to_domains=None)]\n",
    "agent = create_openai_tools_agent(llm, tools, APISEARCH_PROMPT)\n",
    "agent_executor = AgentExecutor(agent=agent, tools=tools, \n",
    "                               return_intermediate_steps=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "ca910f71-60fb-4758-b4a9-757e37eb421f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "https://api.kraken.com/0/public/Ticker?pair=XBTUSDThe current Bitcoin price in USD is $63,475.90.https://api.kraken.com/0/public/OHLC?pair=ETHUSDThe latest Ethereum OHLC (Open/High/Low/Close) values are as follows:\n",
      "\n",
      "- Open: $3466.34\n",
      "- High: $3466.34\n",
      "- Low: $3466.34\n",
      "- Close: $3466.34\n",
      "\n",
      "These values are for the most recent time frame available from the data provided.To get the current bid and ask price for Euro, you would use the Ticker endpoint to retrieve the information for the asset pair that includes Euro. Assuming the asset pair for Euro to USD is \"EURUSD\", the API URL would be:\n",
      "\n",
      "```\n",
      "https://api.kraken.com/0/public/Ticker?pair=EURUSD\n",
      "``` \n",
      "\n",
      "However, if the exact pair code for Euro to USD is different on Kraken, you would need to replace \"EURUSD\" with the correct pair code used by Kraken.### Bitcoin Price in USD\n",
      "The current Bitcoin price in USD is **USD 63,475.90**.\n",
      "\n",
      "### Ethereum OHLC Values\n",
      "The latest Ethereum OHLC (Open/High/Low/Close) values are:\n",
      "\n",
      "- **Open**: USD 3466.34\n",
      "- **High**: USD 3466.34\n",
      "- **Low**: USD 3466.34\n",
      "- **Close**: USD 3466.34\n",
      "\n",
      "These values are for the most recent time frame available from the data provided.\n",
      "\n",
      "### Bid and Ask Price for Euro\n",
      "Unfortunately, I was unable to retrieve the current bid and ask price for the Euro. However, typically this information can be found using financial APIs or market data services. If you are looking for this information, financial platforms like Kraken provide an API endpoint where you can get the latest bid and ask prices for currency pairs, including the Euro to USD (EURUSD)."
     ]
    },
    {
     "data": {
      "text/markdown": [
       "### Bitcoin Price in USD\n",
       "The current Bitcoin price in USD is **USD 63,475.90**.\n",
       "\n",
       "### Ethereum OHLC Values\n",
       "The latest Ethereum OHLC (Open/High/Low/Close) values are:\n",
       "\n",
       "- **Open**: USD 3466.34\n",
       "- **High**: USD 3466.34\n",
       "- **Low**: USD 3466.34\n",
       "- **Close**: USD 3466.34\n",
       "\n",
       "These values are for the most recent time frame available from the data provided.\n",
       "\n",
       "### Bid and Ask Price for Euro\n",
       "Unfortunately, I was unable to retrieve the current bid and ask price for the Euro. However, typically this information can be found using financial APIs or market data services. If you are looking for this information, financial platforms like Kraken provide an API endpoint where you can get the latest bid and ask prices for currency pairs, including the Euro to USD (EURUSD)."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 884 ms, sys: 68.6 ms, total: 953 ms\n",
      "Wall time: 2min 10s\n"
     ]
    }
   ],
   "source": [
    "%%time \n",
    "\n",
    "#As LLMs responses are never the same, we do a for loop in case the answer cannot be parsed according to our prompt instructions\n",
    "for i in range(2):\n",
    "    try:\n",
    "        response = agent_executor.invoke({\"question\":QUESTION})[\"output\"]\n",
    "        break\n",
    "    except Exception as e:\n",
    "        response = str(e)\n",
    "        continue\n",
    "        \n",
    "printmd(response)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73027201-d6e2-4aa0-a480-934c53ae4eb8",
   "metadata": {},
   "source": [
    "**Great!!** we have now an API Agent using APIChain as a tool, capable of reasoning until it can find the answer."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9ba3e35-8021-4262-8494-d1aee3862f7e",
   "metadata": {},
   "source": [
    "## Simple APIs\n",
    "\n",
    "What happens if the API is quite basic, meaning it's just a simple endpoint without a Swagger/OpenAPI definition? Let’s consider the following example:\n",
    "\n",
    "[CountdownAPI](https://www.countdownapi.com/) is a streamlined version of the eBay API, available as a paid service. We can test it using their demo query, which does not require any Swagger or OpenAPI specification. In this scenario, our main task is to create a tool that retrieves the results. We then pass these results to an agent for analysis, providing answers to user queries, similar to our approach with the Bing Search agent.\n",
    "\n",
    "An aspect we haven't discussed yet while constructing our API Agent using the APIChain tool is handling situations where either the API specification or the API call results are quite extensive. In such cases, we need to choose between using GPT-4-32k and GPT-4-Turbo.\n",
    "\n",
    "In the example below, there is no API specification, but the response from the API is rather lengthy. For this scenario, we will employ GPT-4-32k."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "9782fafa-9453-46be-b9d7-b33088f61ac8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Token count: 14459 \n",
      "\n",
      "{\"request_info\": {\"success\": true, \"demo\": true}, \"request_parameters\": {\"type\": \"search\", \"ebay_domain\": \"ebay.com\", \"search_term\": \"memory cards\"}, \"request_metadata\": {\"ebay_url\": \"https://www.ebay.com/sch/i.html?_nkw=memory+cards&_sacat=0&_dmd=1&_fcid=1\"}, \"search_results\": [{\"position\": 1, \"title\": \"Sandisk Micro SD Card Memory 32GB 64GB 128GB 256GB 512GB 1TB Lot Extreme Ultra\", \"epid\": \"203914554350\", \"link\": \"https://www.ebay.com/itm/203914554350\", \"image\": \"https://i.ebayimg.com/thumbs/images/g/A7wAAOSwemNjTz~l/s-l300.jpg\", \"condition\": \"Brand New\", \"seller_info\": {\"name\": \"terashack\", \"review_count\": 60445, \"positive_feedback_percent\": 100}, \"is_auction\": false, \"buy_it_now\": false, \"free_returns\": true, \"sponsored\": true, \"prices\": [{\"value\": 9.99, \"raw\": \"$9.99\"}, {\"value\": 438.99, \"raw\": \"$438.99\"}], \"price\": {\"value\": 9.99, \"raw\": \"$9.99\"}}, {\"position\": 2, \"title\": \"Gigastone 128GB SD Card, Memory Card for Cameras, Full HD Video, SDXC U1 Class10\", \"epid\": \"313264869008\", \"link\": \"https://www.ebay.com/itm/313264869008\", \"image\": \"https://i.ebayimg.com/thumbs/images/g/t~AAAOSw9opfjasq/s-l300.jpg\", \"condition\": \"Brand New\", \"seller_info\": {\"name\": \"gigastoneadmin\", \"review_count\": 2902, \"positive_feedback_percent\": 99.4}, \"is_auction\": false, \"buy_it_now\": false, \"free_returns\": true, \"sponsored\": true, \"prices\": [{\"value\": 18.98, \"raw\": \"$18.98\"}], \"price\": {\"value\": 18.98, \"raw\": \"$18.98\"}}, {\"position\": 3, \"title\": \"SanDIsk SDHC/SDXC Memory Card 64GB - SDSDB-064G-B35\", \"epid\": \"296054022057\", \"link\": \"https://www.ebay.com/itm/296054022057\", \"image\": \"https://i.ebayimg.com/thumbs/images/g/ecsAAOSwFwdlV9pE/s-l300.jpg\", \"hotness\": \"Direct from Western Digital\", \"condition\": \"Brand New\", \"seller_info\": {\"name\": \"wd\", \"review_count\": 39265, \"positive_feedback_percent\": 98.6}, \"is_auction\": false, \"buy_it_now\": false, \"free_returns\": true, \"shipping_cost\": 6, \"rating\": 4.5, \"ratings_total\": 52, \"sponsored\": true, \"prices\": [{\"value\": 9.49, \"raw\": \"$9.49\"}],  ...\n"
     ]
    }
   ],
   "source": [
    "# set up the request parameters\n",
    "params = {\n",
    "  'api_key': 'demo',\n",
    "  'type': 'search',\n",
    "  'ebay_domain': 'ebay.com',\n",
    "  'search_term': 'memory cards'\n",
    "}\n",
    "\n",
    "# make the http GET request to Countdown API\n",
    "api_result = requests.get('https://api.countdownapi.com/request', params)\n",
    "\n",
    "num_tokens = num_tokens_from_string(str(api_result.json())) # this is a custom function we created in common/utils.py\n",
    "print(\"Token count:\",num_tokens,\"\\n\")  \n",
    "\n",
    "# print the first 2000 characters of JSON response from Countdown API\n",
    "print(json.dumps(api_result.json())[:2000], \"...\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57cf8aaa-9a16-48ad-9846-bbacec82d52f",
   "metadata": {},
   "source": [
    "So, the answer from this product query (the demo only works with 'memory cards' - you will need to sign up for their trial if you want to try any query with an API key), is about 16.5k tokens. When combined with the prompt, we won't have any other option than to use GPT-4-32k or GPT-4 turbo models. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "67c51a32-13f5-4802-84cd-ce40b397cb1b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MySimpleAPISearch(BaseTool):\n",
    "    \"\"\"Tool for simple API calls that doesn't require OpenAPI 3.0 specs\"\"\"\n",
    "    \n",
    "    name = \"apisearch\"\n",
    "    description = \"useful when the questions includes the term: apisearch.\\n\"\n",
    "\n",
    "    api_key: str\n",
    "    \n",
    "    def _run(self, query: str) -> str:\n",
    "        \n",
    "        params = {\n",
    "          'api_key': self.api_key,\n",
    "          'type': 'search',\n",
    "          'ebay_domain': 'ebay.com',\n",
    "          'search_term': query\n",
    "        }\n",
    "\n",
    "        # make the http GET request to Countdown API\n",
    "        api_result = requests.get('https://api.countdownapi.com/request', params)\n",
    "        \n",
    "        try:\n",
    "            response = json.dumps(api_result.json())\n",
    "        except Exception as e:\n",
    "            response = e\n",
    "        \n",
    "        return response\n",
    "            \n",
    "    async def _arun(self, query: str) -> str:\n",
    "        \"\"\"Use the tool asynchronously.\"\"\"\n",
    "        raise NotImplementedError(\"This Tool does not support async\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "c0daa409-a196-4eae-aaac-b4545d0e3280",
   "metadata": {},
   "outputs": [],
   "source": [
    "tools = [MySimpleAPISearch(api_key='demo')]\n",
    "agent = create_openai_tools_agent(llm, tools, APISEARCH_PROMPT)\n",
    "agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=False, return_intermediate_steps=True )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6a0f773-7957-469a-a8bc-911a68ce0b98",
   "metadata": {},
   "source": [
    "This time let's use the .stream() method "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "71a1d824-7257-4a6b-8b0c-cd5176136ac7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling Tool: `apisearch` with input `SanDisk memory cards price`\n",
      "---\n",
      "Here are some options for SanDisk memory cards with their prices and links to purchase them:\n",
      "\n",
      "1. **Sandisk Micro SD Card Memory**\n",
      "   - Price: USD 9.99 to USD 438.99\n",
      "   - [Buy on eBay](https://www.ebay.com/itm/203914554350)\n",
      "\n",
      "2. **SanDisk Micro SD Card for Smartphones Tablets**\n",
      "   - Price: USD 5.20 to USD 18.90\n",
      "   - [Buy on eBay](https://www.ebay.com/itm/324736594273)\n",
      "\n",
      "3. **Lot of 4 SanDisk Secure Digital Ultra 64GB Memory Card**\n",
      "   - Price: USD 25.95\n",
      "   - [Buy on eBay](https://www.ebay.com/itm/386454457401)\n",
      "\n",
      "4. **SanDisk Industrial Micro SD Memory Card Class 10 UHS-I**\n",
      "   - Price: USD 9.82 to USD 366.39\n",
      "   - [Buy on eBay](https://www.ebay.com/itm/274312158070)\n",
      "\n",
      "5. **Sandisk Micro SD Card Ultra Memory Card Wholesale lot**\n",
      "   - Price: USD 2.48 to USD 514.20\n",
      "   - [Buy on eBay](https://www.ebay.com/itm/195635604530)\n",
      "\n",
      "Please note that prices are subject to change and may vary based on the seller, condition of the card, and any ongoing promotions or sales. The provided links will take you to eBay where you can view more details and complete your purchase."
     ]
    },
    {
     "data": {
      "text/markdown": [
       "Final Output: Here are some options for SanDisk memory cards with their prices and links to purchase them:\n",
       "\n",
       "1. **Sandisk Micro SD Card Memory**\n",
       "   - Price: USD 9.99 to USD 438.99\n",
       "   - [Buy on eBay](https://www.ebay.com/itm/203914554350)\n",
       "\n",
       "2. **SanDisk Micro SD Card for Smartphones Tablets**\n",
       "   - Price: USD 5.20 to USD 18.90\n",
       "   - [Buy on eBay](https://www.ebay.com/itm/324736594273)\n",
       "\n",
       "3. **Lot of 4 SanDisk Secure Digital Ultra 64GB Memory Card**\n",
       "   - Price: USD 25.95\n",
       "   - [Buy on eBay](https://www.ebay.com/itm/386454457401)\n",
       "\n",
       "4. **SanDisk Industrial Micro SD Memory Card Class 10 UHS-I**\n",
       "   - Price: USD 9.82 to USD 366.39\n",
       "   - [Buy on eBay](https://www.ebay.com/itm/274312158070)\n",
       "\n",
       "5. **Sandisk Micro SD Card Ultra Memory Card Wholesale lot**\n",
       "   - Price: USD 2.48 to USD 514.20\n",
       "   - [Buy on eBay](https://www.ebay.com/itm/195635604530)\n",
       "\n",
       "Please note that prices are subject to change and may vary based on the seller, condition of the card, and any ongoing promotions or sales. The provided links will take you to eBay where you can view more details and complete your purchase."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---\n"
     ]
    }
   ],
   "source": [
    "for chunk in agent_executor.stream({\"question\": 'what is the price for SanDisk \"memory cards\"? give me the links please', \"language\":\"English\"}):\n",
    "    # Agent Action\n",
    "    if \"actions\" in chunk:\n",
    "        for action in chunk[\"actions\"]:\n",
    "            print(f\"Calling Tool: `{action.tool}` with input `{action.tool_input}`\")\n",
    "    # Observation\n",
    "    elif \"steps\" in chunk:\n",
    "        continue\n",
    "        # for step in chunk[\"steps\"]:\n",
    "        #     print(f\"Tool Result: `{step.observation}`\")\n",
    "    # Final result\n",
    "    elif \"output\" in chunk:\n",
    "        printmd(f'Final Output: {chunk[\"output\"]}')\n",
    "    else:\n",
    "        raise ValueError()\n",
    "    print(\"---\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56cbc405-26e2-471e-9626-2a0df07f5ddc",
   "metadata": {},
   "source": [
    "# Summary"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7381ea5f-7269-4e1f-8b0c-1e2c04bd84c0",
   "metadata": {},
   "source": [
    "In this notebook, we learned about how to create very smart API agents for simple or complex APIs that use Swagger or OpenAPI specifications.\n",
    "We see, again, that the key to success is to use: Agents with Expert tools + GPT-4 + good prompts.\n",
    "\n",
    "As homework, try to create a shopping assistant for Etsy e-commerce site using the following API spec: (you will need to register for free and create an API-Key)\n",
    "\n",
    "- https://developers.etsy.com/documentation/\n",
    "- https://www.etsy.com/openapi/generated/oas/3.0.0.json"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02073623-91b4-40d6-8eaf-cb6d9c6a7a9a",
   "metadata": {},
   "source": [
    "# NEXT\n",
    "\n",
    "The Next Notebook will guide you on how we stick everything together. How do we use the features of all notebooks and create a brain agent that can respond to any request accordingly."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10 - SDK v2",
   "language": "python",
   "name": "python310-sdkv2"
  },
  "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.10.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}