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 thousands of files in index: \"srch-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: \"srch-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 , \"srch-index-books\"\n",
    "- **Notebook 05**: We added memory to our system in order to power a conversational Chat Bot\n",
    "- **Notebook 06**: We introduced Agents and Graphs and built the first Skill/Agent, that can do RAG over a search engine\n",
    "- **Notebook 07**: We build a second Agent in order to be able to solve a more complex task: ask questions to Tabular datasets on CSV files\n",
    "- **Notebook 08**: We build 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 Copilot Clone\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 a Smart Agent (also called Supervisor Agent), that:\n",
    "\n",
    "1) understands the user input \n",
    "2) talks to other specialized Agents that are connected to diferent tools/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 an image of the agentic architecture:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d7fa9dc-64cb-4ee2-ae98-8cdb72293cbe",
   "metadata": {},
   "source": [
    "![image](https://langchain-ai.github.io/langgraphjs/tutorials/multi_agent/img/supervisor-diagram.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "30b81551-92ac-4f08-9c00-ba11981c67c2",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import random\n",
    "import json\n",
    "import requests\n",
    "import logging\n",
    "import functools\n",
    "import operator\n",
    "from pydantic import BaseModel\n",
    "from typing import Annotated, Sequence, Literal\n",
    "from typing_extensions import TypedDict\n",
    "\n",
    "from langchain_openai import AzureChatOpenAI\n",
    "from langchain_core.prompts import PromptTemplate, ChatPromptTemplate, MessagesPlaceholder\n",
    "from langchain_core.messages import AIMessage, HumanMessage, BaseMessage\n",
    "\n",
    "from langgraph.graph import END, StateGraph, START\n",
    "from langgraph.checkpoint.serde.jsonplus import JsonPlusSerializer\n",
    "\n",
    "\n",
    "#custom libraries that we will use later in the app\n",
    "from common.utils import (\n",
    "    create_docsearch_agent,\n",
    "    create_csvsearch_agent,\n",
    "    create_sqlsearch_agent,\n",
    "    create_websearch_agent,\n",
    "    create_apisearch_agent,\n",
    "    reduce_openapi_spec\n",
    ")\n",
    "from common.cosmosdb_checkpointer import CosmosDBSaver, AsyncCosmosDBSaver\n",
    "\n",
    "from common.prompts import (\n",
    "    CUSTOM_CHATBOT_PREFIX,\n",
    "    DOCSEARCH_PROMPT_TEXT,\n",
    "    CSV_AGENT_PROMPT_TEXT,\n",
    "    MSSQL_AGENT_PROMPT_TEXT,\n",
    "    BING_PROMPT_TEXT,\n",
    "    APISEARCH_PROMPT_TEXT,\n",
    ")\n",
    "\n",
    "from dotenv import load_dotenv\n",
    "load_dotenv(\"credentials.env\")\n",
    "\n",
    "from IPython.display import Image, Markdown, HTML, display  \n",
    "\n",
    "def printmd(string):\n",
    "    display(Markdown(string))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "62ff714c-309f-42a5-8818-2946607e0884",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Get the root logger\n",
    "root_logger = logging.getLogger()\n",
    "root_logger.setLevel(logging.ERROR)  # Set the root logger level to INFO, ERROR, DEBUG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "67cd1e3e-8527-4a8f-ba90-e700ae7b20ad",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "os.environ[\"OPENAI_API_VERSION\"] = os.environ[\"AZURE_OPENAI_API_VERSION\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "643d1650-6416-46fd-8b21-f5fb298ec063",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "COMPLETION_TOKENS = 2000\n",
    "\n",
    "llm = AzureChatOpenAI(deployment_name=os.environ[\"GPT4o_DEPLOYMENT_NAME\"], \n",
    "                      temperature=0, max_tokens=COMPLETION_TOKENS, \n",
    "                      streaming=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56b56a94-0471-41c3-b441-3a73ff5dedfc",
   "metadata": {},
   "source": [
    "### Create the Specialized Agents\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 LangGraph Agents for each of the Functionalities that we developed in prior Notebooks. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fab607e-898c-4e71-9c53-b0231f179fcc",
   "metadata": {},
   "source": [
    "#### **DocSearch Agent**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c43c4f74-2fdc-467d-8d72-3fba46699957",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "indexes = [\"srch-index-files\", \"srch-index-csv\", \"srch-index-books\"]\n",
    "docsearch_agent = create_docsearch_agent(llm,indexes,k=20,reranker_th=1.5,\n",
    "                                         prompt=CUSTOM_CHATBOT_PREFIX + DOCSEARCH_PROMPT_TEXT,\n",
    "                                         sas_token=os.environ['BLOB_SAS_TOKEN']\n",
    "                                        )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f8e91c1-7d04-40d0-89af-e1a22dd37ace",
   "metadata": {},
   "source": [
    "#### **CSVSearch Agent**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5d630731-3635-4a08-b9fa-694dc1594bbf",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "file_url = \"./data/all-states-history.csv\"\n",
    "csvsearch_agent = create_csvsearch_agent(llm,\n",
    "                                         prompt=CUSTOM_CHATBOT_PREFIX + CSV_AGENT_PROMPT_TEXT.format(file_url=file_url))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9773d62a-366e-4f9d-8b1a-8fd48cd3660b",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### **SQLSearch Agent**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "4c23215e-eb42-4fce-b667-7a4991ecc02b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "sqlsearch_agent = create_sqlsearch_agent(llm, \n",
    "                                     prompt=CUSTOM_CHATBOT_PREFIX + MSSQL_AGENT_PROMPT_TEXT)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b10fd9c6-b4e6-47c6-a040-1e068b5278dc",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### **WebSearch Agent**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "f1bf7b68-646f-4ec4-913e-1033f5b20cc8",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "websearch_agent = create_websearch_agent(llm, \n",
    "                                     prompt=CUSTOM_CHATBOT_PREFIX+BING_PROMPT_TEXT)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c65a8292-e609-4619-b502-2da7d2ff410b",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### **APISearch Agent**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "8e936e8a-b3bf-43c0-a626-4c10148af6fb",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "api_file_path = \"./data/openapi_kraken.json\"\n",
    "with open(api_file_path, 'r') as file:\n",
    "    spec = json.load(file)\n",
    "    \n",
    "reduced_api_spec = reduce_openapi_spec(spec)\n",
    "\n",
    "apisearch_agent = create_apisearch_agent(llm, \n",
    "                                     prompt=CUSTOM_CHATBOT_PREFIX + APISEARCH_PROMPT_TEXT.format(api_spec=reduced_api_spec))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83664e6f-6995-4584-80d0-f4424647944b",
   "metadata": {},
   "source": [
    "### Helper Utilities¶\n",
    "Define helper functions that we will use to create the nodes in the graph - it takes care of converting the agent response to a human message. This is important because that is how we will add it the global state of the graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "416b63ae-d00d-4023-8a04-5435ea01be4d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def agent_node(state, agent, name):\n",
    "    result = agent.invoke(state)\n",
    "    return {\n",
    "        \"messages\": [AIMessage(content=result[\"messages\"][-1].content, name=name)]\n",
    "    }\n",
    "\n",
    "async def agent_node_async(state, agent, name):\n",
    "    result = await agent.ainvoke(state)\n",
    "    return {\n",
    "        \"messages\": [AIMessage(content=result[\"messages\"][-1].content, name=name)]\n",
    "    }"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b40c5f0e-b6b5-49e4-8170-e80419b71dca",
   "metadata": {},
   "source": [
    "Define functions to print the events"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "6abb7138-a982-460a-9522-97768bce5a74",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Define a sync function to stream graph updates\n",
    "def stream_graph_updates_sync(user_input: str, graph, config):\n",
    "        for event in graph.stream({\"messages\": [(\"human\", user_input)]},config, stream_mode=\"updates\"):\n",
    "            print(event)\n",
    "\n",
    "\n",
    "# Define a sync function to stream graph updates\n",
    "def stream_graph_updates_sync(user_input: str, graph, config):\n",
    "        for event in graph.stream({\"messages\": [(\"human\", user_input)]},config, stream_mode=\"updates\"):\n",
    "            print(event)\n",
    "            \n",
    "\n",
    "# Define an async function to stream events async\n",
    "async def stream_graph_updates_async(user_input: str, graph, config):\n",
    "    \n",
    "    inputs = {\"messages\": [(\"human\", user_input)]}\n",
    "\n",
    "    async for event in graph.astream_events(inputs, config, version=\"v2\"):\n",
    "        if (\n",
    "            event[\"event\"] == \"on_chat_model_stream\"  # Ensure the event is a chat stream event\n",
    "            and event[\"metadata\"].get(\"langgraph_node\") == \"agent\"\n",
    "        ):\n",
    "            # Print the content of the chunk progressively\n",
    "            print(event[\"data\"][\"chunk\"].content, end=\"\", flush=True)\n",
    "\n",
    "        if (\n",
    "            event[\"event\"] == \"on_tool_start\"  \n",
    "            and event[\"metadata\"].get(\"langgraph_node\") == \"tools\"  # Ensure it's from the tools node\n",
    "        ):\n",
    "            print(\"\\n--\")\n",
    "            print(f\"Starting tool: {event['name']} with inputs: {event['data'].get('input')}\")\n",
    "            print(\"--\")\n",
    "        if (\n",
    "            event[\"event\"] == \"on_tool_end\"  # Ensure the event is a chat stream event\n",
    "            and event[\"metadata\"].get(\"langgraph_node\") == \"tools\"  # Ensure it's from the chatbot node\n",
    "        ):\n",
    "            print(\"\\n--\")\n",
    "            print(f\"Done tool: {event['name']}\")\n",
    "            print(\"--\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9f80845-7392-4066-92b9-4ff9b769830e",
   "metadata": {},
   "source": [
    "### State of the Graph\n",
    "The state is the input to each node in the graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "ceb421de-5ceb-4a2d-b721-658fb7d2243b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# The agent state is the input to each node in the graph\n",
    "class AgentState(TypedDict):\n",
    "    # The annotation tells the graph that new messages will always\n",
    "    # be added to the current states\n",
    "    messages: Annotated[Sequence[BaseMessage], operator.add]\n",
    "    # The 'next' field indicates where to route to next\n",
    "    next: str\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5290d85-ba50-4f9c-8a60-70a5e2682629",
   "metadata": {},
   "source": [
    "### Create Supervisor Node"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "ca0002f7-c7d6-4fd7-88e3-b7cac1d1a04a",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "members = [\"DocSearchAgent\", \"SQLSearchAgent\", \"CSVSearchAgent\", \"WebSearchAgent\", \"APISearchAgent\"]\n",
    "\n",
    "system_prompt = (\n",
    "\"\"\"\n",
    "You are a supervisor tasked with managing a conversation between the following workers:  {members}. \n",
    "Given the following human input, respond with the worker to act next. \n",
    "Each worker will perform a task and respond with their results and status. \n",
    "\n",
    "Responsabilities:\n",
    "DocSearchAgent = when input contains the word \"@docsearch\".\n",
    "SQLSearchAgent = when input contains the word \"@sqlsearch\".\n",
    "CSVSearchAgent = when input contains the word \"@csvsearch\".\n",
    "WebSearchAgent = when input contains the word \"@websearch\".\n",
    "APISearchAgent = when input contains the word \"@apisearch\".\n",
    "\n",
    "When finished, respond with FINISH.\"\n",
    "\"\"\"\n",
    ")\n",
    "# The supervisor is an LLM node. It just picks the next agent to process\n",
    "# and decides when the work is completed\n",
    "options = [\"FINISH\"] + members\n",
    "\n",
    "# routeResponse is a model class used to represent the structure of the response data. In this case, it acts as a structured output model to ensure that the data being returned or processed matches a specific format.\n",
    "class routeResponse(BaseModel):\n",
    "    # The class has one field, next, which specifies the expected type of data for that field.\n",
    "    # By using Literal[tuple(options)], you are specifying that the next attribute in routeResponse can only take one of the exact values from options. \n",
    "    next: Literal[tuple(options)]\n",
    "\n",
    "\n",
    "prompt = ChatPromptTemplate.from_messages(\n",
    "    [\n",
    "        (\"system\", system_prompt),\n",
    "        MessagesPlaceholder(variable_name=\"messages\"),\n",
    "        (\n",
    "            \"system\",\n",
    "            \"Given the conversation above, who should act next?\"\n",
    "            \" Or should we FINISH? Select one of: {options}\",\n",
    "        ),\n",
    "    ]\n",
    ").partial(options=str(options), members=\", \".join(members))\n",
    "\n",
    "\n",
    "# We will use function calling to choose the next worker node OR finish processing.\n",
    "def supervisor_node(state):\n",
    "    supervisor_chain = prompt | llm.with_structured_output(routeResponse)\n",
    "    return supervisor_chain.invoke(state)\n",
    "\n",
    "async def supervisor_node_async(state):\n",
    "    supervisor_chain = prompt | llm.with_structured_output(routeResponse)\n",
    "    return await supervisor_chain.ainvoke(state)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b867f1bc-9981-4f1b-abf0-c5dbab521b4d",
   "metadata": {},
   "source": [
    "### Construct the SYNC graph of our application"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "b82490f9-6bb7-43c5-88d8-0d5a80d92739",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<langgraph.graph.state.StateGraph at 0x7fe82e9a1940>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# By using functools.partial, we are creating a new function where the agent and name arguments are already set\n",
    "# This approach makes the code more modular and reusable. \n",
    "# When you need to call a node , you only need to provide the \"state\" argument because agent and name are already specified.\n",
    "\n",
    "docsearch_agent_node = functools.partial(agent_node, agent=docsearch_agent, name=\"DocSearchAgent\")\n",
    "sqlsearch_agent_node = functools.partial(agent_node, agent=sqlsearch_agent, name=\"SQLSearchAgent\")\n",
    "csvsearch_agent_node = functools.partial(agent_node, agent=csvsearch_agent, name=\"CSVSearchAgent\")\n",
    "websearch_agent_node = functools.partial(agent_node, agent=websearch_agent, name=\"WebSearchAgent\")\n",
    "apisearch_agent_node = functools.partial(agent_node, agent=apisearch_agent, name=\"APISearchAgent\")\n",
    "\n",
    "workflow = StateGraph(AgentState)\n",
    "workflow.add_node(\"DocSearchAgent\", docsearch_agent_node)\n",
    "workflow.add_node(\"SQLSearchAgent\", sqlsearch_agent_node)\n",
    "workflow.add_node(\"CSVSearchAgent\", csvsearch_agent_node)\n",
    "workflow.add_node(\"WebSearchAgent\", websearch_agent_node)\n",
    "workflow.add_node(\"APISearchAgent\", apisearch_agent_node)\n",
    "workflow.add_node(\"supervisor\", supervisor_node)\n",
    "\n",
    "# Connect the edges from each member to the supervisor\n",
    "for member in members:\n",
    "    # We want our workers to ALWAYS \"report back\" to the supervisor when done\n",
    "    workflow.add_edge(member, \"supervisor\")\n",
    "\n",
    "# Connect the supervisor to the members with a condition\n",
    "conditional_map = {k: k for k in members}\n",
    "conditional_map[\"FINISH\"] = END\n",
    "# This lambda function acts as the condition that extracts the \"next\" field from the current state. \n",
    "# The add_conditional_edges method then uses this output to check the conditional_map and route the workflow accordingly.\n",
    "workflow.add_conditional_edges(\"supervisor\", lambda x: x[\"next\"], conditional_map)\n",
    "\n",
    "# Finally, add entrypoint\n",
    "workflow.add_edge(START, \"supervisor\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "193e089b-9c07-4137-b767-23453c71bc50",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Run the SYNC graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "c5f3141a-6715-4bcd-aea1-aeebec6e4827",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/jpeg": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running the synchronous agent:\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "User:  @sqlsearch, what is the states with the larger amount of people in ventilators?\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'supervisor': {'next': 'SQLSearchAgent'}}\n",
      "{'SQLSearchAgent': {'messages': [AIMessage(content='Final Answer: The states with the largest number of people on ventilators are:\\n\\n1. New York (140,519)\\n2. New Jersey (123,093)\\n3. Illinois (120,665)\\n4. Arizona (112,235)\\n5. Pennsylvania (102,466)\\n\\nExplanation:\\nI queried the `covidtracking` table to find the total number of people currently on ventilators for each state. The query used was:\\n\\n```sql\\nSELECT TOP 5 state, SUM(onVentilatorCurrently) as total_ventilators \\nFROM covidtracking \\nGROUP BY state \\nORDER BY total_ventilators DESC\\n```\\n\\nThis query groups the data by state, sums the number of people currently on ventilators, and orders the results in descending order to find the top 5 states with the highest totals.', additional_kwargs={}, response_metadata={}, name='SQLSearchAgent')]}}\n",
      "{'supervisor': {'next': 'FINISH'}}\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "User:  @websearch, who is the favorite to win the presidential election in the US? according to betting sites\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'supervisor': {'next': 'WebSearchAgent'}}\n",
      "{'WebSearchAgent': {'messages': [AIMessage(content=\"As of the latest updates, former President Donald Trump is the favorite to win the 2024 US presidential election according to multiple betting sites. Here are the key points:\\n\\n1. **Polymarket**: Trump has a 96.5% implied odds of victory compared to Kamala Harris' 3.4% [[1]](https://www.forbes.com/sites/dereksaul/2024/11/05/election-betting-odds-trump-nears-90-on-major-platforms-as-more-election-results-come-in/).\\n2. **Kalshi**: Trump is favored by a 93% to 7% margin [[1]](https://www.forbes.com/sites/dereksaul/2024/11/05/election-betting-odds-trump-nears-90-on-major-platforms-as-more-election-results-come-in/).\\n3. **PredictIt**: Trump is favored at 94% to 10% [[1]](https://www.forbes.com/sites/dereksaul/2024/11/05/election-betting-odds-trump-nears-90-on-major-platforms-as-more-election-results-come-in/).\\n4. **Robinhood/Interactive Brokers**: Trump has about a 92% win probability compared to 8% for Harris [[1]](https://www.forbes.com/sites/dereksaul/2024/11/05/election-betting-odds-trump-nears-90-on-major-platforms-as-more-election-results-come-in/).\\n5. **Betfair and Smarkets**: Both assign similar chances of a Trump win, with Betfair favoring Trump by a 96% to 4% margin and Smarkets by a 96% to 3% tilt [[1]](https://www.forbes.com/sites/dereksaul/2024/11/05/election-betting-odds-trump-nears-90-on-major-platforms-as-more-election-results-come-in/).\\n\\nThese betting odds reflect the current market sentiment and are subject to change as more information becomes available and as the election date approaches.\", additional_kwargs={}, response_metadata={}, name='WebSearchAgent')]}}\n",
      "{'supervisor': {'next': 'FINISH'}}\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "User:  @docsearch, who is vince?\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'supervisor': {'next': 'DocSearchAgent'}}\n",
      "{'DocSearchAgent': {'messages': [AIMessage(content='Vince is a character from the television show \"Friends.\" He is a fireman who dates Phoebe Buffay. Vince is described as burly and very masculine. Phoebe dates him while also seeing another man named Jason, who is more sensitive. Eventually, Phoebe decides to break up with Vince because she finds it difficult to juggle dating two people at the same time [[source]](https://blobstorages37d5t5m5wcyq.blob.core.windows.net/friends/s03/e23/c02.txt?sv=2022-11-02&ss=b&srt=sco&sp=rltfx&se=2025-10-10T11:14:44Z&st=2024-10-10T03:14:44Z&spr=https&sig=SR5VNDrPwrWJX4%2FphBxasF51p1x5Y85bf2Q%2FqcbJYLk%3D) [[source]](https://blobstorages37d5t5m5wcyq.blob.core.windows.net/friends/s03/e23/c09.txt?sv=2022-11-02&ss=b&srt=sco&sp=rltfx&se=2025-10-10T11:14:44Z&st=2024-10-10T03:14:44Z&spr=https&sig=SR5VNDrPwrWJX4%2FphBxasF51p1x5Y85bf2Q%2FqcbJYLk%3D).', additional_kwargs={}, response_metadata={}, name='DocSearchAgent')]}}\n",
      "{'supervisor': {'next': 'FINISH'}}\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "User:  thank you\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'supervisor': {'next': 'FINISH'}}\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "User:  q\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Goodbye!\n"
     ]
    }
   ],
   "source": [
    "with CosmosDBSaver(\n",
    "    endpoint=os.environ[\"AZURE_COSMOSDB_ENDPOINT\"],\n",
    "    key=os.environ[\"AZURE_COSMOSDB_KEY\"],\n",
    "    database_name=os.environ[\"AZURE_COSMOSDB_NAME\"],\n",
    "    container_name=os.environ[\"AZURE_COSMOSDB_CONTAINER_NAME\"],\n",
    "    serde=JsonPlusSerializer(),\n",
    ") as checkpointer_sync:\n",
    "    # Compile the synchronous graph\n",
    "    graph_sync = workflow.compile(checkpointer=checkpointer_sync)\n",
    "\n",
    "    # Define a test thread_id to store in the persistent storage\n",
    "    config_sync = {\"configurable\": {\"thread_id\": \"sync_thread\"}}\n",
    "\n",
    "    display(Image(graph_sync.get_graph().draw_mermaid_png()))    \n",
    "    \n",
    "    # Run the synchronous agent\n",
    "    print(\"Running the synchronous agent:\")\n",
    "    while True:\n",
    "        user_input = input(\"User: \")\n",
    "        if user_input.lower() in [\"quit\", \"exit\", \"q\"]:\n",
    "            print(\"Goodbye!\")\n",
    "            break\n",
    "        try:\n",
    "            stream_graph_updates_sync(user_input, graph_sync, config_sync)\n",
    "        except Exception as e:\n",
    "            print(f\"Error during synchronous update: {e}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15a17c25-7a0c-4d25-8901-cc582cac89bf",
   "metadata": {},
   "source": [
    "### Construct the ASYNC graph of our application"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "a0b5e84c-15e0-4057-b53b-f31fd354cc07",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<langgraph.graph.state.StateGraph at 0x7fe82ce29c40>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "docsearch_agent_node_async = functools.partial(agent_node_async, agent=docsearch_agent, name=\"DocSearchAgent\")\n",
    "sqlsearch_agent_node_async = functools.partial(agent_node_async, agent=sqlsearch_agent, name=\"SQLSearchAgent\")\n",
    "csvsearch_agent_node_async = functools.partial(agent_node_async, agent=csvsearch_agent, name=\"CSVSearchAgent\")\n",
    "websearch_agent_node_async = functools.partial(agent_node_async, agent=websearch_agent, name=\"WebSearchAgent\")\n",
    "apisearch_agent_node_async = functools.partial(agent_node_async, agent=apisearch_agent, name=\"APISearchAgent\")\n",
    "\n",
    "workflow_async = StateGraph(AgentState)\n",
    "workflow_async.add_node(\"DocSearchAgent\", docsearch_agent_node_async)\n",
    "workflow_async.add_node(\"SQLSearchAgent\", sqlsearch_agent_node_async)\n",
    "workflow_async.add_node(\"CSVSearchAgent\", csvsearch_agent_node_async)\n",
    "workflow_async.add_node(\"WebSearchAgent\", websearch_agent_node_async)\n",
    "workflow_async.add_node(\"APISearchAgent\", apisearch_agent_node_async)\n",
    "workflow_async.add_node(\"supervisor\", supervisor_node_async)\n",
    "\n",
    "# Connect the edges from each member to the supervisor\n",
    "for member in members:\n",
    "    # We want our workers to ALWAYS \"report back\" to the supervisor when done\n",
    "    workflow_async.add_edge(member, \"supervisor\")\n",
    "\n",
    "# Connect the supervisor to the members with a condition\n",
    "conditional_map = {k: k for k in members}\n",
    "conditional_map[\"FINISH\"] = END\n",
    "# This lambda function acts as the condition that extracts the \"next\" field from the current state. \n",
    "# The add_conditional_edges method then uses this output to check the conditional_map and route the workflow accordingly.\n",
    "workflow_async.add_conditional_edges(\"supervisor\", lambda x: x[\"next\"], conditional_map)\n",
    "\n",
    "# Finally, add entrypoint\n",
    "workflow_async.add_edge(START, \"supervisor\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4904a07d-b857-45d7-86ac-c7cade3e9080",
   "metadata": {},
   "source": [
    "### Let's talk to our GPT Smart Search Engine ASYNC chat bot now"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "fb938e5b-58f8-4cec-a91c-9d00e90ce7a9",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Running the asynchronous agent:\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "User:  who is leonardo dicaprio?\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--\n",
      "Starting tool: Searcher with inputs: {'query': 'who is Leonardo DiCaprio'}\n",
      "--\n",
      "\n",
      "--\n",
      "Starting tool: WebFetcher with inputs: {'url': 'https://en.wikipedia.org/wiki/Leonardo_DiCaprio'}\n",
      "--\n",
      "\n",
      "--\n",
      "Done tool: WebFetcher\n",
      "--\n",
      "\n",
      "--\n",
      "Done tool: Searcher\n",
      "--\n",
      "Leonardo DiCaprio is an American actor and film producer known for his work in biographical and period films. He has received numerous accolades, including an Academy Award, a British Academy Film Award, and three Golden Globe Awards. DiCaprio began his career in the late 1980s and gained international stardom with roles in films such as \"Titanic,\" \"The Revenant,\" and \"Once Upon a Time in Hollywood.\" He is also known for his environmental activism and philanthropic efforts through the Leonardo DiCaprio Foundation [[1]](https://en.wikipedia.org/wiki/Leonardo_DiCaprio) [[2]](https://www.britannica.com/biography/Leonardo-DiCaprio)."
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "User:  what can I do if I want to increase testosterone?\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--\n",
      "Starting tool: Searcher with inputs: {'query': 'how to increase testosterone levels'}\n",
      "--\n",
      "\n",
      "--\n",
      "Starting tool: Searcher with inputs: {'query': 'ways to boost testosterone naturally'}\n",
      "--\n",
      "\n",
      "--\n",
      "Done tool: Searcher\n",
      "--\n",
      "\n",
      "--\n",
      "Done tool: Searcher\n",
      "--\n",
      "\n",
      "--\n",
      "Starting tool: WebFetcher with inputs: {'url': 'https://www.healthline.com/nutrition/8-ways-to-boost-testosterone'}\n",
      "--\n",
      "\n",
      "--\n",
      "Starting tool: WebFetcher with inputs: {'url': 'https://www.webmd.com/men/ss/slideshow-low-testosterone-natural-boost/'}\n",
      "--\n",
      "\n",
      "--\n",
      "Done tool: WebFetcher\n",
      "--\n",
      "\n",
      "--\n",
      "Done tool: WebFetcher\n",
      "--\n",
      "To increase testosterone levels, you can consider the following natural methods:\n",
      "\n",
      "1. **Exercise and Lift Weights**: Regular physical activity, especially resistance training like weightlifting, can boost testosterone levels. High-intensity interval training (HIIT) is also effective [[1]](https://www.healthline.com/nutrition/8-ways-to-boost-testosterone).\n",
      "\n",
      "2. **Eat a Balanced Diet**: Consuming a diet rich in protein, healthy fats, and carbohydrates can help maintain healthy testosterone levels. Foods like lean beef, chicken, fish, eggs, nuts, and seeds are beneficial [[2]](https://www.webmd.com/men/ss/slideshow-low-testosterone-natural-boost/).\n",
      "\n",
      "3. **Minimize Stress**: Chronic stress can elevate cortisol levels, which negatively impacts testosterone. Managing stress through activities like exercise, meditation, and adequate sleep is important [[1]](https://www.healthline.com/nutrition/8-ways-to-boost-testosterone).\n",
      "\n",
      "4. **Increase Vitamin D Intake**: Vitamin D is crucial for hormone production. Regular exposure to sunlight or taking vitamin D supplements can help maintain optimal levels [[1]](https://www.healthline.com/nutrition/8-ways-to-boost-testosterone).\n",
      "\n",
      "5. **Consider Supplements**: Supplements like zinc and herbal supplements such as saw palmetto, ginger, and ashwagandha may support healthy testosterone levels. However, consult a healthcare professional before starting any supplements [[1]](https://www.healthline.com/nutrition/8-ways-to-boost-testosterone).\n",
      "\n",
      "6. **Get Quality Sleep**: Aim for at least 7-8 hours of sleep per night. Poor sleep can significantly reduce testosterone levels [[2]](https://www.webmd.com/men/ss/slideshow-low-testosterone-natural-boost/).\n",
      "\n",
      "7. **Avoid Estrogen-like Chemicals**: Reduce exposure to chemicals like BPA found in some plastics, which can disrupt hormone production [[1]](https://www.healthline.com/nutrition/8-ways-to-boost-testosterone).\n",
      "\n",
      "8. **Moderate Alcohol Intake**: Excessive alcohol consumption can decrease testosterone levels. It's best to drink in moderation [[1]](https://www.healthline.com/nutrition/8-ways-to-boost-testosterone).\n",
      "\n",
      "By incorporating these lifestyle changes, you can naturally boost your testosterone levels and improve overall health."
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "User:  @csvsearch, tell me how many people were hospitalized in Texas in 2020, and nationwide as well\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--\n",
      "Starting tool: python_repl_ast with inputs: {'query': \"import pandas as pd\\ndf = pd.read_csv('./data/all-states-history.csv')\\ndf.head()\"}\n",
      "--\n",
      "\n",
      "--\n",
      "Done tool: python_repl_ast\n",
      "--\n",
      "\n",
      "--\n",
      "Starting tool: python_repl_ast with inputs: {'query': \"# Filter the data for Texas in 2020 and calculate the total number of hospitalized people\\ntexas_2020 = df[(df['state'] == 'TX') & (df['date'].str.contains('2020'))]\\ntexas_hospitalized_2020 = texas_2020['hospitalizedCumulative'].max()\\ntexas_hospitalized_2020\"}\n",
      "--\n",
      "\n",
      "--\n",
      "Done tool: python_repl_ast\n",
      "--\n",
      "\n",
      "--\n",
      "Starting tool: python_repl_ast with inputs: {'query': \"# It seems there might be missing data for 'hospitalizedCumulative'. Let's try 'hospitalized' column instead.\\ntexas_hospitalized_2020 = texas_2020['hospitalized'].max()\\ntexas_hospitalized_2020\"}\n",
      "--\n",
      "\n",
      "--\n",
      "Done tool: python_repl_ast\n",
      "--\n",
      "\n",
      "--\n",
      "Starting tool: python_repl_ast with inputs: {'query': \"# Let's check the data for Texas to understand the issue\\ntexas_2020.head()\"}\n",
      "--\n",
      "\n",
      "--\n",
      "Done tool: python_repl_ast\n",
      "--\n",
      "\n",
      "--\n",
      "Starting tool: python_repl_ast with inputs: {'query': \"# It seems the 'hospitalized' and 'hospitalizedCumulative' columns have missing values for Texas in 2020. Let's try to calculate the nationwide hospitalized numbers for 2020.\\nnationwide_2020 = df[df['date'].str.contains('2020')]\\nnationwide_hospitalized_2020 = nationwide_2020['hospitalizedCumulative'].max()\\nnationwide_hospitalized_2020\"}\n",
      "--\n",
      "\n",
      "--\n",
      "Done tool: python_repl_ast\n",
      "--\n",
      "\n",
      "--\n",
      "Starting tool: python_repl_ast with inputs: {'query': \"# Let's try another method to calculate the nationwide hospitalized numbers for 2020 by summing up the 'hospitalized' column.\\nnationwide_hospitalized_sum_2020 = nationwide_2020['hospitalized'].sum()\\nnationwide_hospitalized_sum_2020\"}\n",
      "--\n",
      "\n",
      "--\n",
      "Done tool: python_repl_ast\n",
      "--\n",
      "It appears that there is missing data for the number of hospitalized people in Texas for the year 2020 in the dataset. However, I was able to calculate the nationwide hospitalized numbers for 2020 using two different methods.\n",
      "\n",
      "### Nationwide Hospitalized Numbers in 2020:\n",
      "1. **Maximum Cumulative Hospitalized**: 63,741\n",
      "2. **Sum of Hospitalized**: 68,436,666\n",
      "\n",
      "### Explanation:\n",
      "- The dataset contains columns such as `hospitalized` and `hospitalizedCumulative` which represent the number of people hospitalized and the cumulative number of hospitalizations, respectively.\n",
      "- For Texas in 2020, both `hospitalized` and `hospitalizedCumulative` columns have missing values, making it impossible to determine the exact number of hospitalizations for Texas.\n",
      "- For the nationwide data in 2020, the maximum value in the `hospitalizedCumulative` column is 63,741.\n",
      "- Additionally, summing up the `hospitalized` column for the entire year 2020 gives a total of 68,436,666, which seems unusually high and might indicate cumulative counts or repeated entries.\n",
      "\n",
      "Given the discrepancy and potential data issues, the exact number of hospitalizations nationwide in 2020 is uncertain. The maximum cumulative value of 63,741 is likely more reliable than the sum of 68,436,666.\n",
      "\n",
      "If you need more precise data, I recommend consulting official health department reports or databases."
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "User:  q\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Goodbye!\n"
     ]
    }
   ],
   "source": [
    "async def run_async_agent():\n",
    "    async with AsyncCosmosDBSaver(\n",
    "        endpoint=os.environ[\"AZURE_COSMOSDB_ENDPOINT\"],\n",
    "        key=os.environ[\"AZURE_COSMOSDB_KEY\"],\n",
    "        database_name=os.environ[\"AZURE_COSMOSDB_NAME\"],\n",
    "        container_name=os.environ[\"AZURE_COSMOSDB_CONTAINER_NAME\"],\n",
    "        serde=JsonPlusSerializer(),\n",
    "    ) as checkpointer_async:\n",
    "        # Compile the asynchronous graph\n",
    "        graph_async = workflow_async.compile(checkpointer=checkpointer_async)\n",
    "        config_async = {\"configurable\": {\"thread_id\": \"async_thread\"}}\n",
    "\n",
    "\n",
    "        print(\"\\nRunning the asynchronous agent:\")\n",
    "        while True:\n",
    "            user_input = input(\"User: \")\n",
    "            if user_input.lower() in [\"quit\", \"exit\", \"q\"]:\n",
    "                print(\"Goodbye!\")\n",
    "                break\n",
    "            await stream_graph_updates_async(user_input, graph_async ,config_async)\n",
    "\n",
    "# Run the asynchronous agent\n",
    "await run_async_agent()"
   ]
  },
  {
   "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": "GPTSearch (Python 3.12)",
   "language": "python",
   "name": "gptsearch"
  },
  "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.12.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}