11-Smart_Agent.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6423f8f3-a592-4ee7-9969-39e38933be52",
   "metadata": {},
   "source": [
    "# Putting it all together"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06bf854d-94d7-4a65-952a-22c7999a9a9b",
   "metadata": {},
   "source": [
    "So far we have done the following on the prior Notebooks:\n",
    "\n",
    "- **Notebook 01**: We loaded the Azure Search Engine with enriched PDFs in index: \"cogsrch-index-files\"\n",
    "- **Notebook 02**: We loaded more information to the Search Engine this time using a CSV file with 90k rows/articles in index: \"cogsrch-index-csv\"\n",
    "- **Notebook 03**: We added AzureOpenAI GPT models to enhance the the production of the answer by using Utility Chains of LLMs\n",
    "- **Notebook 04**: We manually loaded an index with large/complex PDFs information , \"cogsrch-index-books-vector\"\n",
    "- **Notebook 05**: We added memory to our system in order to power a conversational Chat Bot\n",
    "- **Notebook 06**: We introduced Agents and Tools and built the first Skill/Agent, that can do RAG over a search engine\n",
    "- **Notebook 07**: We build a second Agent (Pandas) in order to be able to solve a more complex task: ask questions to Tabular datasets\n",
    "- **Notebook 08**: We used a SQL Agent in order to talk to a SQL Database directly\n",
    "- **Notebook 09**: We used another  Agent in order to talk to the Bing Search API and create a Bing Chat Clone and implemented callbacks for real-time streaming and tool information\n",
    "- **Notebook 10**: We built an API Agent that can translate a question into the right API calls, giving us the capability to talk to any datasource that provides a RESTFul API.\n",
    "\n",
    "\n",
    "We are missing one more thing: **How do we glue all these features together into a very smart GPT Smart Search Engine Chat Bot?**\n",
    "\n",
    "We want a virtual assistant for our company that can get the question, think what tool to use, then get the answer. The goal is that, regardless of the source of the information (Search Engine, Bing Search, SQL Database, CSV File, JSON File, APIs, etc), the Assistant can answer the question correctly using the right tool.\n",
    "\n",
    "In this Notebook we are going to create that \"brain\" Agent (also called Master Agent), that:\n",
    "\n",
    "1) understands the question, interacts with the user \n",
    "2) talks to other specialized Agents that are connected to diferent sources\n",
    "3) once it get's the answer it delivers it to the user or let the specialized Agent to deliver it directly\n",
    "\n",
    "This is the same concept of [AutoGen](https://www.microsoft.com/en-us/research/blog/autogen-enabling-next-generation-large-language-model-applications/): Agents talking to each other."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d7fa9dc-64cb-4ee2-ae98-8cdb72293cbe",
   "metadata": {},
   "source": [
    "![image](https://www.microsoft.com/en-us/research/uploads/prod/2023/09/AutoGen_Fig1.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "30b81551-92ac-4f08-9c00-ba11981c67c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import random\n",
    "import json\n",
    "import requests\n",
    "from operator import itemgetter\n",
    "from typing import Union, List\n",
    "from langchain_openai import AzureChatOpenAI\n",
    "from langchain.agents import AgentExecutor, Tool, create_openai_tools_agent\n",
    "from langchain_community.chat_message_histories import ChatMessageHistory, CosmosDBChatMessageHistory\n",
    "from langchain.callbacks.manager import CallbackManager\n",
    "from langchain_core.runnables.history import RunnableWithMessageHistory\n",
    "from langchain_core.runnables import ConfigurableFieldSpec, ConfigurableField\n",
    "from langchain_core.prompts import PromptTemplate, ChatPromptTemplate, MessagesPlaceholder\n",
    "from langchain_core.output_parsers import StrOutputParser\n",
    "from langchain.output_parsers import JsonOutputToolsParser\n",
    "from langchain_core.runnables import (\n",
    "    Runnable,\n",
    "    RunnableLambda,\n",
    "    RunnableMap,\n",
    "    RunnablePassthrough,\n",
    ")\n",
    "\n",
    "#custom libraries that we will use later in the app\n",
    "from common.utils import (\n",
    "    DocSearchAgent, \n",
    "    CSVTabularAgent, \n",
    "    SQLSearchAgent, \n",
    "    ChatGPTTool, \n",
    "    BingSearchAgent, \n",
    "    APISearchAgent, \n",
    "    reduce_openapi_spec\n",
    ")\n",
    "from common.callbacks import StdOutCallbackHandler\n",
    "from common.prompts import CUSTOM_CHATBOT_PROMPT \n",
    "\n",
    "from dotenv import load_dotenv\n",
    "load_dotenv(\"credentials.env\")\n",
    "\n",
    "from IPython.display import Markdown, HTML, display \n",
    "\n",
    "def printmd(string):\n",
    "    display(Markdown(string))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "67cd1e3e-8527-4a8f-ba90-e700ae7b20ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "os.environ[\"OPENAI_API_VERSION\"] = os.environ[\"AZURE_OPENAI_API_VERSION\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56b56a94-0471-41c3-b441-3a73ff5dedfc",
   "metadata": {},
   "source": [
    "### Get the Tools - DocSearch Agent, CSV Agent, SQL Agent, Web Search Agent, ChatGPT, API Agent\n",
    "\n",
    "**Consider the following concept:** Agents, which are essentially software entities designed to perform specific tasks, can be equipped with tools. These tools themselves can be other agents, each possessing their own set of tools. This creates a layered structure where tools can range from code sequences to human actions, forming interconnected chains. Ultimately, you're constructing a network of agents and their respective tools, all collaboratively working towards solving a specific task (This is what ChatGPT is). This network operates by leveraging the unique capabilities of each agent and tool, creating a dynamic and efficient system for task resolution.\n",
    "\n",
    "In the file `common/utils.py` we created Agent Tools Classes for each of the Functionalities that we developed in prior Notebooks. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "643d1650-6416-46fd-8b21-f5fb298ec063",
   "metadata": {},
   "outputs": [],
   "source": [
    "cb_handler = StdOutCallbackHandler()\n",
    "cb_manager = CallbackManager(handlers=[cb_handler])\n",
    "\n",
    "COMPLETION_TOKENS = 2000\n",
    "\n",
    "# We can run the everything with GPT3.5, but try also GPT4 and see the difference in the quality of responses\n",
    "# You will notice that GPT3.5 is not as reliable.\n",
    "\n",
    "llm = AzureChatOpenAI(deployment_name=os.environ[\"GPT35_DEPLOYMENT_NAME\"], \n",
    "                      temperature=0, max_tokens=COMPLETION_TOKENS)\n",
    "\n",
    "# Uncomment below if you want to see the answers streaming\n",
    "# llm = AzureChatOpenAI(deployment_name=os.environ[\"GPT35_DEPLOYMENT_NAME\"], temperature=0, max_tokens=COMPLETION_TOKENS, streaming=True, callback_manager=cb_manager)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a6a4cc93-2dd6-45eb-ac5b-5af2d31809dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "doc_indexes = [\"cogsrch-index-files\", \"cogsrch-index-csv\"]\n",
    "doc_search = DocSearchAgent(llm=llm, indexes=doc_indexes,\n",
    "                           k=6, reranker_th=1,\n",
    "                           sas_token=os.environ['BLOB_SAS_TOKEN'],\n",
    "                           name=\"docsearch\",\n",
    "                           description=\"useful when the questions includes the term: docsearch\",\n",
    "                           callback_manager=cb_manager, verbose=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "eafd5bf5-28ee-4edd-978b-384cce057257",
   "metadata": {},
   "outputs": [],
   "source": [
    "book_indexes = [\"cogsrch-index-books\"]\n",
    "book_search = DocSearchAgent(llm=llm, indexes=book_indexes,\n",
    "                           k=10, reranker_th=1,\n",
    "                           sas_token=os.environ['BLOB_SAS_TOKEN'],\n",
    "                           name=\"booksearch\",\n",
    "                           description=\"useful when the questions includes the term: booksearch\",\n",
    "                           callback_manager=cb_manager, verbose=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0f0ae466-aff8-4cdf-80d3-ef2c61867fc7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# BingSearchAgent is a langchain Tool class to use the Bing Search API (https://www.microsoft.com/en-us/bing/apis/bing-web-search-api)\n",
    "www_search = BingSearchAgent(llm=llm, k=5, callback_manager=cb_manager, \n",
    "                             name=\"bing\",\n",
    "                             description=\"useful when the questions includes the term: bing\",\n",
    "                             verbose=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "78edb304-c4a2-4f10-8ded-936e9141aa02",
   "metadata": {},
   "outputs": [],
   "source": [
    "## CSVTabularAgent is a custom Tool class crated to Q&A over CSV files\n",
    "file_url = \"./data/all-states-history.csv\"\n",
    "csv_search = CSVTabularAgent(path=file_url, llm=llm, callback_manager=cb_manager,\n",
    "                             name=\"csvfile\",\n",
    "                             description=\"useful when the questions includes the term: csvfile\",\n",
    "                             verbose=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b9d54cc5-41bc-43c3-a91d-12fc3a2446ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "## SQLDbAgent is a custom Tool class created to Q&A over a MS SQL Database\n",
    "sql_search = SQLSearchAgent(llm=llm, k=30, callback_manager=cb_manager,\n",
    "                            name=\"sqlsearch\",\n",
    "                            description=\"useful when the questions includes the term: sqlsearch\",\n",
    "                            verbose=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "65465173-92f6-489d-9b48-58d109c5723e",
   "metadata": {},
   "outputs": [],
   "source": [
    "## ChatGPTTool is a custom Tool class created to talk to ChatGPT knowledge\n",
    "chatgpt_search = ChatGPTTool(llm=llm, callback_manager=cb_manager,\n",
    "                             name=\"chatgpt\",\n",
    "                            description=\"use for general questions, profile, greeting-like questions and when the questions includes the term: chatgpt\",\n",
    "                            verbose=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "1fe2b4a7-4053-4334-867f-e4c916e360b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "## APISearchAgent is a custom Tool class created to talk to any API \n",
    "\n",
    "url = \"https://datasetsgptsmartsearch.blob.core.windows.net/apispecs/openapi_kraken.json\"\n",
    "spec = requests.get(url + os.environ['BLOB_SAS_TOKEN']).json()\n",
    "\n",
    "api_search = APISearchAgent(llm=AzureChatOpenAI(deployment_name=os.environ[\"GPT4_DEPLOYMENT_NAME\"], temperature=0.5, max_tokens=1000),\n",
    "                            llm_search=AzureChatOpenAI(deployment_name=os.environ[\"GPT4_DEPLOYMENT_NAME\"], temperature=0.5, max_tokens=1000),\n",
    "                            api_spec=str(reduce_openapi_spec(spec)),\n",
    "                            callback_manager=cb_manager,\n",
    "                            name=\"apisearch\",\n",
    "                            description=\"useful when the questions includes the term: apisearch\",\n",
    "                            verbose=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "179fc56a-b7e4-44a1-8b7f-68b2b4d02e13",
   "metadata": {},
   "source": [
    "### Variables/knobs to use for customization"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21f11831-7578-4326-b3b3-d9b073a7149d",
   "metadata": {},
   "source": [
    "As you have seen so far, there are many knobs that you can dial up or down in order to change the behavior of your GPT Smart Search engine application, these are the variables you can tune:\n",
    "\n",
    "- <u>llm</u>:\n",
    "  - **deployment_name**: this is the deployment name of your Azure OpenAI model. This of course dictates the level of reasoning and the amount of tokens available for the conversation. For a production system you will need gpt-4-32k. This is the model that will give you enough reasoning power to work with agents, and enough tokens to work with detailed answers and conversation memory.\n",
    "  - **temperature**: How creative you want your responses to be\n",
    "  - **max_tokens**: How long you want your responses to be. It is recommended a minimum of 500\n",
    "- <u>Tools</u>: To each tool you can add the following parameters to modify the defaults (set in utils.py), these are very important since they are part of the system prompt and determines what tool to use and when.\n",
    "  - **name**: the name of the tool\n",
    "  - **description**: when the brain agent should use this tool\n",
    "- <u>DocSearchAgent</u>: \n",
    "  - **k**: The top k results per index from the text search action\n",
    "  - **similarity_k**: top k results combined from the vector search action\n",
    "  - **reranker_th**: threshold of the semantic search reranker. Picks results that are above the threshold. Max possible score=4\n",
    "- <u>BingSearchAgent</u>:\n",
    "  - **k**: The top k results from the bing search action\n",
    "- <u>SQLSearchAgent</u>:\n",
    "  - **k**: The top k results from the SQL search action. Adds TOP clause to the query\n",
    "  \n",
    "in `utils.py` you can also tune:\n",
    "- <u>model_tokens_limit</u>: In this function you can edit what is the maximum allows of tokens reserve for the content. Remember that the remaining will be for the system prompt plus the answer"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9ee1058-debb-4f97-92a4-999e0c4e0386",
   "metadata": {},
   "source": [
    "### Test the Tools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "dc11cb35-8817-4dd0-b123-27f9eb032f43",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tool: docsearch\n",
      "Agent Action: \n",
      "Invoking: `docsearch` with `{'query': 'weather in Dallas today'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `docsearch` with `{'query': 'current weather in Dallas'}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "I'm sorry, but I couldn't find the specific weather information for Dallas today. The documents I retrieved contain information about the relationship between weather and COVID-19, as well as the impact of weather on the transmission of infectious diseases. If you need specific weather information for Dallas, I recommend checking a reliable weather website or using a weather app for the most accurate and up-to-date details."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Test the Documents Search Tool with a question we know it doesn't have the knowledge for\n",
    "printmd(doc_search.run(\"what is the weather today in Dallas?\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "473222f1-b423-49f3-98e7-ab70dcf47bd6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tool: docsearch\n",
      "Agent Action: \n",
      "Invoking: `docsearch` with `{'query': 'How does Covid affect obese people?'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `docsearch` with `{'query': 'How does Covid affect elderly people?'}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "### How Covid Affects Obese People\n",
       "\n",
       "Obesity is a significant risk factor for severe illness and complications related to COVID-19. Here are some key findings from the retrieved documents:\n",
       "\n",
       "1. **Increased Severity**: Studies have shown that obesity is highly frequent among critically ill patients with COVID-19, and it remains difficult to elucidate the mechanisms by which COVID-19 severity is increased in the context of obesity<sup><a href=\"https://doi.org/10.1002/oby.22867\" target=\"_blank\">[1]</a></sup>.\n",
       "\n",
       "2. **Cardiac Complications**: Hospitalized patients with COVID-19 who are obese have presented cardiac complications, including myocarditis, arrhythmias, heart failure, and sudden death. Myocardial response in COVID-19 is closely associated with in-hospital mortality, indicating the impact of obesity on the severity of COVID-19<sup><a href=\"https://doi.org/10.1002/oby.22867\" target=\"_blank\">[1]</a></sup>.\n",
       "\n",
       "3. **Risk of Severe Disease**: Obese patients with COVID-19 have increased odds of progressing to severe illness. They are at higher risk of developing severe symptoms and have a negative prognosis compared to non-obese patients<sup><a href=\"https://doi.org/10.2337/dc20-0576\" target=\"_blank\">[2]</a></sup>.\n",
       "\n",
       "4. **Impact on Mortality**: Two-thirds of people who developed serious or fatal COVID-19-related complications were overweight or obese. Almost 72% of those in critical care units were either overweight or obese, highlighting the impact of obesity on seriously ill COVID-19 patients<sup><a href=\"https://doi.org/10.1002/oby.22844\" target=\"_blank\">[3]</a></sup>.\n",
       "\n",
       "5. **Mechanistic Framework**: There is a theoretical mechanistic framework whereby adipose tissue in subjects with obesity may act as a reservoir for more extensive viral spread with increased shedding, immune activation, and cytokine amplification, leading to poor COVID-19 outcomes<sup><a href=\"https://doi.org/10.1016/j.enfcli.2020.05.004\" target=\"_blank\">[4]</a></sup>.\n",
       "\n",
       "### How Covid Affects Elderly People\n",
       "\n",
       "Elderly people are at a higher risk of more serious and possibly fatal illness associated with COVID-19. Here are some key findings from the retrieved documents:\n",
       "\n",
       "1. **Mortality Risk**: Mortality data indicates a risk of mortality of 3.6% for people in their 60s, which increases to 8.0% and 14.8% for people in their 70s and over 80s. This highlights the increased risk of mortality for elderly individuals<sup><a href=\"https://doi.org/10.1111/jocn.15274\" target=\"_blank\">[1]</a></sup>.\n",
       "\n",
       "2. **Severity of Illness**: The current SARS-CoV-2 pandemic is affecting elderly people worldwide with greater incidence and severity. In Spain, 68% of all coronavirus hospitalizations correspond to those over 60 years of age<sup><a href=\"https://doi.org/10.1016/j.enfcli.2020.05.004\" target=\"_blank\">[2]</a></sup>.\n",
       "\n",
       "3. **Risk Interactions Across Age Groups**: The risk of coronavirus infection among elderly people is significantly affected by other age groups. Protecting elderly people from coronavirus infection could reduce the risk of infection among themselves and ameliorate the risks of virus infection among other age groups<sup><a href=\"http://medrxiv.org/cgi/content/short/2020.05.17.20105049v1\" target=\"_blank\">[3]</a></sup>.\n",
       "\n",
       "4. **Complications**: Complications of COVID-19 have been particularly severe among older adults, emphasizing the need for pandemic preparedness in nursing homes and support programs for community-dwelling older adults<sup><a href=\"https://doi.org/10.1172/jci.insight.139292\" target=\"_blank\">[4]</a></sup>.\n",
       "\n",
       "These findings underscore the increased vulnerability of elderly individuals to severe illness and complications associated with COVID-19.\n",
       "\n",
       "For more detailed information, you can refer to the provided sources."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Test the Document Search Tool with a question that we know it has the answer for\n",
    "printmd(doc_search.run(\"How Covid affects obese people? and elderly?\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "46a5ed66-e7ff-43bd-829f-c028476d2593",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tool: booksearch\n",
      "Agent Action: \n",
      "Invoking: `docsearch` with `{'query': 'kidney stolen legend'}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "The \"Kidney Heist\" legend is a well-known urban legend that has circulated widely over the past fifteen years. The legend typically begins with the classic urban-legend opening: \"A friend of a friend...\" and involves a story about a person who wakes up in an ice-filled bathtub after being drugged, only to discover that one of their kidneys has been stolen. There are numerous versions of this legend, but they all share three core elements: the drugged drink, the ice-filled bathtub, and the kidney-theft punch line. The story is often set in a specific location, which varies depending on where it is told, adding localized details that enhance its credibility and effect<sup><a href=\"https://datasetsgptsmartsearch.blob.core.windows.net/books/Made_To_Stick.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-01-03T02:11:44Z&st=2024-01-02T18:11:44Z&spr=https&sig=ngrEqvqBVaxyuSYqgPVeF%2B9c0fXLs94v3ASgwg7LDBs%3D\" target=\"_blank\">source</a></sup>.\n",
       "\n",
       "The legend is characterized by its vivid and concrete details, which make it memorable and easy to retell. It taps into emotions such as fear, disgust, and suspicion, and if believed to be true, it might change people's behavior, particularly in terms of accepting drinks from strangers. The story's stickiness and memorability make it a powerful example of how concrete and emotionally engaging stories can have a lasting impact on people<sup><a href=\"https://datasetsgptsmartsearch.blob.core.windows.net/books/Made_To_Stick.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-01-03T02:11:44Z&st=2024-01-02T18:11:44Z&spr=https://sig=ngrEqvqBVaxyuSYqgPVeF%2B9c0fXLs94v3ASgwg7LDBs%3D\" target=\"_blank\">source</a></sup>.\n",
       "\n",
       "The legend of the \"Kidney Heist\" is an example of a sticky idea that is understood, remembered, and has a lasting impact on people, even though it is not based on truth. It serves as an illustration of how certain stories, despite being false, can have a significant influence on people's perceptions and behaviors<sup><a href=\"https://datasetsgptsmartsearch.blob.core.windows.net/books/Made_To_Stick.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-01-03T02:11:44Z&st=2024-01-02T18:11:44Z&spr=https://sig=ngrEqvqBVaxyuSYqgPVeF%2B9c0fXLs94v3ASgwg7LDBs%3D\" target=\"_blank\">source</a></sup>."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Test the other index created manually\n",
    "printmd(book_search.run(\"Tell me about the kidney stolen legend?\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "03839591-553c-46a0-846a-1c4fb96bf851",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tool: bing\n",
      "Agent Action: \n",
      "Invoking: `Searcher` with `{'query': 'family members of the current president of India'}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "The current President of India is Smt. Droupadi Murmu. However, the search results did not provide specific information about her family members. If you have any other questions or if there's anything else I can assist you with, feel free to ask!"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Test the Bing Search Agent\n",
    "# Note: GPT-4 will solve this research, GPT-3.5 solves it half of the time\n",
    "printmd(www_search.run(\"Who are the family member names of the current president of India?\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "bc64f3ee-96e4-4007-8a3c-2f017a615587",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tool: csvfile\n",
      "Agent Action: \n",
      "Invoking: `python_repl_ast` with `{'query': 'len(df)'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `python_repl_ast` with `{'query': 'df.shape'}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "The file has 20,780 rows.\n",
       "\n",
       "Explanation:\n",
       "- Using the `len(df)` function, we obtained the total number of rows in the dataframe, which is 20,780.\n",
       "- Additionally, using the `df.shape` attribute, we obtained the shape of the dataframe, which is (20780, 41). This confirms that the dataframe has 20,780 rows."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Test the CSV Agent\n",
    "printmd(csv_search.run(\"how many rows does the file have?\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "c809f8d7-2ed9-46d8-a73c-118da063cace",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tool: sqlsearch\n",
      "Agent Action: \n",
      "Invoking: `sql_db_list_tables` with ``\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `sql_db_schema` with `{'table_names': 'covidtracking'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `sql_db_query` with `SELECT state, SUM(death) as total_deaths FROM covidtracking WHERE state IN ('CA', 'OR', 'WA') AND date LIKE '2020-07%' GROUP BY state`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "The total number of deaths in California, Oregon, and Washington in July 2020 are as follows:\n",
       "- California: 229,362 deaths\n",
       "- Oregon: 7,745 deaths\n",
       "- Washington: 44,440 deaths\n",
       "\n",
       "Here's the SQL query I used to obtain this information:\n",
       "```sql\n",
       "SELECT state, SUM(death) as total_deaths \n",
       "FROM covidtracking \n",
       "WHERE state IN ('CA', 'OR', 'WA') AND date LIKE '2020-07%' \n",
       "GROUP BY state\n",
       "```\n",
       "\n",
       "Explanation:\n",
       "1. I used the `covidtracking` table to filter the data for the states of California (CA), Oregon (OR), and Washington (WA).\n",
       "2. I selected the total number of deaths (`SUM(death)`) for each state where the date is in July 2020 (`date LIKE '2020-07%'`).\n",
       "3. I grouped the results by state to get the total deaths for each state."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Test the SQL Search Agent\n",
    "printmd(sql_search.run(\"How many people in total died california in each state of the west coast in July 2020?\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "f70501c2-03d0-4072-b451-ddb92f4add56",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tool: chatgpt\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "In Python, you can use the `random` module to generate random numbers. The `random` module provides various functions for generating random numbers, such as `random()`, `randint()`, `choice()`, and `shuffle()`. For example, to generate a random integer between 1 and 10, you can use the `randint()` function as follows:\n",
       "\n",
       "```python\n",
       "import random\n",
       "random_number = random.randint(1, 10)\n",
       "print(random_number)\n",
       "```\n",
       "\n",
       "This will produce a random integer between 1 and 10. You can explore other functions in the `random` module to suit your specific needs."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Test the ChatGPTWrapper Search Tool\n",
    "printmd(chatgpt_search.run(\"what is the function in python that allows me to get a random number?\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c0ff658-b75a-4960-8576-65472844ad05",
   "metadata": {},
   "source": [
    "### Define what tools are we going to give to our brain agent\n",
    "\n",
    "Go to `common/utils.py` to check the tools definition and the instructions on what tool to use when"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "d018c884-5c91-4a35-90e3-6a5a6e510c25",
   "metadata": {},
   "outputs": [],
   "source": [
    "tools = [www_search, sql_search, doc_search, book_search, chatgpt_search]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06f91421-079d-4bdd-9c45-96a0977c6558",
   "metadata": {},
   "source": [
    "**Note**: Notice that since both the CSV file and the SQL Database have the same exact data, we are only going to use the SQLDBTool since it is faster and more reliable"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27699991-00d8-4f0a-8511-e03e530910c3",
   "metadata": {},
   "source": [
    "# Option 1: Using OpenAI functions as router"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66aed5eb-846d-44d1-acf1-04b8ff931d30",
   "metadata": {},
   "source": [
    "We need a method to route the question to the right tool, one way to do this is to use OpenAI models functions via the Tools API (models 1106 and newer). To do this, we need to bind these tools/functions to the model and let the model respond with the right tool to use.\n",
    "\n",
    "The advantage of this option is that there is no another agent in the middle between the experts (agent tools) and the user. Each agent tool responds directly. Also, another advantage is that multiple tools can be called in parallel.\n",
    "\n",
    "**Note**: on this method it is important that each agent tool has the same system profile prompt so they adhere to the same reponse guidelines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "218163af-2279-4891-8699-7f9f291c49f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "llm_with_tools = llm.bind_tools(tools)\n",
    "tool_map = {tool.name: tool for tool in tools}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "2c5e8efd-b907-4157-99f8-15a44a63f17d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def call_tool(tool_invocation: dict) -> Union[str, Runnable]:\n",
    "    \"\"\"Function for dynamically constructing the end of the chain based on the model-selected tool.\"\"\"\n",
    "    tool = tool_map[tool_invocation[\"type\"]]\n",
    "    return RunnablePassthrough.assign(output=itemgetter(\"args\") | tool)\n",
    "\n",
    "def print_response(result: List):\n",
    "    for answer in result:\n",
    "        printmd(\"**\"+answer[\"type\"] + \"**\" + \": \" + answer[\"output\"])\n",
    "        printmd(\"----\")\n",
    "      \n",
    "# .map() allows us to apply a function to a list of inputs.\n",
    "call_tool_list = RunnableLambda(call_tool).map()\n",
    "agent = llm_with_tools | JsonOutputToolsParser() | call_tool_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "ec71da3f-097b-4b56-bfcb-c5ed241d8cf7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tool: chatgpt\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "**chatgpt**: Hello! I'm doing well, thank you for asking. My name is Jarvis. How can I assist you today?"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "----"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "result = agent.invoke(\"hi, how are you, what is your name?\")\n",
    "print_response(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "63682613-daa3-49fa-9fe0-6e5af8ff05ee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tool: bing\n",
      "Agent Action: \n",
      "Invoking: `Searcher` with `{'query': 'current president of France'}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "**bing**: The current president of France is Emmanuel Macron. He was re-elected as the President of the Republic on 24 April 2022. Emmanuel Macron is the eighth President of the Fifth Republic of France and has been in office since 2017. If you need more information, you can visit the official website of the French Presidency at [Élysée](https://www.elysee.fr/en/emmanuel-macron).\n",
       "\n",
       "If you have any more questions or need further assistance, feel free to ask!"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "----"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "result = agent.invoke(\"Who is the current president of France?\")\n",
    "print_response(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "5f58b57b-51cb-433c-b6a8-376e6aa06e12",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tool: docsearch\n",
      "Tool: bing\n",
      "Agent Action: \n",
      "Invoking: `docsearch` with `{'query': 'CLP'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `Searcher` with `{'query': 'CLP'}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "**docsearch**: The term \"CLP\" can refer to different concepts based on the context. Here are some of the references related to \"CLP\" that I found:\n",
       "\n",
       "1. **Constraint Logic Programming (CLP):** This refers to a powerful extension of conventional logic programming that involves the incorporation of constraint languages and constraint solving methods into logic programming languages. It was first introduced by Jaffar and Lassez in 1986 as a general framework for a logic programming language that is parametrized with respect to constraint language and a domain of computation, yielding soundness and completeness results for an operational semantics relying on a constraint solver for the employed constraint language<sup><a href=\"https://datasetsgptsmartsearch.blob.core.windows.net/arxivcs/pdf/0008/0008036v1.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-01-03T02:11:44Z&st=2024-01-02T18:11:44Z&spr=https&sig=ngrEqvqBVaxyuSYqgPVeF%2B9c0fXLs94v3ASgwg7LDBs%3D\" target=\"_blank\">[1]</a></sup>.\n",
       "\n",
       "2. **CLP(FD) - Constraint Logic Programming over Finite Domains:** This is an extension of logic programming where logical variables are assigned a domain and relations between variables are described with constraints. A solution to a CLP(FD) program is a valuation of every variable in its own domain such that no constraint is falsified. Solutions are found using two mechanisms: propagation and enumeration. The goal of CLP(FD) is to generate a CLP(FD) constraint between the input and output variables of an imperative program<sup><a href=\"https://datasetsgptsmartsearch.blob.core.windows.net/arxivcs/pdf/0506/0506005v1.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-01-03T02:11:44Z&st=2024-01-02T18:11:44Z&spr=https&sig=ngrEqvqBVaxyuSYqgPVeF%2B9c0fXLs94v3ASgwg7LDBs%3D\" target=\"_blank\">[2]</a></sup>.\n",
       "\n",
       "3. **Relevance to Computer Science Research:** CLP has been extensively researched in the context of logic programming, constraint logic grammars, and their applications in computational linguistics. It involves the incorporation of constraint languages and constraint solving methods into logic programming languages, providing a powerful framework for various applications<sup><a href=\"https://datasetsgptsmartsearch.blob.core.windows.net/arxivcs/pdf/0008/0008036v1.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-01-03T02:11:44Z&st=2024-01-02T18:11:44Z&spr=https&sig=ngrEqvqBVaxyuSYqgPVeF%2B9c0fXLs94v3ASgwg7LDBs%3D\" target=\"_blank\">[3]</a></sup>.\n",
       "\n",
       "4. **Quantitative Constraint Logic Programming:** This refers to a formal semantics for quantitative inference in CLP based upon the simple and intuitive concepts of fuzzy set algebra. It provides a precise, yet simple formal semantics for quantitative inference in CLP and enables the use of the search technique of alpha-beta pruning for efficient disambiguation<sup><a href=\"https://datasetsgptsmartsearch.blob.core.windows.net/arxivcs/pdf/0008/0008036v1.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-01-03T02:11:44Z&st=2024-01-02T18:11:44Z&spr=https&sig=ngrEqvqBVaxyuSYqgPVeF%2B9c0fXLs94v3ASgwg7LDBs%3D\" target=\"_blank\">[3]</a></sup>.\n",
       "\n",
       "These references provide a comprehensive overview of the different aspects and applications of \"CLP\" in various domains."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "----"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "**bing**: The acronym \"CLP\" has various meanings in different contexts:\n",
       "\n",
       "1. **CLP Group**: CLP is a leading power company with operations in Hong Kong, Mainland China, India, Australia, and other regions. It provides energy solutions for a sustainable future and showcases its history and culture at CLP Pulse. [CLP Group Website](https://www.clpgroup.com/en/index.html)\n",
       "\n",
       "2. **CLP Power Hong Kong**: This is a subsidiary of CLP Holdings Limited, offering electricity to over 80% of Hong Kong's population. It also provides energy-saving tips, eco-friendly products, and online services such as eBill, PPS payment, and CLP TomorroVerse. [CLP Power Hong Kong Website](https://www.clp.com.hk/en/index)\n",
       "\n",
       "3. **Country Liberal Party (CLP)**: The Country Liberal Party of the Northern Territory, commonly known as the Country Liberals, is a center-right political party in Australia's Northern Territory. It operates in a two-party system with the Australian Labor Party (ALP) and contests federal elections as an affiliate of the Liberal Party of Australia and National Party of Australia. [Country Liberal Party - Wikipedia](https://en.wikipedia.org/wiki/Country_Liberal_Party)\n",
       "\n",
       "4. **EnergyAustralia and CLP**: There is also a mention of CLP in relation to EnergyAustralia, where it is stated that EnergyAustralia had contracted its generation in advance, ahead of the spike in wholesale prices, and then had to cover the contracts in the market at the higher spot rates because of the... [EnergyAustralia plunges to heavy loss, eyes partnerships - Financial Review](https://www.afr.com/companies/energy/energyaustralia-plunges-to-heavy-loss-20220808-p5b81k)\n",
       "\n",
       "These are the various meanings and contexts in which the acronym \"CLP\" is used. If you have a specific context in mind, please let me know!"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "----"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "result = agent.invoke(\"docsearch,bing, what is CLP?\")\n",
    "print_response(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb036da4-825f-45a4-a08f-c5a272c8f895",
   "metadata": {},
   "source": [
    "# Option 2: Using a user facing agent that calls the agent tools experts\n",
    "\n",
    "With this method, we create a user facing agent that talks to the user and also talks to the experts (agent tools)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0cc02389-cf52-4a5f-b4a1-2820ee5d8116",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Initialize the brain agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "ea67e969-26b3-4e6f-a6c0-16780ed418e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "agent = create_openai_tools_agent(llm, tools, CUSTOM_CHATBOT_PROMPT)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "d9d2d5b4-0145-402e-a620-0fe3f3548acf",
   "metadata": {},
   "outputs": [],
   "source": [
    "agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "e3ffef69-5dcd-423a-802d-7a0c419c7e46",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_session_history(session_id: str, user_id: str) -> CosmosDBChatMessageHistory:\n",
    "    cosmos = CosmosDBChatMessageHistory(\n",
    "        cosmos_endpoint=os.environ['AZURE_COSMOSDB_ENDPOINT'],\n",
    "        cosmos_database=os.environ['AZURE_COSMOSDB_NAME'],\n",
    "        cosmos_container=os.environ['AZURE_COSMOSDB_CONTAINER_NAME'],\n",
    "        connection_string=os.environ['AZURE_COMOSDB_CONNECTION_STRING'],\n",
    "        session_id=session_id,\n",
    "        user_id=user_id\n",
    "        )\n",
    "\n",
    "    # prepare the cosmosdb instance\n",
    "    cosmos.prepare_cosmos()\n",
    "    return cosmos\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "73e389f9-17cc-4c12-80e0-ab671b46bf37",
   "metadata": {},
   "outputs": [],
   "source": [
    "brain_agent_executor = RunnableWithMessageHistory(\n",
    "    agent_executor,\n",
    "    get_session_history,\n",
    "    input_messages_key=\"question\",\n",
    "    history_messages_key=\"history\",\n",
    "    history_factory_config=[\n",
    "        ConfigurableFieldSpec(\n",
    "            id=\"user_id\",\n",
    "            annotation=str,\n",
    "            name=\"User ID\",\n",
    "            description=\"Unique identifier for the user.\",\n",
    "            default=\"\",\n",
    "            is_shared=True,\n",
    "        ),\n",
    "        ConfigurableFieldSpec(\n",
    "            id=\"session_id\",\n",
    "            annotation=str,\n",
    "            name=\"Session ID\",\n",
    "            description=\"Unique identifier for the conversation.\",\n",
    "            default=\"\",\n",
    "            is_shared=True,\n",
    "        ),\n",
    "    ],\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "601fce84-4a02-41a6-8ae2-f692174d4cc8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "session982 user355\n"
     ]
    }
   ],
   "source": [
    "# This is where we configure the session id and user id\n",
    "random_session_id = \"session\"+ str(random.randint(1, 1000))\n",
    "ramdom_user_id = \"user\"+ str(random.randint(1, 1000))\n",
    "\n",
    "config={\"configurable\": {\"session_id\": random_session_id, \"user_id\": ramdom_user_id}}\n",
    "print(random_session_id, ramdom_user_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4904a07d-b857-45d7-86ac-c7cade3e9080",
   "metadata": {},
   "source": [
    "### Let's talk to our GPT Smart Search Engine chat bot now"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "4b37988b-9fb4-4958-bc17-d58d8dac8bb7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tool: chatgpt\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "I'm glad to hear that you're doing well, Pablo. How can I assist you today?"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# This question should not use any tool, the brain agent should answer it without the use of any tool\n",
    "printmd(brain_agent_executor.invoke({\"question\": \"Hi, I'm Pablo Marin, how are you doing today?\"}, config=config)[\"output\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "a070c558-3963-40ef-b94e-365324ee3d20",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "I'm here to assist you with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions. My name is Jarvis, and I'm designed to be a helpful assistant for all your inquiries. How can I assist you today?"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "printmd(brain_agent_executor.invoke({\"question\": \"what is your name and what do you do?\"}, config=config)[\"output\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "ebdc3ad9-ad59-4135-87f6-e86728a11b71",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tool: bing\n",
      "Agent Action: \n",
      "Invoking: `Searcher` with `{'query': 'Italian restaurants in downtown Chicago'}`\n",
      "\n",
      "\n",
      "\n",
      "Tool: bing\n",
      "Agent Action: \n",
      "Invoking: `Searcher` with `{'query': 'sushi restaurants in downtown Chicago'}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "Here are some options for Italian and Sushi restaurants in downtown Chicago:\n",
       "\n",
       "### Italian Restaurants\n",
       "1. **Sofi Restaurant**\n",
       "   - This family-run Italian eatery serves a menu rich in homemade pasta, bolognese, and truffle risotto, complemented by a tranquil outdoor seating area.\n",
       "   - [Tripadvisor - Italian Restaurants in Downtown / The Loop Chicago](https://www.tripadvisor.com/Restaurants-g35805-c26-zfn7778523-Chicago_Illinois.html)\n",
       "\n",
       "2. **The Fillmore**\n",
       "   - Located in the heart of Jeweler’s Row, the Madison Street location embodies historic Chicago dining, with a timeless ambiance and a menu featuring classic Italian dishes.\n",
       "   - [OpenTable - 116 Best Italian Restaurants In Downtown / Loop](https://www.opentable.com/cuisine/best-italian-restaurants-downtown-chicago-il)\n",
       "\n",
       "3. **Viaggio Ristorante & Lounge, Volare Ristorante Italiano, Piacere Mio, Il Porcellino, Nonna Silvia's Trattoria & Pizzeria, Sapori Trattoria, La Scarola, Maggiano's Little Italy, Quartino Ristorante, Monteverde**\n",
       "   - These are some of the top-rated Italian restaurants in downtown Chicago according to Yelp.\n",
       "   - [Yelp - TOP 10 BEST Italian Restaurants Downtown in Chicago, IL](https://www.yelp.com/search?find_desc=Italian+Restaurants+Downtown&find_loc=Chicago%2C+IL)\n",
       "\n",
       "4. **Monteverde**\n",
       "   - This West Loop eatery offers a variety of Italian dishes and is known for its chef-owner, Sarah Grueneberg.\n",
       "   - [Time Out - 35 Best Italian Restaurants in Chicago](https://www.timeout.com/chicago/restaurants/best-italian-restaurants-in-chicago-find-pasta-pizza-and-more)\n",
       "\n",
       "### Sushi Restaurants\n",
       "1. **Blue Sushi Sake Grill**\n",
       "   - Known for its top-notch sushi cuisine, this restaurant is regarded as \"the best sushi restaurant in Chicago\" by multiple reviewers. It is praised for its fresh, high-quality sushi, with favorites including the Truffle Salmon, Ceviche style Hirami, and Black Tuna Sashimi.\n",
       "   - [OpenTable](https://www.opentable.com/cuisine/best-sushi-restaurants-downtown-chicago-il)\n",
       "\n",
       "2. **Pokeworks**\n",
       "   - A convenient location with friendly staff and a clean, tidy environment.\n",
       "   - [Tripadvisor](https://www.tripadvisor.com/Restaurants-g35805-c38-zfn7778523-Chicago_Illinois.html)\n",
       "\n",
       "3. **I Love Sushi**\n",
       "   - Known for its nice location, fast service, and friendly employees.\n",
       "   - [Tripadvisor](https://www.tripadvisor.com/Restaurants-g35805-c38-zfn7778523-Chicago_Illinois.html)\n",
       "\n",
       "4. **Sushi Plus Rotary Sushi Bar**\n",
       "   - An all-you-can-eat sushi restaurant.\n",
       "   - [Yelp](https://www.yelp.com/search?find_desc=sushi+downtown&find_loc=Chicago%2C+IL)\n",
       "\n",
       "5. **Kyōten**\n",
       "   - One of Chicago's most extensive (and expensive) omakase experiences, offering high-quality sushi.\n",
       "   - [Time Out](https://www.timeout.com/chicago/restaurants/the-best-sushi-in-chicago)\n",
       "\n",
       "These restaurants offer a range of Italian and sushi cuisine, so you can choose based on your preferences. Enjoy your dining experience in downtown Chicago!"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "printmd(brain_agent_executor.invoke({\"question\": \"bing, I need to take my girlfriend to dinner tonight in downtown Chicago. Please give me options for Italian and Sushi as well\"}, \n",
    "                                    config=config)[\"output\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "6e47566b-15a4-40c3-87b6-a66071e4c1ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tool: bing\n",
      "Agent Action: \n",
      "Invoking: `Searcher` with `{'query': 'Sushi Plus Rotary Sushi Bar Chicago'}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "I found some details about Sushi Plus Rotary Sushi Bar in Chicago. It has two locations:\n",
       "\n",
       "1. **Boystown Location**\n",
       "   - Facebook Page: [Sushi Plus Rotary Sushi Bar Boystown | Chicago IL - Facebook](https://www.facebook.com/sushipluschicago/)\n",
       "   - Yelp Page: [Sushi Plus Rotary Sushi Bar - Boystown - Yelp](https://www.yelp.com/biz/sushi-plus-rotary-sushi-bar-boystown-chicago)\n",
       "\n",
       "2. **Chinatown Location**\n",
       "   - Facebook Page: [Sushi Plus Rotary Sushi Bar Chinatown | Chicago IL - Facebook](https://www.facebook.com/sushipluschinatown/)\n",
       "   - Yelp Page: [Sushi Plus Rotary Sushi Bar - Chinatown - Yelp](https://www.yelp.ca/biz/sushi-plus-rotary-sushi-bar-chinatown-chicago)\n",
       "   - Restaurant Guru: [Sushi Plus Rotary Sushi Bar - Chinatown, 2131 S Archer Ave in Chicago ...](https://restaurantguru.com/Sushi-Rotary-Sushi-Bar-Chicago-2)\n",
       "\n",
       "You can explore these links for more information about the Sushi Plus Rotary Sushi Bar in Chicago. Enjoy your dining experience!"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "printmd(brain_agent_executor.invoke({\"question\": \"can you tell me more about restaurant 4 on your list of sushi restaurants?\"}, config=config)[\"output\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "7d0b33f9-75fa-4a3e-b9d8-8fd30dbfd3fc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tool: chatgpt\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "The formula for momentum in physics is given by the equation:\n",
       "\n",
       "\\[ p = mv \\]\n",
       "\n",
       "Where:\n",
       "- \\( p \\) is the momentum\n",
       "- \\( m \\) is the mass of the object\n",
       "- \\( v \\) is the velocity of the object\n",
       "\n",
       "This formula shows that momentum is the product of an object's mass and its velocity."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "printmd(brain_agent_executor.invoke({\"question\": \"chatgpt, tell me the formula in physics for momentum\"}, config=config)[\"output\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "94f354eb-884d-4fd3-842e-a8adc3b09a70",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tool: docsearch\n",
      "Agent Action: \n",
      "Invoking: `docsearch` with `{'query': 'CLP'}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "I found multiple meanings and applications for the term \"CLP\" in different contexts. Here are some of the contexts in which \"CLP\" is mentioned:\n",
       "\n",
       "1. **Constraint Logic Programming (CLP):** This refers to a powerful extension of conventional logic programming that incorporates constraint languages and constraint-solving methods into logic programming languages.\n",
       "\n",
       "2. **CLP(FD) - Constraint Logic Programming over Finite Domains:** This is an extension of logic programming where logical variables are assigned a domain, and relations between variables are described with constraints.\n",
       "\n",
       "3. **Recombinant Baculovirus-Generated Bluetongue Virus (BTV) Core-Like Particles (CLP):** This refers to the use of immunosorbent electron microscopy to quantify recombinant baculovirus-generated bluetongue virus (BTV) core-like particles.\n",
       "\n",
       "4. **Dynamic Inference of Likely Invariants using Daikon and CLP(FD):** This involves the use of Daikon, a tool for dynamic inference of likely invariants, to infer likely program invariants of a given program.\n",
       "\n",
       "Given these different contexts, it's important to specify the specific context or meaning of \"CLP\" that you are referring to."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "printmd(brain_agent_executor.invoke({\"question\": \"docsearch, what is CLP?\"}, config=config)[\"output\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "2fd67aed-ecd7-4096-9266-22de30c64e71",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tool: docsearch\n",
      "Agent Action: \n",
      "Invoking: `docsearch` with `{'query': 'Constraint Logic Programming'}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "Constraint Logic Programming (CLP) is a powerful extension of conventional logic programming that incorporates constraint languages and constraint-solving methods into logic programming languages. The name CLP was first introduced by Jaffar and Lassez in 1986 for a general framework of a logic programming language that is parameterized with respect to constraint language and a domain of computation. This framework yields soundness and completeness results for an operational semantics relying on a constraint solver for the employed constraint language [1](https://datasetsgptsmartsearch.blob.core.windows.net/arxivcs/pdf/0008/0008036v1.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-01-03T02:11:44Z&st=2024-01-02T18:11:44Z&spr=https&sig=ngrEqvqBVaxyuSYqgPVeF%2B9c0fXLs94v3ASgwg7LDBs%3D).\n",
       "\n",
       "CLP provides an operational treatment of various frameworks by embedding arbitrary logical languages into constraint logic programs. Definite clause specifications over such constraint languages then define grammars as constraint logic programs, i.e., as sets of axiomatic interpreted definite clauses. The prediction problem in this setting involves inferring an answer proving the implication to be a logical consequence of the program [1](https://datasetsgptsmartsearch.blob.core.windows.net/arxivcs/pdf/0008/0008036v1.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-01-03T02:11:44Z&st=2024-01-02T18:11:44Z&spr=https&sig=ngrEqvqBVaxyuSYqgPVeF%2B9c0fXLs94v3ASgwg7LDBs%3D).\n",
       "\n",
       "The approach of CLP is also discussed in the context of constraint logic grammars (CLGs), which are understood as grammars formulated by means of a suitable logical language that can be used as a constraint language in the CLP scheme. This connection provides an operational treatment of purely declaratively specified grammars, enabling a clear model-theoretic characterization of linguistic objects by specifying grammars as sets of descriptions from a suitable logical description language, called the constraint language [1](https://datasetsgptsmartsearch.blob.core.windows.net/arxivcs/pdf/0008/0008036v1.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-01-03T02:11:44Z&st=2024-01-02T18:11:44Z&spr=https&sig=ngrEqvqBVaxyuSYqgPVeF%2B9c0fXLs94v3ASgwg7LDBs%3D).\n",
       "\n",
       "The operational properties of the CLP scheme are discussed in the formalism CUF, which offers the operational properties of the CLP scheme but gives up the connection to the model-theoretic specifications of the underlying feature-based grammars. Another approach is defined by Götz and Meurers, who define an explicit translation from a logical language close to that of King into constraint logic programs, preserving the prediction problem by generating a constraint logic program [1](https://datasetsgptsmartsearch.blob.core.windows.net/arxivcs/pdf/0008/0008036v1.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-01-03T02:11:44Z&st=2024-01-02T18:11:44Z&spr=https&sig=ngrEqvqBVaxyuSYqgPVeF%2B9c0fXLs94v3ASgwg7LDBs%3D).\n",
       "\n",
       "In summary, Constraint Logic Programming (CLP) is a powerful extension of conventional logic programming that incorporates constraint languages and constraint solving methods into logic programming languages, providing an operational treatment of various frameworks by embedding arbitrary logical languages into constraint logic programs [1](https://datasetsgptsmartsearch.blob.core.windows.net/arxivcs/pdf/0008/0008036v1.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-01-03T02:11:44Z&st=2024-01-02T18:11:44Z&spr=https&sig=ngrEqvqBVaxyuSYqgPVeF%2B9c0fXLs94v3ASgwg7LDBs%3D)."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "printmd(brain_agent_executor.invoke({\"question\": \"can you tell me more about the first definition?\"}, config=config)[\"output\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "badebc1b-dbfe-4a92-93bd-9ff214c34e75",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tool: sqlsearch\n",
      "Agent Action: \n",
      "Invoking: `sql_db_list_tables` with ``\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `sql_db_schema` with `{'table_names': 'covidtracking'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `sql_db_query` with `SELECT SUM(death) as total_deaths FROM covidtracking WHERE state='TX' AND date LIKE '2020%'`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "The total number of people who died of COVID in Texas in 2020 is 2,841,253. This information is based on the data from the `covidtracking` table, and it reflects the impact of the COVID-19 pandemic in Texas during that year."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "printmd(brain_agent_executor.invoke({\"question\": \"sqlsearch, How many people died of covid in Texas in 2020?\"}, config=config)[\"output\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "aa62a502-fb14-4e39-a0d5-054f4d804b77",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tool: sqlsearch\n",
      "Agent Action: \n",
      "Invoking: `sql_db_list_tables` with ``\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `sql_db_schema` with `{'table_names': 'covidtracking'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `sql_db_query` with `SELECT SUM(deathIncrease) as TotalDeaths FROM covidtracking WHERE state='TX' AND date >= '2020-01-01' AND date <= '2020-12-31'`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "The total number of deaths due to COVID-19 in Texas in 2020, based on the \"deathIncrease\" column, is 27,437. This data reflects the impact of the COVID-19 pandemic on the state of Texas during that year."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "printmd(brain_agent_executor.invoke({\"question\": \"that result doesn't seem correct, can you use the deathIncrease column?\"}, config=config)[\"output\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "410d398b-d589-4352-8c42-2df5be173498",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tool: booksearch\n",
      "Agent Action: \n",
      "Invoking: `docsearch` with `{'query': 'setting boundaries with kids'}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "I found some valuable insights from the document \"Boundaries: When to Say Yes, How to Say No to Take Control of Your Life\" that shed light on setting boundaries with kids. Here are some key points:\n",
       "\n",
       "1. **Developmental Aspect of Boundaries**: The document emphasizes that boundaries come after bonding. Children must have secure bonding before they can effectively learn to set boundaries and move away from others. Good connections naturally lead to the development of boundaries and independence.\n",
       "\n",
       "2. **Instilling vs. Repairing Boundaries**: Teaching responsibility, limit setting, and delay of gratification early on can lead to smoother later years of a child's life. The document suggests that the later parents start, the harder they and their children have to work on boundary development.\n",
       "\n",
       "3. **Boundary Development in Children**: The work of boundary development in children is described as the work of learning responsibility. Teaching children the merits and limits of responsibility prepares them for adulthood tasks.\n",
       "\n",
       "4. **Boundary Needs of Children**: Boundaries play a crucial role in meeting important needs in children, such as self-protection. The document emphasizes that boundaries are designed to keep the good in and the bad out, and skills such as saying no, telling the truth, and maintaining physical distance need to be developed in the family structure to allow the child to take on the responsibility of self-protection.\n",
       "\n",
       "These insights provide valuable perspectives on the importance of setting boundaries with kids and the developmental aspects involved in this process."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "printmd(brain_agent_executor.invoke({\"question\": \"booksearch, I don't know how to say No to my kids, help me! What kind of boundaries should I set?\"}, config=config)[\"output\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "1fcd6749-b36d-4b5c-be9c-e2f02f34d230",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tool: bing\n",
      "Agent Action: \n",
      "Invoking: `Searcher` with `{'query': 'best restaurants in downtown Seoul'}`\n",
      "\n",
      "\n",
      "\n",
      "Tool: bing\n",
      "Agent Action: \n",
      "Invoking: `Searcher` with `{'query': 'top-rated restaurants in downtown Seoul'}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "Based on the information gathered, here are some of the best and top-rated restaurants in downtown Seoul:\n",
       "\n",
       "1. **Bar Cham**\n",
       "   - This restaurant made the 2022 Asia’s 50 Best Bars list and offers various non-alcoholic cocktail options just as delicious as their alcoholic counterparts.\n",
       "   - [More Info](https://www.eater.com/maps/best-seoul-restaurants-38)\n",
       "\n",
       "2. **Gop - Mapo**\n",
       "   - Known for offering the best grilled Korean meal in Seoul and is one of the best restaurants to try beef intestine.\n",
       "   - [More Info](https://www.tripadvisor.com/Restaurants-g294197-Seoul.html)\n",
       "\n",
       "3. **Mingles Restaurant**\n",
       "   - Cuisine: Korean (traditional and modern)\n",
       "   - Nestled near the Han River in the Gangnam-Gu district, Mingles Restaurant is one of the most popular eateries in Seoul, known for impeccable service and delicious food.\n",
       "   - [More Info](https://thekoreanguide.com/best-restaurants-seoul/)\n",
       "\n",
       "4. **THE PLACE Dining**\n",
       "   - An Italian restaurant with stunning views of the N Seoul Tower, offering a 360-degree view of Seoul with its window counter seating.\n",
       "   - [More Info](https://thesmartlocal.com/read/korea-scenic-restaurants/)\n",
       "\n",
       "5. **Woo Lae Oak 우래옥**\n",
       "   - This restaurant is worth visiting and is listed in the Michelin Guide 2023 Bib Gourmand. It offers a unique dining experience and is highly recommended.\n",
       "   - [More Info](https://kimchimari.com/best-seoul-restaurants-2023/)\n",
       "\n",
       "These restaurants offer a diverse range of cuisines and dining experiences, making them excellent choices for a memorable dining experience in downtown Seoul. Enjoy your dining experience!"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# This question although does not contain instructions for a tool, the brain agent decides what tool to use\n",
    "printmd(brain_agent_executor.invoke({\"question\": \"What's a good place to dine today in downtown Seoul?\"}, config=config)[\"output\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "080cc28e-2130-4c79-ba7d-0ed702f0ea7a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tool: chatgpt\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "You can use the `trim()` method in JavaScript to remove leading and trailing white spaces from a string. Here's an example:\n",
       "\n",
       "```javascript\n",
       "// Example of trimming spaces from a sentence in JavaScript\n",
       "const sentence = \"   Hello, world!   \";\n",
       "const trimmedSentence = sentence.trim();\n",
       "console.log(trimmedSentence); // Output: \"Hello, world!\"\n",
       "```\n",
       "\n",
       "In this example, the `trim()` method removes the leading and trailing spaces from the sentence, resulting in the output \"Hello, world!\"."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# This question many times causes a parsing error, but we can still give the answer using the run_agent function\n",
    "# which handles the parsing error exception\n",
    "printmd(brain_agent_executor.invoke({\"question\": \"@chatgpt, can you give me a javascript example of how to trim the spaces of a sentence?\"}, config=config)[\"output\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "b82d20c5-4591-4d94-8af7-bae614685874",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "I'm sorry, I cannot comply with that request."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# This question should trigger our prompt safety instructions\n",
    "printmd(brain_agent_executor.invoke({\"question\": \"Tell me a funny joke about the president\"}, config=config)[\"output\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "a5ded8d9-0bfe-4e16-be3f-382271c120a9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "You're welcome! If you have any more questions or need further assistance, feel free to ask. Have a great day!"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "printmd(brain_agent_executor.invoke({\"question\": \"Thank you Jarvis!\"}, config=config)[\"output\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96a54fc7-ec9b-4ced-9e17-c65d00aa97f6",
   "metadata": {},
   "source": [
    "# Summary"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c48d899-bd7b-4081-a656-e8d9e597220d",
   "metadata": {},
   "source": [
    "Great!, We just built the GPT Smart Search Engine!\n",
    "In this Notebook we created the brain, the decision making Agent that decides what Tool to use to answer the question from the user. This is what was necessary in order to have an smart chat bot.\n",
    "\n",
    "We can have many tools to accomplish different tasks, including connecting to APIs, dealing with File Systems, and even using Humans as Tools. For more reference see [HERE](https://python.langchain.com/docs/integrations/tools/)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9969ed7e-3680-4853-b750-675a42d3b9ea",
   "metadata": {},
   "source": [
    "# NEXT\n",
    "It is time now to use all the functions and prompts build so far and build a Web application.\n",
    "The Next notebook will guide you on how to build:\n",
    "\n",
    "1) A Bot API Backend\n",
    "2) A Frontend UI with a Search and Webchat interfaces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64e99872-b01b-4e1a-9d41-04f70e22bbf4",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}