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": "code",
   "execution_count": 3,
   "id": "1072b488-e03c-4663-a9ed-12f8d8ef244b",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Uncomment if you want to trace and monitor the runs with LangSmith\n",
    "# os.environ[\"LANGCHAIN_TRACING_V2\"] = \"True\"\n",
    "# os.environ[\"LANGCHAIN_ENDPOINT\"] = \"https://api.smith.langchain.com\"\n",
    "# os.environ[\"LANGCHAIN_API_KEY\"] = \"<ENTER_YOUR_LANGSMITH_API>\"\n",
    "# os.environ[\"LANGCHAIN_PROJECT\"] = \"Notebook.11\""
   ]
  },
  {
   "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": 4,
   "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[\"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": 5,
   "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": 6,
   "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": 7,
   "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": 8,
   "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": 9,
   "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": 32,
   "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": 25,
   "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": 12,
   "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'}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "I'm sorry, but I couldn't find the specific weather information for Dallas. If you'd like, I can attempt to search for it again."
      ],
      "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": 13,
   "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-19 affect obese people?'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `docsearch` with `{'query': 'How does COVID-19 affect elderly people?'}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "### How COVID-19 Affects Obese People\n",
       "\n",
       "COVID-19 has been shown to have a more severe impact on obese individuals, leading to more serious symptoms and a negative prognosis. Here are some key findings related to the impact of COVID-19 on obese individuals:\n",
       "\n",
       "1. **Increased Risk of Severe Disease**: Obese patients have been found to have increased odds of progressing to severe COVID-19. A study in China found that obese patients had a 3.40-fold odds of developing severe disease compared to normal weight patients. Additionally, men who were obese had increased odds of developing severe COVID-19 compared to those who were normal weight [[1]](https://doi.org/10.2337/dc20-0576).\n",
       "\n",
       "2. **Symptoms and Complications**: Obese patients tend to have symptoms such as cough and fever, and they are at a higher risk of exacerbations from viral respiratory infections. The severity of coronavirus disease 2019 (COVID-19) is significantly associated with obesity, indicating a greater impact on seriously ill COVID-19 patients who are overweight or obese [[2]](https://doi.org/10.1002/oby.22844).\n",
       "\n",
       "3. **Risk Factor for Serious Illness**: The World Health Organization (WHO) considers obesity a major risk factor for becoming seriously ill with COVID-19. Data from the UK Intensive Care National Audit and Research Centre indicates that two-thirds of people who developed serious or fatal COVID-19-related complications were overweight or obese [[3]](https://doi.org/10.1002/oby.22844).\n",
       "\n",
       "4. **Pathogenesis and Mechanisms**: Obesity plays a significant part in the pathogenesis of COVID-19 patients, and the role of Body Mass Index (BMI) in the severity of COVID-19 should not be ignored. The consequences of inflammation of adipose tissue have been reported as a leading cause of insulin resistance and hypertension due to metabolic dysfunction. BMI plays a significant role in COVID-19 severity, especially in the elderly population [[4]](http://medrxiv.org/cgi/content/short/2020.05.11.20098806v1?rss=1).\n",
       "\n",
       "### How COVID-19 Affects Elderly People\n",
       "\n",
       "Elderly individuals are at a higher risk of more serious and possibly fatal illness associated with COVID-19. Here are some key findings related to the impact of COVID-19 on elderly individuals:\n",
       "\n",
       "1. **Incidence and Severity**: The current SARS-CoV-2 pandemic (COVID-19) 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. 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 [[5]](https://doi.org/10.1016/j.enfcli.2020.05.004).\n",
       "\n",
       "2. **Social Isolation and Health Measures**: Global recommendations for older populations include social isolation, hygiene, and social distancing measures to reduce the transmission of the virus. Biopsychosocial care of elderly people, adapting care and personalizing decisions on hospital admissions, palliative care, and alternatives for monitoring and treatment of COVID-19 pathology are essential [[6]](https://doi.org/10.1016/j.enfcli.2020.05.004).\n",
       "\n",
       "3. **Risk Patterns and Interactions**: 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. Interventions to protect the elderly should be effective and for the long term [[7]](http://medrxiv.org/cgi/content/short/2020.05.17.20105049v1?rss=1).\n",
       "\n",
       "4. **Impact on Drug Therapy**: The COVID-19 pandemic presents many medical and social issues for older people, including the safety and efficacy of drug therapy in the context of COVID-19. This highlights the need for specialized care and treatment for elderly individuals [[8]](https://doi.org/10.4140/tcp.n.2020.190).\n",
       "\n",
       "These findings underscore the increased vulnerability of obese and elderly individuals to the severe impact of COVID-19, emphasizing the importance of tailored care and preventive measures for these at-risk populations.\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(await doc_search.arun(\"How Covid affects obese people? and elderly?\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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. This legend typically involves a core set of three elements: a drugged drink, an ice-filled bathtub, and the punch line of kidney theft. There are numerous versions of this legend, each with its own specific details, but the core elements remain consistent across the variations. One version, for example, features a married man who receives a drugged drink from a prostitute he has invited to his room in Las Vegas, creating a morality play with kidneys.\n",
       "\n",
       "This legend is an example of a story that sticks in people's minds. It is memorable, understandable, and effective in changing thought or behavior. The story is characterized by vivid, concrete details, such as the ice-filled bathtub and the weird tube protruding from the lower back, which evoke fear, disgust, and suspicion. These concrete details make the story more tangible and believable, contributing to its memorability and retellability.\n",
       "\n",
       "The \"Kidney Heist\" legend is an example of how localized details lend credibility to stories. Folk legends, including urban legends, often acquire credibility and effect from their localized details, making them more memorable and believable. Concrete details not only lend credibility to the authorities who provide them but also lend credibility to the idea itself.\n",
       "\n",
       "The legend of the \"Kidney Heist\" is just one example of a sticky idea, and it demonstrates the power of stories in shaping perceptions, beliefs, and behaviors. It is a compelling illustration of how certain stories, through their vivid and concrete details, can stick in people's minds and influence their actions.\n",
       "\n",
       "This information was found in the book \"Made to Stick\" by Chip Heath and Dan Heath, which discusses the traits of sticky ideas and the power of stories in shaping perceptions and behaviors.\n",
       "\n",
       "For more details, you can refer to the source: [Made to Stick - The Power of Stories](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)"
      ],
      "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": 16,
   "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",
      "Agent Action: \n",
      "Invoking: `Searcher` with `{'query': 'Droupadi Murmu family members'}`\n",
      "responded: The current President of India is Droupadi Murmu. However, the search did not yield specific information about her family members. I will conduct another search to gather more details about the family members of Droupadi Murmu.\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "The family members of Droupadi Murmu, the current President of India, include her late husband, Shyam Charan Murmu, and her children. She had three children, two sons, and a daughter. Unfortunately, one of her sons, Laxman Murmu, passed away in 2009, and her second son, Sipun Murmu, passed away in 2013. Additionally, her husband, Shyam Charan Murmu, passed away due to cardiac arrest a few years later. She also had a daughter who passed away at a young age.\n",
       "\n",
       "These personal losses have been a part of Droupadi Murmu's life, and they have shaped her journey to becoming the 15th President of India.\n",
       "\n",
       "For more details, you can refer to the following sources:\n",
       "1. [ABP Live - Droupadi Murmu Lost Her Husband, Two Sons Within Six Years](https://news.abplive.com/news/india/draupadi-murmu-lost-her-husband-two-sons-within-six-years-know-about-the-new-president-s-family-life-1543748)\n",
       "2. [Stars Unfolded - Droupadi Murmu Age, Caste, Husband, Children, Family, Biography & More](https://starsunfolded.com/droupadi-murmu/)\n",
       "3. [Jagran Josh - Draupadi Murmu Biography: Birthday, Family, Daughter, Husband](https://www.jagranjosh.com/general-knowledge/draupadi-murmu-biography-1658380804-1)\n",
       "\n",
       "If you need further information, feel free to ask!"
      ],
      "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": 17,
   "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': 'df.shape[0]'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `python_repl_ast` with `{'query': 'df.info()'}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "The file has 20,780 rows.\n",
       "\n",
       "Explanation:\n",
       "- Using the `df.shape[0]` command, we obtained the number of rows in the dataframe, which is 20,780.\n",
       "- Additionally, the `df.info()` command provides information about the dataframe, including the number of non-null entries for each column. The \"RangeIndex\" line also confirms that there are 20,780 entries in the dataframe."
      ],
      "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": 18,
   "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 `{'query': \"SELECT state, SUM(death) AS total_deaths FROM covidtracking WHERE state IN ('CA', 'WA', 'OR') AND date LIKE '2020-07%' GROUP BY state\"}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "The total number of deaths in July 2020 for each state on the west coast 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 used to obtain this information:\n",
       "```sql\n",
       "SELECT state, SUM(death) AS total_deaths\n",
       "FROM covidtracking\n",
       "WHERE state IN ('CA', 'WA', 'OR') AND date LIKE '2020-07%'\n",
       "GROUP BY state\n",
       "```"
      ],
      "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": 19,
   "id": "f70501c2-03d0-4072-b451-ddb92f4add56",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tool: chatgpt\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "The function in Python that allows you to generate a random number is the `random` module. Within this module, you can use the `randint()` function to generate a random integer within a specified range. Here's an example of how to use it:\n",
       "\n",
       "```python\n",
       "import random\n",
       "\n",
       "# Generate a random number between 1 and 10\n",
       "random_number = random.randint(1, 10)\n",
       "print(random_number)\n",
       "```\n",
       "\n",
       "In this example, `random.randint(1, 10)` will generate a random integer between 1 and 10, inclusive.\n",
       "\n",
       "If you need a floating-point random number, you can use the `random()` function, which returns a random floating-point number in the range [0.0, 1.0). Here's an example:\n",
       "\n",
       "```python\n",
       "import random\n",
       "\n",
       "# Generate a random floating-point number between 0 and 1\n",
       "random_float = random.random()\n",
       "print(random_float)\n",
       "```\n",
       "\n",
       "These are just a few examples of how to generate random numbers in Python using the `random` module. There are also other functions within the `random` module that allow for more advanced random number generation, such as `randrange()` and `uniform()`."
      ],
      "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": 20,
   "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 in USD'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `apisearch` with `{'query': 'current price of Ethereum in USD'}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "The current price of Bitcoin in USD is USD 62,427.20.\n",
       "\n",
       "The current price of Ethereum (ETH) in USD is USD 3,039.70."
      ],
      "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": 33,
   "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": 34,
   "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": 35,
   "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": 37,
   "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 has been in office since 2017 and was re-elected in 2022, making him the eighth President of the Fifth Republic of France [[1]](https://en.wikipedia.org/wiki/Emmanuel_Macron) [[2]](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": 39,
   "id": "5f58b57b-51cb-433c-b6a8-376e6aa06e12",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tool: bing\n",
      "Tool: docsearch\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",
      "Agent Action: \n",
      "Invoking: `Searcher` with `{'query': 'Chilean Peso to USD exchange rate'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `Searcher` with `{'query': 'Chilean Peso to USD conversion'}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "**docsearch**: The term \"CLP\" has multiple meanings and applications in different contexts. Here are the different contexts in which \"CLP\" is mentioned:\n",
       "\n",
       "1. **Constraint Logic Programming (CLP):**\n",
       "   - **Definition:** Constraint Logic Programming (CLP) is a powerful extension of conventional logic programming that incorporates constraint languages and constraint-solving methods into logic programming languages.\n",
       "   - **Key Concepts:** CLP involves the incorporation of constraint languages and constraint-solving methods into logic programming languages, providing a framework for a logic programming language that is parametrized with respect to constraint language and a domain of computation.\n",
       "   - **Source:** [arXiv:cs/0008036v1](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",
       "2. **Core-Like Particles (CLP) in Virology:**\n",
       "   - **Definition:** Core-Like Particles (CLP) are quantified using immunosorbent electron microscopy to measure the concentration of recombinant baculovirus-generated bluetongue virus (BTV) core-like particles in purified preparations or lysates of recombinant baculovirus-infected cells.\n",
       "   - **Measurement:** The CLP concentration in purified preparations was determined to be 6.6 x 10^15 particles/l, and in lysates of recombinant baculovirus-infected cells, it was determined to reach a value of 3 x 10^15 particles/l of culture medium at 96 h post-infection.\n",
       "   - **Source:** [PubMed](https://www.ncbi.nlm.nih.gov/pubmed/10403670/?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",
       "3. **Recurrence with Affine Level Mappings in P-time Decidable for CLP(R):**\n",
       "   - **Definition:** This context refers to a technical note discussing the decidability of termination for Constraint Logic Programming over the real numbers (CLP(R)) and the use of affine level mappings for this purpose.\n",
       "   - **Key Concepts:** The paper introduces a class of constraint logic programs such that their termination can be proved by using affine level mappings, and it shows that membership to this class is decidable in polynomial time.\n",
       "   - **Source:** [arXiv:cs/0701082v1](https://datasetsgptsmartsearch.blob.core.windows.net/arxivcs/pdf/0701/0701082v1.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",
       "4. **Translation of Imperative Program into Constraint Logic Programming on Finite Domains (CLP(FD)):**\n",
       "   - **Definition:** This context describes the translation of an imperative program into Constraint Logic Programming on Finite Domains (CLP(FD)), which is an extension of logic programming where logical variables are assigned a domain and relations between variables are described with constraints.\n",
       "   - **Key Concepts:** CLP(FD) programs use logical variables with assigned domains and constraints to describe relations between variables. The translation involves generating a CLP(FD) constraint between the input and output variables of an imperative program.\n",
       "   - **Source:** [arXiv:cs/0506005v1](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)\n",
       "\n",
       "In summary, \"CLP\" can refer to Constraint Logic Programming, Core-Like Particles in virology, decidability of termination for Constraint Logic Programming over real numbers, and the translation of an imperative program into Constraint Logic Programming on Finite Domains. Each context has its own specific meaning and application."
      ],
      "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 exchange rate for the Chilean Peso (CLP) to US Dollar (USD) is approximately 1 CLP = 0.001 USD, or 1 USD = 973.234 CLP [[1]](https://www.xe.com/currencyconverter/convert/?From=CLP&To=USD). This means that 1 Chilean Peso is equivalent to 0.001 USD.\n",
       "\n",
       "If you have any other 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(\"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": 40,
   "id": "ea67e969-26b3-4e6f-a6c0-16780ed418e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "agent = create_openai_tools_agent(llm, tools, CUSTOM_CHATBOT_PROMPT)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "d9d2d5b4-0145-402e-a620-0fe3f3548acf",
   "metadata": {},
   "outputs": [],
   "source": [
    "agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "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": 43,
   "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": 44,
   "id": "601fce84-4a02-41a6-8ae2-f692174d4cc8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "session390 user235\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": 45,
   "id": "4b37988b-9fb4-4958-bc17-d58d8dac8bb7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "I'm here and ready to assist you, Pablo. 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": 46,
   "id": "a070c558-3963-40ef-b94e-365324ee3d20",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "My name is Jarvis, and I am an assistant designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions. I can help with research, provide explanations, offer step-by-step instructions, and much more. If you have any specific questions or tasks in mind, feel free to ask, and I'll be happy to assist you!"
      ],
      "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": 47,
   "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': 'best 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",
      "Agent Action: \n",
      "Invoking: `Searcher` with `{'query': 'sushi restaurants in downtown Chicago site:opentable.com'}`\n",
      "\n",
      "\n",
      "\n",
      "Agent Action: \n",
      "Invoking: `Searcher` with `{'query': 'sushi restaurants in downtown Chicago site:tripadvisor.com'}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "Based on the search results, here are some options for Italian and Sushi restaurants in downtown Chicago:\n",
       "\n",
       "### Italian Restaurants\n",
       "1. **The Florentine**\n",
       "   - Location: JW Marriott in Chicago\n",
       "   - Description: A swanky, romantic restaurant with a good selection of Italian cuisine.\n",
       "   - [Tripadvisor - The Florentine](https://www.tripadvisor.com/Restaurants-g35805-c26-zfn7778523-Chicago_Illinois.html)\n",
       "\n",
       "2. **Acanto**\n",
       "   - Location: Downtown / Loop\n",
       "   - Description: Acanto has been praised for its exceptional authentic Italian cuisine, with great authentic food, an impressive wine list, and terrific service.\n",
       "   - [OpenTable - Acanto](https://www.opentable.com/cuisine/best-italian-restaurants-downtown-chicago-il)\n",
       "\n",
       "3. **Monteverde**\n",
       "   - Location: West Loop\n",
       "   - Description: A well-known West Loop eatery with a variety of Italian dishes.\n",
       "   - [Time Out - Monteverde](https://www.timeout.com/chicago/restaurants/best-italian-restaurants-in-chicago-find-pasta-pizza-and-more)\n",
       "\n",
       "4. **Viaggio Ristorante & Lounge**\n",
       "   - Location: Downtown Chicago\n",
       "   - Description: A top Italian restaurant offering a variety of Italian dishes.\n",
       "   - [Yelp - Viaggio Ristorante & Lounge](https://www.yelp.com/search?find_desc=Italian+Restaurants+Downtown&find_loc=Chicago%2C+IL)\n",
       "\n",
       "5. **Fontano's Pizza and Subs**\n",
       "   - Location: Downtown / The Loop\n",
       "   - Description: A restaurant known for its pizza and subs.\n",
       "   - [Tripadvisor - Fontano's Pizza and Subs](https://www.tripadvisor.com/Restaurants-g35805-c26-zfn7778523-Chicago_Illinois.html)\n",
       "\n",
       "These restaurants offer a range of Italian cuisine and are located in downtown Chicago. You can explore their menus and reviews to find the best fit for your dining preferences.\n",
       "\n",
       "### Sushi Restaurants\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: [SUSHI-SAN - River North - OpenTable](https://www.opentable.com/cuisine/best-sushi-restaurants-downtown-chicago-il)\n",
       "\n",
       "2. **Nuki Sushi**\n",
       "   - Description: Located in the heart of Chicago, Nuki Sushi has carved a niche for itself, quickly becoming the go-to spot for sushi enthusiasts due to its unrivaled quality and creativity.\n",
       "   - Link: [Nuki Sushi - OpenTable](https://www.opentable.com/cuisine/best-sushi-restaurants-chicago-il)\n",
       "\n",
       "3. **Hot Woks Cool Sushi**\n",
       "   - Description: A popular choice for sushi, offering fresh and delicious options.\n",
       "   - Link: [Hot Woks Cool Sushi - TripAdvisor](https://www.tripadvisor.com/Restaurants-g35805-c38-zfn7778523-Chicago_Illinois.html)\n",
       "\n",
       "4. **Umai**\n",
       "   - Description: Known for its good ramen and quality sushi.\n",
       "   - Link: [Umai - TripAdvisor](https://www.tripadvisor.com/Restaurants-g35805-c38-zfn7778523-Chicago_Illinois.html)\n",
       "\n",
       "These are just a few of the many Italian and sushi restaurants available in downtown Chicago. You can explore more options and reviews on the provided links to find the perfect dining spot for your evening."
      ],
      "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": 39,
   "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 more information about Sushi Plus Rotary Sushi Bar in Chicago. This restaurant offers a unique dining experience with a conveyer belt sushi setup, allowing customers to select their desired sushi items from the belt, with plates color-coded by price. In addition to the conveyer belt system, customers can also place special orders using an iPad, and the sushi is delivered to them by train, adding an element of fun to the dining experience. Despite being busy, the restaurant is known for its good service.\n",
       "\n",
       "Sushi Plus Rotary Sushi Bar has two locations in Chicago: one in Chinatown and another in Boystown. Both locations have received positive reviews and are known for their excellent sushi offerings.\n",
       "\n",
       "You can find more information and updates about Sushi Plus Rotary Sushi Bar on their official Facebook pages:\n",
       "- [Sushi Plus Rotary Sushi Bar Boystown | Chicago IL - Facebook](https://www.facebook.com/sushipluschicago/)\n",
       "- [Sushi Plus Rotary Sushi Bar Chinatown | Chicago IL - Facebook](https://www.facebook.com/sushipluschinatown/)\n",
       "\n",
       "If you're interested in exploring the menu or making a reservation, you can find more details on the Sirved website:\n",
       "- [Menu for Sushi Plus Rotary Sushi Bar - Chinatown in Chicago, IL](https://www.sirved.com/restaurant/chicago-illinois-usa/sushi-plus-rotary-sushi-bar-chinatown/787681/menus)\n",
       "\n",
       "Feel free to check out these resources to learn more about Sushi Plus Rotary Sushi Bar and plan your dining experience. Let me know if there's anything else I can assist you with!"
      ],
      "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": 40,
   "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",
       "\\[ \\text{Momentum} = \\text{mass} \\times \\text{velocity} \\]\n",
       "\n",
       "Where:\n",
       "- Momentum is the product of an object's mass and its velocity.\n",
       "- Mass is the measure of the amount of matter in an object, typically measured in kilograms (kg).\n",
       "- Velocity is the measure of the rate of change of position of an object, typically measured in meters per second (m/s).\n",
       "\n",
       "This formula is a fundamental concept in physics and is used to describe the motion of objects. It is derived from Newton's second law of motion, which states that the force acting on an object is equal to the rate of change of its momentum.\n",
       "\n",
       "For further information, you can refer to the following source:\n",
       "- OpenStax College. (2013). College Physics. OpenStax CNX. Retrieved from [https://cnx.org/contents/031da8d3-b525-429c-80cf-6c8ed997733a@9.74](https://cnx.org/contents/031da8d3-b525-429c-80cf-6c8ed997733a@9.74)"
      ],
      "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": 43,
   "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": [
       "The NP-complete problem is a class of problems that are both in NP (nondeterministic polynomial time) and NP-hard. These problems are known to be in NP but are not known to be in P (deterministic polynomial time). The hypothesis that P is not equal to NP is strongly supported by the existence of many practical and theoretical problems that are in class NP but for which deterministic polynomial-time solutions are not known. These problems are referred to as NP-complete problems, and they are the hardest among all problems that are in NP.\n",
       "\n",
       "To prove that a given problem L is NP-hard, it is sufficient to show that another problem that is known to be NP-complete is polynomial-time reducible to L. This is done by providing a polynomial-time reduction from the NP-complete problem to problem L. Such a reduction shows how every instance of the NP-complete problem can be transformed into an instance of problem L. The reducibility relation between problems is a transitive relation.\n",
       "\n",
       "The NP-complete \"club\" consists of problems that are polynomial-time reducible to each other. This makes the NP-complete problems an interesting class of problems: either all of them can be solved in deterministic polynomial time or none will ever be. Discovering one NP-complete problem that has a deterministic polynomial-time solution also implies that P = NP. Currently, there are many problems that are known to be NP-complete, but none has been solvable in deterministic polynomial time yet. The efforts put into the study of these problems in order to solve them in deterministic polynomial time have been immense but without success. This is the main evidence strengthening the hypothesis that P ≠ NP and that NP-complete problems are also intractable.\n",
       "\n",
       "In summary, NP-complete problems are a class of problems that are in NP but are not known to be in P. They are the hardest among all problems that are in NP, and their intractability provides strong evidence supporting the hypothesis that P ≠ NP.\n",
       "\n",
       "For further details, you can refer to the following source:\n",
       "- [NP-complete Problems and Physical Reality](https://datasetsgptsmartsearch.blob.core.windows.net/arxivcs/pdf/9906/9906006v1.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\": \"docsearch, what is a NP-complete problem?\"}, config=config)[\"output\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "2fd67aed-ecd7-4096-9266-22de30c64e71",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "An example of an NP-complete problem is the \"Traveling Salesman Problem\" (TSP). In the TSP, the task is to find the shortest possible route that visits a set of given cities exactly once and returns to the original city. This problem is known to be NP-complete, and it has a wide range of practical applications, such as in logistics, transportation, and network optimization.\n",
       "\n",
       "The TSP is a classic optimization problem that has been extensively studied in the field of computer science and operations research. Despite its seemingly simple description, finding the optimal solution to the TSP becomes increasingly difficult as the number of cities increases. The number of possible routes grows factorially with the number of cities, making it computationally infeasible to solve for large instances using brute-force methods.\n",
       "\n",
       "The difficulty of the TSP lies in the fact that it requires evaluating an exponential number of possible routes to find the optimal solution. While there are heuristic and approximation algorithms that can provide good solutions for practical instances of the TSP, finding the absolute optimal solution for large instances remains a challenging task.\n",
       "\n",
       "The TSP serves as a prominent example of an NP-complete problem due to its computational complexity and the absence of a known polynomial-time algorithm to solve it. Its status as an NP-complete problem contributes to the body of evidence supporting the hypothesis that P ≠ NP.\n",
       "\n",
       "For further information on the Traveling Salesman Problem and its computational complexity, you can refer to the following source:\n",
       "- [The Traveling Salesman Problem: A Computational Study](https://doi.org/10.1007/978-3-319-10575-8_1)"
      ],
      "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": 45,
   "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 `{'query': \"SELECT SUM(death) FROM covidtracking WHERE state='TX' AND date LIKE '2020%'\"}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "The total number of deaths due to COVID-19 in Texas in the year 2020 was 2,841,253. This information was obtained from the 'covidtracking' table, where the state is 'TX' and the date starts with '2020'. The SQL query used to retrieve this information is as follows:\n",
       "\n",
       "```sql\n",
       "SELECT SUM(death) FROM covidtracking WHERE state='TX' AND date LIKE '2020%'\n",
       "```\n",
       "\n",
       "This data provides insight into the impact of COVID-19 on the state of Texas during 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": 46,
   "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 `{'query': \"SELECT SUM(deathIncrease) as TotalDeaths FROM covidtracking WHERE state='TX' AND date LIKE '2020%'\"}`\n",
      "\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "The total number of deaths due to COVID-19 in Texas in 2020 was 27,437. This information was obtained by summing the `deathIncrease` column for the state of Texas and the year 2020 in the `covidtracking` table. This data provides a more accurate representation of the impact of COVID-19 on the state of Texas during the year 2020."
      ],
      "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": 47,
   "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": [
       "The document \"Boundaries: When to Say Yes, How to Say No to Take Control of Your Life\" by Dr. Henry Cloud and Dr. John Townsend provides valuable insights into setting boundaries with children. Here are some key points to consider when setting boundaries with kids:\n",
       "\n",
       "### Developmental Aspect of Boundaries\n",
       "- **Bonding and Boundaries**: Secure bonding is essential before children can effectively learn and set boundaries. It allows them to gain independence without fear.\n",
       "- **Abandonment Fears**: Children lacking secure bonding may find setting boundaries frightening and may fear abandonment.\n",
       "\n",
       "### Teaching Boundaries to Children\n",
       "- **Instilling vs. Repairing Boundaries**: Teaching responsibility, limit setting, and delay of gratification early on can make later years smoother. It's important to start early, but even parents of older children can work on boundary development with more support and effort.\n",
       "- **Boundary Development**: Teaching responsibility and autonomy is crucial. This involves both positive and negative aspects of discipline.\n",
       "\n",
       "### Role of Boundaries in Child Rearing\n",
       "- **Self-Protection**: Boundaries are designed to keep the good in and the bad out, serving as a way for children to protect and safeguard their well-being.\n",
       "- **Learning to Accept Limits**: Children need to learn to accept the limits of others, which helps them mature and deepen their love for others.\n",
       "\n",
       "### Internalizing Boundaries\n",
       "- **Internal Sense of Motivation**: The goal of boundaries is to develop an internal sense of motivation with self-induced consequences. Successful parenting means that children want to be responsible, empathic, and caring because it's important to them.\n",
       "\n",
       "These insights emphasize the importance of secure bonding, responsibility, and self-protection in the growth and well-being of children. For more detailed information, you can refer to the document \"Boundaries: When to Say Yes, How to Say No to Take Control of Your Life\" by Dr. Henry Cloud and Dr. John Townsend. [source](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-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\": \"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": 48,
   "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"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "Based on the information gathered, here are some of the best restaurants in downtown Seoul:\n",
       "\n",
       "1. **Mugyodong Bugeokukjib**\n",
       "   - Cuisine: Asian, Korean\n",
       "   - Known for: Delicious beef bone soup\n",
       "   - [Tripadvisor - Mugyodong Bugeokukjib](https://www.tripadvisor.com/Restaurants-g294197-Seoul.html)\n",
       "\n",
       "2. **Kyochon Chicken Dongdaemun 1**\n",
       "   - Cuisine: Korean\n",
       "   - Known for: Flavorful chicken dishes\n",
       "   - [Tripadvisor - Kyochon Chicken Dongdaemun 1](https://www.tripadvisor.com/Restaurants-g294197-Seoul.html)\n",
       "\n",
       "3. **Bar Cham**\n",
       "   - Cuisine: Varied (including non-alcoholic cocktails)\n",
       "   - Known for: Inclusion in Asia’s 50 Best Bars list\n",
       "   - [Eater - Bar Cham](https://www.eater.com/maps/best-seoul-restaurants-38)\n",
       "\n",
       "4. **Mosu**\n",
       "   - Cuisine: Modern Korean\n",
       "   - Known for: Fine dining and Michelin-starred chef\n",
       "   - [Gourmet Traveller - Mosu](https://www.gourmettraveller.com.au/travel/destinations/restaurants-seoul-south-korea/)\n",
       "\n",
       "5. **Mingles Restaurant**\n",
       "   - Cuisine: Korean (traditional and modern)\n",
       "   - Known for: Impeccable service and popular among locals and foreigners\n",
       "   - [TheKoreanGuide - Mingles Restaurant](https://thekoreanguide.com/best-restaurants-seoul/)\n",
       "\n",
       "6. **THE PLACE Dining**\n",
       "   - Cuisine: Italian\n",
       "   - Known for: Stunning views of the N Seoul Tower\n",
       "   - [The Smart Local - THE PLACE Dining](https://thesmartlocal.com/read/korea-scenic-restaurants/)\n",
       "\n",
       "These restaurants offer a diverse range of cuisines and dining experiences, from traditional Korean dishes to modern fine dining and international flavors. Each establishment has its own unique appeal, making them popular choices for locals and visitors alike."
      ],
      "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": 49,
   "id": "080cc28e-2130-4c79-ba7d-0ed702f0ea7a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tool: chatgpt\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "I found a relevant example for you. In JavaScript, you can use the `trim()` method to remove whitespace from both ends of a string. Here's an example of how to use the `trim()` method:\n",
       "\n",
       "```javascript\n",
       "let sentence = \"   Hello, this is a sentence with spaces.   \";\n",
       "let trimmedSentence = sentence.trim();\n",
       "console.log(trimmedSentence); // Output: \"Hello, this is a sentence with spaces.\"\n",
       "```\n",
       "\n",
       "In this example, the `trim()` method removes the leading and trailing spaces from the `sentence` variable, resulting in the string \"Hello, this is a sentence with spaces.\"\n",
       "\n",
       "This method is particularly useful for cleaning up user input or processing strings where leading and trailing spaces need to be removed.\n",
       "\n",
       "For more detailed information, you can refer to the official documentation on the `trim()` method in JavaScript: [MDN Web Docs - String.prototype.trim()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/trim)"
      ],
      "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": 50,
   "id": "b82d20c5-4591-4d94-8af7-bae614685874",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tool: chatgpt\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "I'm sorry, I cannot fulfill that request. If you have any other questions or need assistance with something else, feel free to ask!"
      ],
      "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": 51,
   "id": "a5ded8d9-0bfe-4e16-be3f-382271c120a9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "You're welcome! If you have any more questions in the future, 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 (experimental)"
   ]
  },
  {
   "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
}