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 when using multiple sources.\n",
    "\n",
    "llm = AzureChatOpenAI(deployment_name=os.environ[\"GPT4o_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[\"GPT4o_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 = [\"srch-index-files\", \"srch-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 = [\"srch-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=\"useful 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 today in Dallas', 'return_direct': True}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "I couldn't retrieve the specific weather information for Dallas today from the provided documents. For the most accurate and up-to-date weather information, I recommend checking a reliable weather website or app such as [Weather.com](https://weather.com) or [AccuWeather](https://www.accuweather.com)."
      ],
      "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': 'Covid effects on obese people'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `docsearch` with `{'query': 'Covid effects on elderly people'}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "### Impact of COVID-19 on Obese People\n",
       "\n",
       "Obesity has been identified as a significant risk factor for severe outcomes in COVID-19 patients. Several studies have highlighted the increased severity and complications associated with COVID-19 in obese individuals:\n",
       "\n",
       "1. **Increased Severity and Complications**: Obese patients are more likely to develop severe COVID-19. A study involving 383 hospitalized patients in Shenzhen, China, found that obese patients had a 3.40-fold increased odds of developing severe disease compared to those with normal weight, after adjusting for various factors such as age, sex, and comorbidities [[1]](https://doi.org/10.2337/dc20-0576; https://www.ncbi.nlm.nih.gov/pubmed/32409502/?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-07-09T13:52:04Z&st=2024-07-09T05:52:04Z&spr=https&sig=9Nx31tWOzf6CWylUZnGaciT9VDWVJSJ9vQulMcshm7Q%3D).\n",
       "\n",
       "2. **Cardiac Complications**: Obesity is associated with an increased risk of cardiac complications in COVID-19 patients, including myocarditis, arrhythmias, heart failure, and sudden death. These complications are closely linked to in-hospital mortality [[2]](https://doi.org/10.1002/oby.22867; https://www.ncbi.nlm.nih.gov/pubmed/32365275/?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-07-09T13:52:04Z&st=2024-07-09T05:52:04Z&spr=https&sig=9Nx31tWOzf6CWylUZnGaciT9VDWVJSJ9vQulMcshm7Q%3D).\n",
       "\n",
       "3. **Higher ICU Admissions**: Data from the UK Intensive Care National Audit and Research Centre indicated that nearly 72% of critically ill COVID-19 patients were either overweight or obese, underscoring the impact of obesity on the severity of the disease [[3]](https://doi.org/10.1002/oby.22844; https://www.ncbi.nlm.nih.gov/pubmed/32314871/?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-07-09T13:52:04Z&st=2024-07-09T05:52:04Z&spr=https&sig=9Nx31tWOzf6CWylUZnGaciT9VDWVJSJ9vQulMcshm7Q%3D).\n",
       "\n",
       "4. **Theoretical Mechanisms**: Obesity may exacerbate COVID-19 outcomes through several mechanisms, including increased viral spread and immune activation due to adipose tissue acting as a reservoir for the virus. This can lead to cytokine amplification and a more severe inflammatory response [[4]](https://doi.org/10.1002/oby.22843; https://www.ncbi.nlm.nih.gov/pubmed/32314868/?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-07-09T13:52:04Z&st=2024-07-09T05:52:04Z&spr=https&sig=9Nx31tWOzf6CWylUZnGaciT9VDWVJSJ9vQulMcshm7Q%3D).\n",
       "\n",
       "### Impact of COVID-19 on Elderly People\n",
       "\n",
       "Elderly individuals are at a significantly higher risk of severe illness and mortality from COVID-19. Key findings include:\n",
       "\n",
       "1. **Higher Mortality Rates**: Mortality rates increase with age. Data from the Oxford COVID-19 Evidence Service indicated a mortality risk of 3.6% for people in their 60s, which rises to 8.0% for those in their 70s and 14.8% for those over 80 [[5]](https://doi.org/10.1111/jocn.15274; https://www.ncbi.nlm.nih.gov/pubmed/32239784/?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-07-09T13:52:04Z&st=2024-07-09T05:52:04Z&spr=https&sig=9Nx31tWOzf6CWylUZnGaciT9VDWVJSJ9vQulMcshm7Q%3D).\n",
       "\n",
       "2. **Increased Hospitalizations**: In Spain, 68% of all coronavirus hospitalizations were among those over 60 years of age, highlighting the greater incidence and severity of the disease in the elderly [[6]](https://doi.org/10.1016/j.enfcli.2020.05.004; https://www.ncbi.nlm.nih.gov/pubmed/32425485/?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-07-09T13:52:04Z&st=2024-07-09T05:52:04Z&spr=https&sig=9Nx31tWOzf6CWylUZnGaciT9VDWVJSJ9vQulMcshm7Q%3D).\n",
       "\n",
       "3. **Clinical Characteristics**: Elderly patients with COVID-19 are more likely to progress to severe disease and have higher mortality rates compared to younger patients. They also tend to have more extensive lung involvement and lower lymphocyte counts, which are indicators of a more severe infection [[7]](https://doi.org/10.1016/j.jinf.2020.03.005?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-07-09T13:52:04Z&st=2024-07-09T05:52:04Z&spr=https&sig=9Nx31tWOzf6CWylUZnGaciT9VDWVJSJ9vQulMcshm7Q%3D).\n",
       "\n",
       "4. **Intergenerational Risk**: The risk of infection among elderly people is significantly affected by the infection rates in younger age groups. Protecting elderly individuals from infection can also reduce the overall transmission of the virus [[8]](http://medrxiv.org/cgi/content/short/2020.05.17.20105049v1?rss=1?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-07-09T13:52:04Z&st=2024-07-09T05:52:04Z&spr=https&sig=9Nx31tWOzf6CWylUZnGaciT9VDWVJSJ9vQulMcshm7Q%3D).\n",
       "\n",
       "In summary, both obesity and advanced age significantly increase the risk of severe outcomes from COVID-19. Obese individuals are more likely to experience severe disease and complications, while elderly people face higher mortality rates and more severe clinical manifestations."
      ],
      "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(await doc_search.arun(\"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 myth that has circulated widely over the past few decades. The core elements of the story typically include:\n",
       "\n",
       "1. **The Drugged Drink**: The victim, often a business traveler, is approached by an attractive stranger in a bar who offers to buy them a drink. The drink is drugged, causing the victim to lose consciousness.\n",
       "2. **The Ice-Filled Bathtub**: The victim wakes up in a hotel bathtub filled with ice, disoriented and confused.\n",
       "3. **The Kidney Theft**: A note instructs the victim to call 911, and upon doing so, they are informed by the operator that one of their kidneys has been surgically removed by a ring of organ thieves.\n",
       "\n",
       "This legend is particularly memorable due to its vivid and concrete details, such as the ice-filled bathtub and the tube protruding from the victim's lower back. These elements make the story easy to remember and retell, contributing to its persistence in popular culture [[1]](https://datasetsgptsmartsearch.blob.core.windows.net/books/Made_To_Stick.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-07-09T13:52:04Z&st=2024-07-09T05:52:04Z&spr=https&sig=9Nx31tWOzf6CWylUZnGaciT9VDWVJSJ9vQulMcshm7Q%3D).\n",
       "\n",
       "The story often serves as a cautionary tale, warning people about the dangers of accepting drinks from strangers and the potential risks of organ theft. Despite its widespread circulation, there is no evidence to support the occurrence of such incidents in real life. The legend persists because it taps into deep-seated fears and uses concrete, memorable imagery to make a lasting impact [[2]](https://datasetsgptsmartsearch.blob.core.windows.net/books/Made_To_Stick.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-07-09T13:52:04Z&st=2024-07-09T05:52:04Z&spr=https&sig=9Nx31tWOzf6CWylUZnGaciT9VDWVJSJ9vQulMcshm7Q%3D)."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Test the other index created manually\n",
    "printmd(await book_search.arun(\"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': 'current president of India family members names'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `Searcher` with `{'query': 'Droupadi Murmu family members names'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `WebFetcher` with `{'url': 'https://starsunfolded.com/droupadi-murmu/'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `Searcher` with `{'query': 'site:starsunfolded.com Droupadi Murmu family members names'}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "The current President of India, Droupadi Murmu, has faced significant personal tragedies in her life. Here are the details of her family members:\n",
       "\n",
       "- **Husband**: Shyam Charan Murmu (deceased, was a bank officer)\n",
       "- **Children**:\n",
       "  - **Sons**: \n",
       "    - Laxman Murmu (deceased in 2009)\n",
       "    - Sipun Murmu (deceased in 2013)\n",
       "  - **Daughters**:\n",
       "    - One daughter who died at the age of 3 (name not known)\n",
       "    - Itishree Murmu (works in a bank)\n",
       "\n",
       "Droupadi Murmu has endured the loss of her husband and three of her children over the years [[1]](https://starsunfolded.com/droupadi-murmu/)."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Test the Bing Search Agent\n",
    "printmd(await www_search.arun(\"Who are the family member names of the current president of India?\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "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",
       "To determine the number of rows in the file, I used two methods:\n",
       "1. **Using `len(df)`**: This directly gives the number of rows in the DataFrame.\n",
       "2. **Using `df.shape`**: This returns a tuple where the first element is the number of rows and the second element is the number of columns.\n",
       "\n",
       "Both methods confirmed 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(await csv_search.arun(\"how many rows does the file have?\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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_checker` with `{'query': \"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",
      "Agent Action: \n",
      "Invoking: `sql_db_query` with `{'query': \"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": [
       "Final Answer: In July 2020, the total number of deaths due to COVID-19 in each state of the west coast were:\n",
       "- California: 229,362\n",
       "- Oregon: 7,745\n",
       "- Washington: 44,440\n",
       "\n",
       "Explanation:\n",
       "I queried the `covidtracking` table for the total number of deaths (`SUM(death)`) in July 2020 for the west coast states (California, Oregon, and Washington). The SQL query used is:\n",
       "\n",
       "```sql\n",
       "SELECT state, SUM(death) AS total_deaths \n",
       "FROM covidtracking \n",
       "WHERE state IN ('CA', 'OR', 'WA') \n",
       "  AND date LIKE '2020-07%' \n",
       "GROUP BY state\n",
       "```\n",
       "This query groups the results by state and sums the deaths for each state in July 2020. The results show 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(await sql_search.arun(\"How many people in total died california in each state of the west coast in July 2020?\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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 several functions to generate random numbers, but the most commonly used ones are `random()`, `randint()`, and `uniform()`.\n",
       "\n",
       "Here are some examples of how to use these functions:\n",
       "\n",
       "### 1. `random.random()`\n",
       "This function returns a random floating-point number between 0.0 and 1.0.\n",
       "\n",
       "```python\n",
       "import random\n",
       "\n",
       "# Generate a random floating-point number between 0.0 and 1.0\n",
       "random_number = random.random()\n",
       "print(random_number)\n",
       "```\n",
       "\n",
       "### 2. `random.randint(a, b)`\n",
       "This function returns a random integer between `a` and `b` (both inclusive).\n",
       "\n",
       "```python\n",
       "import random\n",
       "\n",
       "# Generate a random integer between 1 and 10 (inclusive)\n",
       "random_integer = random.randint(1, 10)\n",
       "print(random_integer)\n",
       "```\n",
       "\n",
       "### 3. `random.uniform(a, b)`\n",
       "This function returns a random floating-point number between `a` and `b`.\n",
       "\n",
       "```python\n",
       "import random\n",
       "\n",
       "# Generate a random floating-point number between 1.0 and 10.0\n",
       "random_float = random.uniform(1.0, 10.0)\n",
       "print(random_float)\n",
       "```\n",
       "\n",
       "### 4. `random.choice(seq)`\n",
       "This function returns a randomly selected element from a non-empty sequence like a list.\n",
       "\n",
       "```python\n",
       "import random\n",
       "\n",
       "# Generate a random element from a list\n",
       "random_element = random.choice([1, 2, 3, 4, 5])\n",
       "print(random_element)\n",
       "```\n",
       "\n",
       "### 5. `random.sample(population, k)`\n",
       "This function returns a list of `k` unique elements chosen from the population sequence or set.\n",
       "\n",
       "```python\n",
       "import random\n",
       "\n",
       "# Generate a list of 3 unique random elements from a list\n",
       "random_sample = random.sample([1, 2, 3, 4, 5], 3)\n",
       "print(random_sample)\n",
       "```\n",
       "\n",
       "### 6. `random.shuffle(x)`\n",
       "This function shuffles the sequence `x` in place.\n",
       "\n",
       "```python\n",
       "import random\n",
       "\n",
       "# Shuffle a list\n",
       "my_list = [1, 2, 3, 4, 5]\n",
       "random.shuffle(my_list)\n",
       "print(my_list)\n",
       "```\n",
       "\n",
       "These functions provide a variety of ways to generate random numbers and select random elements, making the `random` module very versatile for different use cases.\n",
       "\n",
       "For more detailed information, you can refer to the official Python documentation: [random module](https://docs.python.org/3/library/random.html)."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Test the ChatGPTWrapper Search Tool\n",
    "printmd(await chatgpt_search.arun(\"what is the function in python that allows me to get a random number?\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "7e1d4740-182a-4557-856d-75a81c3098b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tool: apisearch\n",
      "Agent Action: \n",
      "Invoking: `apisearch` with `{'query': 'current price of Bitcoin'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `apisearch` with `{'query': 'current price of Ethereum'}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "The current price of Bitcoin (BTC) against the USD is **USD 58,638.70**. Meanwhile, the current price of Ethereum (ETH) against the USD is **USD 3,104.07**."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Test the API Search Tool - This will be slower since it is using GPT-4\n",
    "printmd(await api_search.arun(\"what is the price now of Bitcoin? and of Ethereum?\"))"
   ]
  },
  {
   "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 simple 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": "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 2023'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `WebFetcher` with `{'url': 'https://www.elysee.fr/en/emmanuel-macron'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `Searcher` with `{'query': 'current president of France 2023 site:elysee.fr'}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "**bing**: The current President of France in 2023 is Emmanuel Macron. He was re-elected as President on April 24, 2022 [[1]](https://www.elysee.fr/en/emmanuel-macron)."
      ],
      "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": 23,
   "id": "5f58b57b-51cb-433c-b6a8-376e6aa06e12",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tool: docsearch\n",
      "Tool: bing\n",
      "Agent Action: \n",
      "Invoking: `Searcher` with `{'query': 'what is CLP'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `docsearch` with `{'query': 'CLP'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `WebFetcher` with `{'urls': ['https://echa.europa.eu/regulations/clp/understanding-clp', 'https://en.wikipedia.org/wiki/CLP_Regulation']}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `Searcher` with `{'query': 'site:echa.europa.eu regulations clp understanding-clp'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `Searcher` with `{'query': 'site:en.wikipedia.org CLP Regulation'}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "**docsearch**: CLP stands for **Constraint Logic Programming**, which is an extension of conventional logic programming. It integrates constraint solving into logic programming languages, allowing for more expressive and powerful programming paradigms. Here are some key points about CLP:\n",
       "\n",
       "1. **Definition and Origin**: The term CLP was first introduced by Jaffar and Lassez in 1986. It represents a general framework for a logic programming language that is parameterized with respect to a constraint language and a domain of computation. This framework ensures soundness and completeness for an operational semantics that relies 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-07-09T13:52:04Z&st=2024-07-09T05:52:04Z&spr=https&sig=9Nx31tWOzf6CWylUZnGaciT9VDWVJSJ9vQulMcshm7Q%3D).\n",
       "\n",
       "2. **Applications and Extensions**: CLP has been extended and refined for various applications, including linguistic knowledge representation and feature-based constraint languages. For example, it has been used to embed logical languages into constraint logic programs, enabling the operational treatment of declaratively specified grammars [[1]](https://datasetsgptsmartsearch.blob.core.windows.net/arxivcs/pdf/0008/0008036v1.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-07-09T13:52:04Z&st=2024-07-09T05:52:04Z&spr=https&sig=9Nx31tWOzf6CWylUZnGaciT9VDWVJSJ9vQulMcshm7Q%3D).\n",
       "\n",
       "3. **Technical Aspects**: CLP involves the use of constraint solvers that map constraints to true or false in finite time. The constraints are first-order formulas that include always satisfiable constraints (true), unsatisfiable constraints (false), and are closed under variable renaming, conjunction, and existential quantification. The associated domain is denoted as \\( D_C \\) [[2]](https://datasetsgptsmartsearch.blob.core.windows.net/arxivcs/pdf/0701/0701082v1.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-07-09T13:52:04Z&st=2024-07-09T05:52:04Z&spr=https&sig=9Nx31tWOzf6CWylUZnGaciT9VDWVJSJ9vQulMcshm7Q%3D).\n",
       "\n",
       "4. **Quantitative and Probabilistic Extensions**: There are also quantitative and probabilistic extensions of CLP. Quantitative CLP uses fuzzy set algebra to provide a formal semantics for quantitative inference, while probabilistic CLP specifies a probability distribution over proof trees or parses and uses statistical methods to infer model parameters from empirical data [[1]](https://datasetsgptsmartsearch.blob.core.windows.net/arxivcs/pdf/0008/0008036v1.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-07-09T13:52:04Z&st=2024-07-09T05:52:04Z&spr=https&sig=9Nx31tWOzf6CWylUZnGaciT9VDWVJSJ9vQulMcshm7Q%3D).\n",
       "\n",
       "In summary, CLP is a versatile and powerful extension of logic programming that incorporates constraint solving, making it suitable for a wide range of applications from software verification to linguistic knowledge representation."
      ],
      "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**: ### What is CLP?\n",
       "\n",
       "**CLP** stands for **Classification, Labelling and Packaging**. It is a regulation of the European Union, specifically Regulation (EC) No 1272/2008, which aligns the EU system of classification, labelling, and packaging of chemical substances and mixtures to the Globally Harmonised System (GHS) of the United Nations. The primary objectives of the CLP Regulation are:\n",
       "\n",
       "1. **Protection of Health and Environment**: Ensuring a high level of protection for human health and the environment.\n",
       "2. **Free Movement**: Facilitating the free movement of substances, mixtures, and articles within the EU.\n",
       "3. **Hazard Communication**: Providing a clear and consistent system for hazard communication through labels and safety data sheets.\n",
       "\n",
       "The regulation requires manufacturers, importers, and downstream users to classify, label, and package their hazardous chemicals appropriately before placing them on the market. This involves identifying the hazards of the substances or mixtures and comparing the hazard information with the criteria laid down in the CLP Regulation [[1]](https://echa.europa.eu/regulations/clp/understanding-clp) [[2]](https://en.wikipedia.org/wiki/CLP_Regulation).\n",
       "\n",
       "### Key Points of CLP Regulation\n",
       "\n",
       "- **Self-Classification**: Manufacturers, importers, and downstream users are responsible for the classification of substances and mixtures.\n",
       "- **Harmonised Classification**: Some substances have a harmonised classification and labelling at the EU level to ensure consistent hazard communication.\n",
       "- **Notification**: Companies must notify the European Chemicals Agency (ECHA) of the classification and labelling of substances they place on the market.\n",
       "- **Labelling and Packaging**: Hazard labels must include specific information such as hazard pictograms, signal words, hazard statements, precautionary statements, and the identity of the supplier.\n",
       "\n",
       "For more detailed information, you can refer to the [ECHA website](https://echa.europa.eu/regulations/clp/understanding-clp) and the [Wikipedia page on CLP Regulation](https://en.wikipedia.org/wiki/CLP_Regulation)."
      ],
      "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": 24,
   "id": "ea67e969-26b3-4e6f-a6c0-16780ed418e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "agent = create_openai_tools_agent(llm, tools, CUSTOM_CHATBOT_PROMPT)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "d9d2d5b4-0145-402e-a620-0fe3f3548acf",
   "metadata": {},
   "outputs": [],
   "source": [
    "agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "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": 27,
   "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": 28,
   "id": "601fce84-4a02-41a6-8ae2-f692174d4cc8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "session439 user393\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": 29,
   "id": "4b37988b-9fb4-4958-bc17-d58d8dac8bb7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Hello Pablo Marin! I'm here and ready to assist you with any questions or tasks you have. How can I help 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": 30,
   "id": "a070c558-3963-40ef-b94e-365324ee3d20",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "My name is Jarvis. I am an assistant designed to help with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions. Whether you need help with research, step-by-step instructions, or detailed information on a variety of topics, I'm here to assist you. How can I help 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": 31,
   "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",
      "Agent Action: \n",
      "Invoking: `Searcher` with `{'query': 'Sushi restaurants in downtown Chicago'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `WebFetcher` with `{'url': 'https://www.tripadvisor.com/Restaurants-g35805-c26-zfn7778523-Chicago_Illinois.html'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `WebFetcher` with `{'url': 'https://www.opentable.com/cuisine/best-italian-restaurants-downtown-chicago-il'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `WebFetcher` with `{'url': 'https://www.yelp.com/search?find_desc=Italian+Restaurants+Downtown&find_loc=Chicago%2C+IL'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `WebFetcher` with `{'url': 'https://www.opentable.com/cuisine/best-sushi-restaurants-downtown-chicago-il'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `WebFetcher` with `{'url': 'https://www.yelp.com/search?find_desc=sushi+downtown&find_loc=Chicago%2C+IL'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `Searcher` with `{'query': 'site:tripadvisor.com Italian restaurants in downtown Chicago'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `Searcher` with `{'query': 'site:opentable.com Italian restaurants in downtown Chicago'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `Searcher` with `{'query': 'site:yelp.com Italian restaurants in downtown Chicago'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `Searcher` with `{'query': 'site:opentable.com Sushi restaurants in downtown Chicago'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `Searcher` with `{'query': 'site:yelp.com Sushi restaurants in downtown Chicago'}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "Here are some top Italian and Sushi restaurants in downtown Chicago:\n",
       "\n",
       "### Italian Restaurants\n",
       "\n",
       "1. **La Rosetta**\n",
       "   - **Description**: Known for its great salads and lunch portions.\n",
       "   - **Link**: [Tripadvisor](https://www.tripadvisor.com/Restaurants-g35805-c26-zfn7778523-Chicago_Illinois.html)\n",
       "\n",
       "2. **Acanto**\n",
       "   - **Description**: Exceptional authentic Italian cuisine with an impressive wine list and terrific service.\n",
       "   - **Link**: [OpenTable](https://www.opentable.com/cuisine/best-italian-restaurants-downtown-chicago-il)\n",
       "\n",
       "3. **Viaggio Ristorante & Lounge**\n",
       "   - **Description**: A popular spot for Italian cuisine in downtown Chicago.\n",
       "   - **Link**: [Yelp](https://www.yelp.com/search?find_desc=Italian+Restaurants+Downtown&find_loc=Chicago%2C+IL)\n",
       "\n",
       "4. **Volare Ristorante Italiano**\n",
       "   - **Description**: Offers a traditional Italian dining experience.\n",
       "   - **Link**: [Yelp](https://www.yelp.com/search?find_desc=Italian+Restaurants+Downtown&find_loc=Chicago%2C+IL)\n",
       "\n",
       "5. **Osteria Via Stato**\n",
       "   - **Description**: An authentic Italian restaurant in downtown Chicago's River North neighborhood.\n",
       "   - **Link**: [Osteria Via Stato](https://www.osteriaviastato.com/)\n",
       "\n",
       "### Sushi Restaurants\n",
       "\n",
       "1. **SUSHI-SAN - River North**\n",
       "   - **Description**: Praised as one of the best Japanese restaurants in the US, offering a great dining experience with reasonable prices.\n",
       "   - **Link**: [OpenTable](https://www.opentable.com/cuisine/best-sushi-restaurants-downtown-chicago-il)\n",
       "\n",
       "2. **Sushi Plus Rotary Sushi Bar**\n",
       "   - **Description**: Known for its unique rotary sushi experience.\n",
       "   - **Link**: [Yelp](https://www.yelp.com/search?find_desc=sushi+downtown&find_loc=Chicago%2C+IL)\n",
       "\n",
       "3. **Nobu Chicago**\n",
       "   - **Description**: A high-end sushi restaurant offering a luxurious dining experience.\n",
       "   - **Link**: [Yelp](https://www.yelp.com/search?find_desc=sushi+downtown&find_loc=Chicago%2C+IL)\n",
       "\n",
       "4. **Sushi Taku**\n",
       "   - **Description**: A popular sushi spot in downtown Chicago.\n",
       "   - **Link**: [Yelp](https://www.yelp.com/search?find_desc=sushi+downtown&find_loc=Chicago%2C+IL)\n",
       "\n",
       "5. **Sunda - River North**\n",
       "   - **Description**: Offers a diverse menu and a superb whiskey list.\n",
       "   - **Link**: [Yelp](https://www.yelp.com/search?find_desc=sushi+downtown&find_loc=Chicago%2C+IL)\n",
       "\n",
       "These restaurants are highly rated and offer a variety of dining experiences in downtown Chicago. Enjoy your meal!"
      ],
      "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": 32,
   "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 Taku downtown Chicago'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `Searcher` with `{'query': 'Sushi Taku reviews downtown Chicago'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `Searcher` with `{'query': 'Sushi Taku menu downtown Chicago'}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "### Sushi Taku in Downtown Chicago\n",
       "\n",
       "**Sushi Taku** is a well-known sushi restaurant in Chicago, particularly famous for its all-you-can-eat sushi offerings. Here are some key details about the restaurant:\n",
       "\n",
       "#### Location\n",
       "- **Address**: 1904 W Division St, Chicago, IL 60622 (Wicker Park)\n",
       "- **Phone**: (773) 252-8258\n",
       "- **Website**: [Sushi Taku](https://www.sushitaku.com/)\n",
       "\n",
       "#### Menu and Pricing\n",
       "- **Lunch**: $22.99 per person (Monday to Friday, 12 noon – 3:30 pm)\n",
       "- **Dinner**: $31.99 per person (4:30 pm – Close, all day on Saturday and Sunday)\n",
       "- The menu includes a wide selection of appetizers, nigiri, signature rolls, regular rolls (which can also be made into hand rolls), vegetable rolls, and desserts (dinner only) [[Sushi Taku Menu](https://www.sushitaku.com/all-you-can-eat-sushi-in-chicago/)].\n",
       "\n",
       "#### Reviews\n",
       "- **Yelp**: Sushi Taku has received positive reviews for its premium quality sushi at reasonable prices. Customers appreciate the variety and freshness of the sushi, as well as the efficient service [[Yelp Reviews](https://www.yelp.com/biz/sushi-taku-chicago-2)].\n",
       "- **Tripadvisor**: The restaurant is rated 4 out of 5 stars, with customers highlighting the excellent all-you-can-eat sushi dinner and the selection of made-to-order appetizers [[Tripadvisor Reviews](https://www.tripadvisor.co.nz/Restaurant_Review-g35805-d13154764-Reviews-Sushi_Taku-Chicago_Illinois.html)].\n",
       "\n",
       "#### Additional Information\n",
       "- **Specialties**: Sushi Taku is known for its all-you-can-eat sushi, which includes a variety of sushi rolls, nigiri, and appetizers. The restaurant was established in 2017 and has since become a favorite spot for sushi lovers in Chicago [[Yelp](https://www.yelp.com/biz/sushi-taku-chicago-2)].\n",
       "\n",
       "For more details, you can visit their [official website](https://www.sushitaku.com/) or check out their [menu](https://www.sushitaku.com/menu-locations/).\n",
       "\n",
       "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": 33,
   "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:\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",
       "Momentum is a vector quantity, which means it has both magnitude and direction. The SI unit for momentum is kilogram meter per second (kg·m/s).\n",
       "\n",
       "### Example Calculation\n",
       "\n",
       "If you have an object with a mass of 5 kg moving at a velocity of 10 m/s, the momentum can be calculated as follows:\n",
       "\n",
       "\\[ p = 5 \\, \\text{kg} \\times 10 \\, \\text{m/s} = 50 \\, \\text{kg·m/s} \\]\n",
       "\n",
       "This means the object has a momentum of 50 kg·m/s in the direction of 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": 34,
   "id": "94f354eb-884d-4fd3-842e-a8adc3b09a70",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tool: docsearch\n",
      "Agent Action: \n",
      "Invoking: `docsearch` with `{'query': 'NP-complete problem'}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "An NP-complete problem is a type of problem in computational complexity theory that is both in NP (nondeterministic polynomial time) and NP-hard. Here are the key points about NP-complete problems:\n",
       "\n",
       "1. **Class NP**: This class includes decision problems for which a given solution can be verified as correct or incorrect in polynomial time by a deterministic Turing machine. Essentially, if you are given a solution, you can check its correctness quickly (in polynomial time) [[1]](https://datasetsgptsmartsearch.blob.core.windows.net/arxivcs/pdf/9906/9906006v1.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-07-09T13:52:04Z&st=2024-07-09T05:52:04Z&spr=https&sig=9Nx31tWOzf6CWylUZnGaciT9VDWVJSJ9vQulMcshm7Q%3D).\n",
       "\n",
       "2. **NP-hard**: A problem is NP-hard if every problem in NP can be reduced to it in polynomial time. This means that an NP-hard problem is at least as hard as the hardest problems in NP. However, NP-hard problems are not necessarily in NP themselves; they might not have solutions that can be verified in polynomial time [[2]](https://datasetsgptsmartsearch.blob.core.windows.net/arxivcs/pdf/9906/9906006v2.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-07-09T13:52:04Z&st=2024-07-09T05:52:04Z&spr=https&sig=9Nx31tWOzf6CWylUZnGaciT9VDWVJSJ9vQulMcshm7Q%3D).\n",
       "\n",
       "3. **NP-complete**: A problem is NP-complete if it is both in NP and NP-hard. This means that it is one of the hardest problems in NP, and if you can solve one NP-complete problem in polynomial time, you can solve all problems in NP in polynomial time. The concept of NP-completeness was first introduced by Stephen Cook in 1971 with the Boolean satisfiability problem (SAT) being the first known NP-complete problem [[1]](https://datasetsgptsmartsearch.blob.core.windows.net/arxivcs/pdf/0604/0604113v1.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-07-09T13:52:04Z&st=2024-07-09T05:52:04Z&spr=https&sig=9Nx31tWOzf6CWylUZnGaciT9VDWVJSJ9vQulMcshm7Q%3D).\n",
       "\n",
       "4. **Polynomial-time Reduction**: To prove that a problem is NP-complete, one typically shows that an already known NP-complete problem can be reduced to the new problem in polynomial time. This involves transforming instances of the known NP-complete problem into instances of the new problem in such a way that the new problem's solution corresponds to the solution of the original problem [[2]](https://datasetsgptsmartsearch.blob.core.windows.net/arxivcs/pdf/9906/9906006v2.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-07-09T13:52:04Z&st=2024-07-09T05:52:04Z&spr=https&sig=9Nx31tWOzf6CWylUZnGaciT9VDWVJSJ9vQulMcshm7Q%3D).\n",
       "\n",
       "5. **Significance**: The significance of NP-complete problems lies in the P vs NP question, which asks whether every problem whose solution can be quickly verified (NP) can also be quickly solved (P). If any NP-complete problem can be solved in polynomial time, then P = NP. Conversely, if no NP-complete problem can be solved in polynomial time, then P ≠ NP. This is one of the most important open questions in computer science [[1]](https://datasetsgptsmartsearch.blob.core.windows.net/arxivcs/pdf/9906/9906006v1.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-07-09T13:52:04Z&st=2024-07-09T05:52:04Z&spr=https&sig=9Nx31tWOzf6CWylUZnGaciT9VDWVJSJ9vQulMcshm7Q%3D).\n",
       "\n",
       "In summary, NP-complete problems are a central concept in computational complexity theory, representing the most challenging problems within NP. Solving any one of these problems efficiently would revolutionize the field by proving that P = NP."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "printmd(brain_agent_executor.invoke({\"question\": \"docsearch, what is a NP-complete problem?\"}, config=config)[\"output\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "2fd67aed-ecd7-4096-9266-22de30c64e71",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tool: docsearch\n",
      "Agent Action: \n",
      "Invoking: `docsearch` with `{'query': 'example of NP-complete problem'}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "### Examples of NP-Complete Problems\n",
       "\n",
       "#### 1. 3-SAT (3-Satisfiability) Problem\n",
       "The **3-SAT problem** is a classic example of an NP-complete problem. It involves determining whether there exists an assignment of truth values to variables that satisfies a given Boolean formula in conjunctive normal form, where each clause contains exactly three literals.\n",
       "\n",
       "- **Problem Statement**: Given a Boolean formula in conjunctive normal form with each clause containing exactly three literals, determine if there is a way to assign truth values to the variables such that the entire formula evaluates to true.\n",
       "- **Example**: Consider the formula \\((x_1 \\lor \\neg x_2 \\lor x_3) \\land (\\neg x_1 \\lor x_2 \\lor \\neg x_3) \\land (x_1 \\lor x_2 \\lor x_3)\\). The task is to find an assignment of \\(x_1\\), \\(x_2\\), and \\(x_3\\) that makes the formula true.\n",
       "\n",
       "This problem is significant because it serves as a basis for proving the NP-completeness of other problems through polynomial-time reductions [[1]](https://datasetsgptsmartsearch.blob.core.windows.net/arxivcs/pdf/9906/9906006v1.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-07-09T13:52:04Z&st=2024-07-09T05:52:04Z&spr=https&sig=9Nx31tWOzf6CWylUZnGaciT9VDWVJSJ9vQulMcshm7Q%3D).\n",
       "\n",
       "#### 2. Queens Problem\n",
       "The **Queens problem** is a variant of the classical n-queens problem. In this version, the input is a number \\( m \\) together with a \\( k \\times k' \\) board whose squares are either black or white. The black squares act as walls through which a queen cannot pass. The problem is to determine whether \\( m \\) queens can be placed on the board such that no queen can attack another.\n",
       "\n",
       "- **Problem Statement**: Given a \\( k \\times k' \\) board with black and white squares and a number \\( m \\), determine if \\( m \\) queens can be placed on the board such that no two queens can attack each other.\n",
       "- **Example**: Imagine a \\( 4 \\times 4 \\) board with some black squares acting as walls. The task is to place 4 queens on the board such that no two queens can attack each other, considering the walls.\n",
       "\n",
       "This problem has been proven to be NP-complete with respect to polynomial-time reductions [[2]](https://datasetsgptsmartsearch.blob.core.windows.net/arxivcs/pdf/0701/0701049v1.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-07-09T13:52:04Z&st=2024-07-09T05:52:04Z&spr=https&sig=9Nx31tWOzf6CWylUZnGaciT9VDWVJSJ9vQulMcshm7Q%3D).\n",
       "\n",
       "These examples illustrate the complexity and intractability of NP-complete problems, which are central to the study of computational complexity theory."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "printmd(brain_agent_executor.invoke({\"question\": \"can you tell an example?\"}, config=config)[\"output\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "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_checker` with `{'query': \"SELECT SUM(death) AS total_deaths FROM covidtracking WHERE state = 'TX' AND date LIKE '2020%'\"}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `sql_db_query` with `{'query': \"SELECT SUM(death) AS total_deaths FROM covidtracking WHERE state = 'TX' AND date LIKE '2020%'\"}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "In 2020, a total of 2,841,253 people died of COVID-19 in Texas. This data was obtained from a query on the `covidtracking` table, summing up the deaths recorded for the state of Texas in the year 2020. \n",
       "\n",
       "For more detailed information, you can refer to the data source or the specific query used:\n",
       "\n",
       "```sql\n",
       "SELECT SUM(death) AS total_deaths FROM covidtracking WHERE state = 'TX' AND date LIKE '2020%'\n",
       "```\n",
       "\n",
       "This query aggregates the total number of deaths recorded in Texas for the year 2020."
      ],
      "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": 37,
   "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_checker` with `{'query': \"SELECT SUM(deathIncrease) AS total_deaths FROM covidtracking WHERE state = 'TX' AND date LIKE '2020%'\"}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `sql_db_query` with `{'query': \"SELECT SUM(deathIncrease) AS total_deaths FROM covidtracking WHERE state = 'TX' AND date LIKE '2020%'\"}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "In 2020, a total of **27,437** people died of COVID-19 in Texas. This data was obtained by summing up the daily increases in deaths recorded for the state of Texas in the year 2020 using the `deathIncrease` column.\n",
       "\n",
       "Here is the SQL query used to obtain this information:\n",
       "\n",
       "```sql\n",
       "SELECT SUM(deathIncrease) AS total_deaths FROM covidtracking WHERE state = 'TX' AND date LIKE '2020%'\n",
       "```\n",
       "\n",
       "This query aggregates the total number of deaths recorded in Texas for the year 2020 based on the daily increases in deaths."
      ],
      "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 instead?\"}, config=config)[\"output\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "410d398b-d589-4352-8c42-2df5be173498",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tool: booksearch\n",
      "Agent Action: \n",
      "Invoking: `docsearch` with `{'query': 'how to say no to kids and set boundaries'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `docsearch` with `{'query': 'setting boundaries with children'}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "Setting boundaries and saying no to children is crucial for their development and safety. Here are some key strategies and insights on how to effectively set boundaries and say no to kids:\n",
       "\n",
       "### 1. **Teach the Importance of Boundaries**\n",
       "Children need to understand that boundaries are essential for their safety and well-being. Teaching them to say \"no\" helps them feel empowered and safe in a world that can be manipulative and exploitative. For example, children should be able to say things like \"No,\" \"I disagree,\" \"I will not,\" \"Stop that,\" and \"It hurts\" [[1]](https://datasetsgptsmartsearch.blob.core.windows.net/books/Boundaries_When_to_Say_Yes_How_to_Say_No_to_Take_Control_of_Your_Life.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-07-09T13:52:04Z&st=2024-07-09T05:52:04Z&spr=https&sig=9Nx31tWOzf6CWylUZnGaciT9VDWVJSJ9vQulMcshm7Q%3D).\n",
       "\n",
       "### 2. **Model and Respect Boundaries**\n",
       "Parents should model good boundary-setting behavior and respect their children's boundaries. For instance, if a child does not want to hug a relative, parents should support their decision and explain to the relative that the child is learning to set personal boundaries [[2]](https://datasetsgptsmartsearch.blob.core.windows.net/books/Boundaries_When_to_Say_Yes_How_to_Say_No_to_Take_Control_of_Your_Life.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-07-09T13:52:04Z&st=2024-07-09T05:52:04Z&spr=https&sig=9Nx31tWOzf6CWylUZnGaciT9VDWVJSJ9vQulMcshm7Q%3D).\n",
       "\n",
       "### 3. **Encourage Safe Expression of \"No\"**\n",
       "Children should feel safe to express their disagreement or refusal. Parents should not withdraw emotionally or become enraged when a child says no. Instead, they should help the child feel that their \"no\" is just as lovable as their \"yes\" [[3]](https://datasetsgptsmartsearch.blob.core.windows.net/books/Boundaries_When_to_Say_Yes_How_to_Say_No_to_Take_Control_of_Your_Life.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-07-09T13:52:04Z&st=2024-07-09T05:52:04Z&spr=https&sig=9Nx31tWOzf6CWylUZnGaciT9VDWVJSJ9vQulMcshm7Q%3D).\n",
       "\n",
       "### 4. **Set Age-Appropriate Boundaries**\n",
       "Parents need to set and maintain age-appropriate boundaries. This includes not giving in to temper tantrums and using time-outs, appropriate confrontations, and other disciplinary measures when necessary. This helps children learn to accept limits and understand the consequences of their actions [[4]](https://datasetsgptsmartsearch.blob.core.windows.net/books/Boundaries_When_to_Say_Yes_How_to_Say_No_to_Take_Control_of_Your_Life.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-07-09T13:52:04Z&st=2024-07-09T05:52:04Z&spr=https&sig=9Nx31tWOzf6CWylUZnGaciT9VDWVJSJ9vQulMcshm7Q%3D).\n",
       "\n",
       "### 5. **Avoid Overcontrol**\n",
       "While it is important to protect children, overcontrolling them can lead to dependency and difficulty in setting and keeping firm boundaries. Parents should allow children to make mistakes and learn from them, which is essential for developing maturity and independence [[5]](https://datasetsgptsmartsearch.blob.core.windows.net/books/Boundaries_When_to_Say_Yes_How_to_Say_No_to_Take_Control_of_Your_Life.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-07-09T13:52:04Z&st=2024-07-09T05:52:04Z&spr=https&sig=9Nx31tWOzf6CWylUZnGaciT9VDWVJSJ9vQulMcshm7Q%3D).\n",
       "\n",
       "### 6. **Teach Responsibility**\n",
       "Teaching children responsibility is a key part of boundary development. This includes helping them understand what they are responsible for and what they are not. For example, children should learn to take care of their belongings and perform tasks around the house [[6]](https://datasetsgptsmartsearch.blob.core.windows.net/books/Boundaries_When_to_Say_Yes_How_to_Say_No_to_Take_Control_of_Your_Life.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-07-09T13:52:04Z&st=2024-07-09T05:52:04Z&spr=https&sig=9Nx31tWOzf6CWylUZnGaciT9VDWVJSJ9vQulMcshm7Q%3D).\n",
       "\n",
       "### 7. **Support System**\n",
       "Parents should establish a support system that encourages boundary setting. This can include co-dependency groups, therapists, marriage counselors, or pastors. Practicing boundary setting in safe relationships can help parents grow in their ability to set limits with their children [[7]](https://datasetsgptsmartsearch.blob.core.windows.net/books/Boundaries_When_to_Say_Yes_How_to_Say_No_to_Take_Control_of_Your_Life.pdf?sv=2022-11-02&ss=b&srt=sco&sp=rl&se=2026-07-09T13:52:04Z&st=2024-07-09T05:52:04Z&spr=https&sig=9Nx31tWOzf6CWylUZnGaciT9VDWVJSJ9vQulMcshm7Q%3D).\n",
       "\n",
       "By implementing these strategies, parents can help their children develop healthy boundaries, which are essential for their emotional and psychological well-being."
      ],
      "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": 39,
   "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 places to dine in downtown Seoul'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `Searcher` with `{'query': 'top restaurants in downtown Seoul 2023'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `Searcher` with `{'query': 'must-try restaurants in downtown Seoul'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `WebFetcher` with `{'url': 'https://www.eater.com/maps/best-seoul-restaurants-38'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `WebFetcher` with `{'url': 'https://www.tripadvisor.com/Restaurants-g294197-Seoul.html'}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "Here are some top dining options in downtown Seoul:\n",
       "\n",
       "### 1. **Mosu**\n",
       "- **Description**: A fine-dining restaurant originally from San Francisco, Mosu offers a sophisticated dining experience with a focus on Korean ingredients and innovative dishes.\n",
       "- **Link**: [Gourmet Traveller](https://www.gourmettraveller.com.au/travel/destinations/restaurants-seoul-south-korea/)\n",
       "\n",
       "### 2. **Woo Lae Oak**\n",
       "- **Description**: A Michelin Guide 2023 Bib Gourmand restaurant known for its traditional Korean dishes. It has a long history and is a favorite among locals and tourists alike.\n",
       "- **Link**: [Kimchimari](https://kimchimari.com/best-seoul-restaurants-2023/)\n",
       "\n",
       "### 3. **Bar Cham**\n",
       "- **Description**: Featured in Asia’s 50 Best Bars list, Bar Cham offers a variety of cocktails, including non-alcoholic options. It’s a great place for a relaxed evening with a unique drink menu.\n",
       "- **Link**: [Eater](https://www.eater.com/maps/best-seoul-restaurants-38)\n",
       "\n",
       "### 4. **Plant Cafe**\n",
       "- **Description**: One of the first vegan restaurants in Seoul, Plant Cafe offers a range of plant-based dishes including vegan bowls, veggie burgers, and wraps. It’s a popular spot for those looking for healthy and delicious vegan options.\n",
       "- **Link**: [Lonely Planet](https://www.lonelyplanet.com/articles/best-places-to-eat-in-seoul)\n",
       "\n",
       "### 5. **Yoogane**\n",
       "- **Description**: Known for its chicken galbi, Yoogane is a popular chain with over 130 branches. The dish is a spicy stir-fried chicken with cheese, vegetables, and rice, making it a favorite among young locals.\n",
       "- **Link**: [Jetset Times](https://jetsettimes.com/countries/south-korea/seoul/seoul-food/where-to-eat-in-seoul-10-must-try-restaurants/)\n",
       "\n",
       "### 6. **Noryangjin Fish Market**\n",
       "- **Description**: One of Korea’s biggest seafood markets, Noryangjin Fish Market offers a wide variety of live seafood. It’s a must-visit for seafood lovers looking to experience fresh and diverse marine cuisine.\n",
       "- **Link**: [Will Fly for Food](https://www.willflyforfood.net/seoul-food-guide-25-must-eat-restaurants-in-seoul-south-korea/)\n",
       "\n",
       "### 7. **THE PLACE Dining**\n",
       "- **Description**: An Italian restaurant located in the N Seoul Tower Plaza, offering stunning 360-degree views of Seoul. It’s a great spot for a romantic dinner with a view.\n",
       "- **Link**: [The Smart Local](https://thesmartlocal.com/read/korea-scenic-restaurants/)\n",
       "\n",
       "These restaurants offer a variety of dining experiences, from fine dining and traditional Korean cuisine to vegan options and seafood markets. Whether you're looking for a sophisticated meal or a casual dining experience, downtown Seoul has something to offer for every palate. Enjoy your meal!"
      ],
      "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": 40,
   "id": "080cc28e-2130-4c79-ba7d-0ed702f0ea7a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Certainly! In JavaScript, you can trim the spaces from the beginning and end of a string using the `trim()` method. Here is an example:\n",
       "\n",
       "### Example: Trimming Spaces from a Sentence\n",
       "\n",
       "```javascript\n",
       "// Original sentence with leading and trailing spaces\n",
       "let sentence = \"   Hello, World!   \";\n",
       "\n",
       "// Using the trim() method to remove spaces\n",
       "let trimmedSentence = sentence.trim();\n",
       "\n",
       "// Output the result\n",
       "console.log(\"Original Sentence: '\" + sentence + \"'\");\n",
       "console.log(\"Trimmed Sentence: '\" + trimmedSentence + \"'\");\n",
       "```\n",
       "\n",
       "### Explanation\n",
       "\n",
       "1. **Original Sentence**: The variable `sentence` contains a string with leading and trailing spaces.\n",
       "2. **Trim Method**: The `trim()` method is called on the `sentence` string to remove the spaces from both the beginning and the end.\n",
       "3. **Output**: The original and trimmed sentences are logged to the console for comparison.\n",
       "\n",
       "### Output\n",
       "\n",
       "```plaintext\n",
       "Original Sentence: '   Hello, World!   '\n",
       "Trimmed Sentence: 'Hello, World!'\n",
       "```\n",
       "\n",
       "The `trim()` method is a simple and effective way to remove unwanted spaces from the beginning and end of a string in JavaScript."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "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": "a5ded8d9-0bfe-4e16-be3f-382271c120a9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "You're welcome, Pablo! 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": "5c289a29-55c4-46df-b8a0-68d5674c1286",
   "metadata": {},
   "source": [
    "# Option 3: Using LangGraph\n",
    "See Notebook 11.5"
   ]
  },
  {
   "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
}