ReAct_Agents.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "61b4ec3e-307a-4efa-8c83-e984f0960735",
   "metadata": {},
   "source": [
    "# Wolfram Alpha ReAct Agent\n",
    "\n",
    "This notebook demonstrates how to create a custom `ReActAgent` using `Llama Index` that interacts with Wolfram Alpha. \n",
    "\n",
    "The agent is designed to handle various tasks, such as retrieving facts, solving equations, integrating expressions, solving word problems, etc.\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "  <h4>Applications</h4>\n",
    "  <p>This agent is meant as a proof-of-concept rather than a useful tool on its own. For instancem this type of method could be integrated into AI Tutor for student-use to ensure factually correct responses.</p>\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5139e53b-f160-4857-9010-56c187125e09",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import requests\n",
    "import urllib.parse\n",
    "import xml.etree.ElementTree as ET\n",
    "from IPython.display import Markdown, display\n",
    "from llama_index.core.agent import ReActAgent\n",
    "from llama_index.core.tools import FunctionTool\n",
    "from llama_index.llms.openai import OpenAI\n",
    "from llama_index.core.llms import ChatMessage\n",
    "\n",
    "def load_text_file(file_path):\n",
    "    with open(file_path, 'r') as file:\n",
    "        return file.read()\n",
    "\n",
    "def printmd(string):\n",
    "    display(Markdown(string))\n",
    "\n",
    "# Load API credentials\n",
    "wolfram_api_key = load_text_file(file_path='wolfram_alpha_api_key.txt').strip(\"\\n\")\n",
    "openai_api_key = load_text_file(file_path='key.txt').strip(\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1919e7e8-1bce-4d76-8d23-91537747265f",
   "metadata": {},
   "source": [
    "### Define Wolfram Alpha Query Functions\n",
    "\n",
    "> For now, we will just use the `get_info` tool, but we will implement the plotting at a later date."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a31e0335-c948-4f88-bc14-36e39af3b7a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ExtendedWolframAlphaAPIWrapper:\n",
    "    \"\"\"\n",
    "    An extended API wrapper for Wolfram Alpha that provides methods to fetch \n",
    "    both plot images and plaintext information for a given query.\n",
    "\n",
    "    Attributes:\n",
    "        appid (str): The application ID for Wolfram Alpha API access.\n",
    "        qp (dict): The base query parameters used for each API request.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, appid: str):\n",
    "        \"\"\"\n",
    "        Initializes the API wrapper with the provided application ID \n",
    "        and sets default query parameters.\n",
    "        \"\"\"\n",
    "        self.appid = appid\n",
    "        self.qp = {\n",
    "            'units': 'metric',             # Use metric units for results.\n",
    "            'format': 'plaintext,image',    # Request both plaintext and image formats by default.\n",
    "            'primary': True,                # Ensure primary information is included.\n",
    "            'appid': self.appid,            # App ID required for API authentication.\n",
    "        }\n",
    "\n",
    "    def run_plots(self, query: str) -> str:\n",
    "        \"\"\"\n",
    "        Submits a query to Wolfram Alpha and retrieves URLs of plot images \n",
    "        related to the query. If no plot is found, returns a message indicating so.\n",
    "\n",
    "        Parameters:\n",
    "            query (str): The user query string to search for plot-related information.\n",
    "\n",
    "        Returns:\n",
    "            str: URLs of plot images if found, or an error message if not.\n",
    "        \"\"\"\n",
    "        self.qp['format'] = 'image'      # Request image format specifically for plots.\n",
    "        self.qp['podstate'] = None       # Clear specific pod state for generalized plot queries.\n",
    "        self.qp['input'] = query         # Set the query input.\n",
    "\n",
    "        # Construct API URI with encoded query parameters.\n",
    "        uri = 'http://api.wolframalpha.com/v2/query?' + urllib.parse.urlencode(self.qp)\n",
    "        response = requests.get(uri)\n",
    "\n",
    "        # Return error message if the API request fails.\n",
    "        if response.status_code != 200:\n",
    "            return \"Error: \" + response.reason\n",
    "\n",
    "        # Parse XML response to extract image URLs from 'Plot' pods.\n",
    "        doc = ET.fromstring(response.text)\n",
    "        plot_urls = []\n",
    "        for pod in doc.findall('.//pod'):\n",
    "            if pod.get('id') == 'Plot':\n",
    "                for subpod in pod.findall('.//subpod'):\n",
    "                    plot_urls.append(subpod.find('img').get('src'))\n",
    "\n",
    "        # Return list of plot URLs or a message if no plots are found.\n",
    "        if not plot_urls:\n",
    "            return \"No plot found.\"\n",
    "\n",
    "        # Format the plot URLs for readability.\n",
    "        plot_list = '\\n'.join([f\"{i+1}. {url}\" for i, url in enumerate(plot_urls)])\n",
    "        return f\"Answer: {plot_list}\"\n",
    "\n",
    "    def get_info(self, query: str) -> str:\n",
    "        \"\"\"\n",
    "        Submits a query to Wolfram Alpha and retrieves plaintext information \n",
    "        relevant to the query, formatted for readability.\n",
    "\n",
    "        Parameters:\n",
    "            query (str): The user query string to search for informational content.\n",
    "\n",
    "        Returns:\n",
    "            str: Structured plaintext information relevant to the query, or an error message.\n",
    "        \"\"\"\n",
    "        self.qp['format'] = 'plaintext'  # Request plaintext format for detailed info.\n",
    "        self.qp['input'] = query         # Set the query input.\n",
    "        self.qp['output'] = 'json'       # Set output to JSON for easy parsing.\n",
    "\n",
    "        # Construct API URI with encoded query parameters.\n",
    "        uri = 'http://api.wolframalpha.com/v2/query?' + urllib.parse.urlencode(self.qp)\n",
    "        response = requests.get(uri)\n",
    "\n",
    "        # Return error message if the API request fails.\n",
    "        if response.status_code != 200:\n",
    "            return \"Error: \" + response.reason\n",
    "\n",
    "        # Check if query was successful\n",
    "        response = response.json()\n",
    "        if not response['queryresult']['success']:\n",
    "            return ('Try another query using as few words as possible to communicate the general concept. '\n",
    "                    'If you are still unsuccessful, try using separate, single word queries.')\n",
    "            \n",
    "        # Parse JSON response and structure the extracted information.\n",
    "        info = '### Wolfram Information\\n'\n",
    "        for pod in response['queryresult']['pods']:\n",
    "            pod_info = \"\"\n",
    "            for subpod in pod['subpods']:\n",
    "                content = subpod['plaintext']\n",
    "                title = subpod['title']\n",
    "                if content == '':\n",
    "                    continue\n",
    "                if title != '':\n",
    "                    pod_info += f\"\\t{title}:\"\n",
    "                pod_info += f\"\\t{content}\\n\"\n",
    "            if pod_info != \"\":\n",
    "                pod_info = f\"\\n{pod['title']}:\\n\" + pod_info\n",
    "                info += pod_info\n",
    "\n",
    "        return info"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "187322de-b879-4c17-b72a-bb09ae86848a",
   "metadata": {},
   "source": [
    "#### Run some tests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7038677c-0c05-44ed-90ec-59da12a8d48e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "### Wolfram Information\n",
      "\n",
      "Input:\n",
      "\ty = 12 x^2 - 3 x\n",
      "\n",
      "Geometric figure:\n",
      "\tparabola\n",
      "\n",
      "Alternate forms:\n",
      "\ty = 3 x (4 x - 1)\n",
      "\t-12 x^2 + 3 x + y = 0\n",
      "\n",
      "Roots:\n",
      "\tx = 0\n",
      "\tx = 1/4\n",
      "\n",
      "Properties as a real function:\n",
      "\tDomain:\tR (all real numbers)\n",
      "\tRange:\t{y element R : y>=-3/16}\n",
      "\n",
      "Partial derivatives:\n",
      "\td/dx(12 x^2 - 3 x) = 24 x - 3\n",
      "\td/dy(12 x^2 - 3 x) = 0\n",
      "\n",
      "Implicit derivatives:\n",
      "\t(dx(y))/(dy) = 1/(3 (-1 + 8 x))\n",
      "\t(dy(x))/(dx) = -3 + 24 x\n",
      "\n",
      "Global minimum:\n",
      "\tmin{12 x^2 - 3 x} = -3/16 at x = 1/8\n",
      "\n"
     ]
    }
   ],
   "source": [
    "response = ExtendedWolframAlphaAPIWrapper(wolfram_api_key).get_info(\"y = 12x**2 - 3x\")\n",
    "print(response)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "780d6c7c-d74d-440c-8404-d7df2d66dafc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "### Wolfram Information\n",
      "\n",
      "Input interpretation:\n",
      "\tmosquito | lifespan\n",
      "\n",
      "Result:\n",
      "\t(9 to 62) days\n",
      "\n",
      "Unit conversions:\n",
      "\t≈ 8 days 20 hours to 62 days\n",
      "\t≈ (730000 to 5.4×10^6) seconds\n",
      "\t≈ (12000 to 91000) minutes\n",
      "\t≈ (200 to 1500) hours\n",
      "\t≈ (1.2 to 9) weeks\n",
      "\n",
      "Scientific name:\n",
      "\tCulicidae\n",
      "\n",
      "Human comparisons:\n",
      "\tcorresponding human value | 73 years\n",
      "fraction of human value | (3.2×10^-4 to 0.0024)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "response = ExtendedWolframAlphaAPIWrapper(wolfram_api_key).get_info(\"lifespan of a mosquito\")\n",
    "print(response)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0e690369-4f05-47ae-90b0-ea1713316806",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "### Wolfram Information\n",
      "\n",
      "Input information:\n",
      "\tgravitational potential energy | \n",
      "mass | 5 kg (kilograms)\n",
      "height | 10 meters\n",
      "gravitational acceleration | 1 g (standard acceleration due to gravity on the surface of the earth)\n",
      "\n",
      "Result:\n",
      "\tgravitational potential energy | 490.3 J (joules)\n",
      "= 0.1362 W h (watt hours)\n",
      "= 3.06×10^12 GeV (gigaelectronvolts)\n",
      "\n",
      "Equation:\n",
      "\tU = m g h | \n",
      "U | gravitational potential energy\n",
      "m | mass\n",
      "h | height\n",
      "g | gravitational acceleration\n",
      "(energy of an object due to gravity near the surface of a gravitating body)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "response = ExtendedWolframAlphaAPIWrapper(wolfram_api_key).get_info(\"gravitational potential energy, 5 kg, 10 meters\")\n",
    "print(response)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9794cec3-0087-421f-b5da-d98152af450d",
   "metadata": {},
   "source": [
    "### Build the Tool for the ReAct Agent\n",
    "\n",
    "We'll use `FunctionTool` to wrap each function and include a detailed description on how to best use the tool."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "2158cd0e-ba77-4888-ae26-8a37e15bb4ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_wolfram_tools(wolfram_api_key):\n",
    "    wolfram_tool = FunctionTool.from_defaults(\n",
    "            fn=ExtendedWolframAlphaAPIWrapper(wolfram_api_key).get_info,\n",
    "            name='wolfram_tool',\n",
    "            description='''A factual information retrieval tool powered by Wolfram Alpha.\n",
    "This tool is designed to provide precise answers for scientific, mathematical, \n",
    "and general knowledge queries. It can be used to retrieve definitions, calculations, and explanations for concepts. \n",
    "The query forwarded to this tool should use as few words as possible to communicate and use unambiguous whole words.\n",
    "Just describe what you're interested in; you don't need to explicitly ask a question. \n",
    "\n",
    "Examples:\n",
    "\n",
    "- \"30% of 8 miles\"\n",
    "- \"1/4 * (4 - 1/2)\"\n",
    "- \"credit card balance $9000, apr 12%, $300/month\"\n",
    "- \"If Jane has 23 cats and I have 2 cats, and then Jane gives me 5 cats, how many more cats does Jane have than I?\"\n",
    "- \"solve x^2 + 4x + 6 = 0\"\n",
    "- \"factor 2x^5 - 19x^4 + 58x^3 - 67x^2 + 56x - 48\"\n",
    "- \"x+y=10, x-y=4\"\n",
    "- \"y = 12x^2 - 3x\"\n",
    "- \"simplify cos(arcsin(x)/2)\"\n",
    "- \"partial fractions (x^2-4)/(x^4-x)\"\n",
    "- \"(x^2-1)/(x^2+1)\"\n",
    "- \"y'' + y = 0\"\n",
    "- \"y'' + y = 0, y(0)=2, y'(0)=1\"\n",
    "- \"differential equations sin 2x\"\n",
    "- \"integrate x^2 sin^3 x dx\"\n",
    "- \"integrate sin x dx from x=0 to pi\"\n",
    "- \"d/dx x^2 y^4, d/dy x^2 y^4\"\n",
    "- \"derivative of x^4 sin x\"\n",
    "- \"limit (1+1/n)^n as n->infinity\"\n",
    "- \"line through (1,2) and (2,1)\"\n",
    "- \"work F=30N, d=100m\"\n",
    "- \"centripetal acceleration, 30mph, 500 ft\"\n",
    "- \"gravitational potential energy, 5 kg, 10 meters\"\n",
    "- \"ideal gas law 2.2mol, 2.0atm, 500K\"\n",
    "- \"photon energy 435nm\"\n",
    "- \"H2SO4\"\n",
    "- \"carbon\"\n",
    "- \"10 densest elements\"\n",
    "- \"octane + O2 -> water + CO2\"\n",
    "- \"ocean at 300m\"\n",
    "- \"global CO2 level\"\n",
    "- \"nerve supply of gallbladder\"\n",
    "- \"chromosome 5, 12.65 million base pairs\"\n",
    "- \"photosynthesis\"\n",
    "- \"Holy Roman Empire\"\n",
    "- \"ww2\"\n",
    "- \"President of Argentina\"''')\n",
    "\n",
    "    return [wolfram_tool]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b43354c-e776-4cb4-b637-0433eec47358",
   "metadata": {},
   "source": [
    "### Initialize the ReAct Agent\n",
    "\n",
    "We’ll set up the `ReActAgent` with all the operation tools, allowing it to select the appropriate tool based on the query."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "91449d49-ba35-4f55-9bc9-ecd2fa694063",
   "metadata": {},
   "outputs": [],
   "source": [
    "from llama_index.core import PromptTemplate\n",
    "\n",
    "def build_agent(wolfram_api_key, llm, verbose=True):\n",
    "    # Define Wolfram Alpha tool to fetch factual information.\n",
    "    wolfram_tools = create_wolfram_tools(wolfram_api_key)\n",
    "\n",
    "    # Initialize the ReAct agent with the Wolfram Alpha tool and the LLM model.\n",
    "    agent = ReActAgent.from_tools(\n",
    "        tools=wolfram_tools,\n",
    "        llm=llm,\n",
    "        verbose=verbose,\n",
    "        max_iterations=20\n",
    "    )\n",
    "\n",
    "    # Update system prompt for the agent\n",
    "    react_system_header_str = \"\"\"\\\n",
    "\n",
    "You are designed to help with a variety of tasks, from answering questions to providing summaries to other types of analyses.\n",
    "\n",
    "## Tools\n",
    "\n",
    "You have access to a wide variety of tools. ALWAYS USE AT LEAST ONE TOOL.\n",
    "Repeatedly use the tools until you have GATHERED AS MUCH FACTUAL INFORMATION as you can before completing the task at hand.\n",
    "This may require breaking the task into subtasks and using different tools (or the same tool multiple times) to complete each subtask.\n",
    "\n",
    "You have access to the following tools:\n",
    "{tool_desc}\n",
    "\n",
    "## Output Format\n",
    "\n",
    "Please answer in the same language as the question and use the following format:\n",
    "\n",
    "```\n",
    "Thought: The current language of the user is: (user's language). I need to use a tool to help me answer the question.\n",
    "Action: tool name (one of {tool_names}) if using a tool.\n",
    "Action Input: the input to the tool, in a JSON format representing the kwargs (e.g. {{\"input\": \"hello world\", \"num_beams\": 5}})\n",
    "```\n",
    "\n",
    "Please ALWAYS start with a Thought.\n",
    "\n",
    "NEVER surround your response with markdown code markers. You may use code markers within your response if you need to.\n",
    "\n",
    "Please use a valid JSON format for the Action Input. Do NOT do this {{'input': 'hello world', 'num_beams': 5}}.\n",
    "\n",
    "If this format is used, the user will respond in the following format:\n",
    "\n",
    "```\n",
    "Observation: tool response\n",
    "```\n",
    "\n",
    "You should keep repeating the above format until you have enough information to answer the question without using any more tools. \n",
    "Remember to always use at least one tool before completing the task.\n",
    "At that point, you MUST respond in the one of the following two formats:\n",
    "\n",
    "```\n",
    "Thought: I can answer without using any more tools. I'll use the user's language to answer\n",
    "Answer: [your answer here (In the same language as the user's question)]\n",
    "```\n",
    "\n",
    "```\n",
    "Thought: I cannot answer the question with the provided tools.\n",
    "Answer: [your answer here (In the same language as the user's question)]\n",
    "```\n",
    "\n",
    "## Current Conversation\n",
    "\n",
    "Below is the current conversation consisting of interleaving human and assistant messages.\n",
    "\n",
    "    \"\"\"\n",
    "    react_system_prompt = PromptTemplate(react_system_header_str)\n",
    "\n",
    "    agent.update_prompts({\"agent_worker:system_prompt\": react_system_prompt})\n",
    "    return agent"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5519794f-00b9-4638-8e0d-b37b17404d2a",
   "metadata": {},
   "source": [
    "### Initialize the Chatbot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d3fd6c4e-f4c8-490d-8972-5121009208a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "class FactBasedChat:\n",
    "    \"\"\"\n",
    "    An interactive chatbot that provides fact-based responses to student questions\n",
    "    by leveraging both an LLM (Large Language Model) and the Wolfram Alpha API for\n",
    "    accurate information retrieval.\n",
    "\n",
    "    Attributes:\n",
    "        message_history (list): A history of messages exchanged between the student and the tutor.\n",
    "        agent (ReActAgent): The ReAct agent that processes student input and uses tools to generate responses.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, openai_api_key: str, wolfram_api_key: str, \n",
    "                 display_system: bool = False, verbose: bool = False):\n",
    "        \"\"\"\n",
    "        Initializes the FactBasedChat, setting up the LLM and Wolfram Alpha tool, \n",
    "        and preparing the ReAct agent with all necessary tools.\n",
    "\n",
    "        Parameters:\n",
    "            openai_api_key (str): API key for accessing OpenAI's GPT model.\n",
    "            wolfram_api_key (str): API key for accessing Wolfram Alpha's API.\n",
    "            display_system (bool): If True, displays the initial system prompt (default is False).\n",
    "        \"\"\"\n",
    "        self.display_system = display_system\n",
    "        self.reset_chat()\n",
    "\n",
    "        # Initialize the LLM with specific parameters.\n",
    "        llm = OpenAI(model=\"gpt-4o-mini\", api_key=openai_api_key, temperature=0.)\n",
    "\n",
    "        # Initialize the ReAct agent with the Wolfram Alpha tool and the LLM model.\n",
    "        self.agent =  build_agent(wolfram_api_key, llm, verbose)\n",
    "        \n",
    "    def reset_chat(self):\n",
    "        \"\"\"\n",
    "        Resets the conversation history and initializes the interaction with a system prompt\n",
    "        to guide the LLM in providing accurate, fact-based assistance.\n",
    "        \"\"\"\n",
    "        self.message_history = []\n",
    "\n",
    "        # Define the initial system prompt for the tutor's role.\n",
    "        system_prompt = \"## Your Role\\n\\n\"\n",
    "        system_prompt += (\n",
    "            \"Your role is to support the student's understanding by providing clear, accurate explanations. \"\n",
    "            \"Use the 'wolfram_tool' to verify facts or retrieve background information on any topic as needed. \"\n",
    "            \"This ensures that your responses are reliable and grounded in factual knowledge.\\n\\n\"\n",
    "            #\"Examples of tool usage:\\n\"\n",
    "            #'- To find factual information, use a call like wolfram_tool(\"lifespan of a mosquito\") to retrieve details.\\n'\n",
    "            #'- For math help, use a function call like wolfram_tool(\"solve y = 12x^2 - 3x\") to get equation solutions or explanations.\\n\\n'\n",
    "            \"Engage thoughtfully with the student and clarify concepts wherever possible.\"\n",
    "        )\n",
    "\n",
    "        # Optionally display the system prompt for debugging.\n",
    "        if self.display_system:\n",
    "            print(system_prompt)\n",
    "        \n",
    "        # Add the system prompt to the conversation history.\n",
    "        self.message_history.append(ChatMessage(role=\"system\", content=system_prompt))\n",
    "\n",
    "    def get_response(self, student_input: str, reset: bool = False) -> str:\n",
    "        \"\"\"\n",
    "        Processes the student's input, interacts with the LLM and tools as needed, \n",
    "        and returns the tutor's response based on the conversation history and system instructions.\n",
    "\n",
    "        Parameters:\n",
    "            student_input (str): The question or input provided by the student.\n",
    "            reset (bool): If True, resets the conversation history and restarts with the system prompt.\n",
    "\n",
    "        Returns:\n",
    "            str: The tutor's response to the student's input.\n",
    "        \"\"\"\n",
    "        if reset:\n",
    "            self.reset_chat()\n",
    "        \n",
    "        # Generate a response using the ReAct agent.\n",
    "        response = self.agent.chat(student_input, self.message_history).response\n",
    "\n",
    "        # Append the student's input to the message history.\n",
    "        self.message_history.append(ChatMessage(role=\"user\", content=student_input))\n",
    "        \n",
    "        # Append the AI's response to the message history.\n",
    "        self.message_history.append(ChatMessage(role=\"assistant\", content=response))\n",
    "\n",
    "        return response\n",
    "\n",
    "chatbot = FactBasedChat(openai_api_key, wolfram_api_key, verbose=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fb36de4-de59-4e13-a89c-b41204ec814b",
   "metadata": {},
   "source": [
    "### Test the Agent\n",
    "\n",
    "Try different prompts to observe how the agent selects the tool and handles each type of query."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c4471201-2857-402e-9851-1d9350d0ec88",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "> Running step c69dbcfd-adf4-4ebf-8ec2-372693bcb9af. Step input: How do I solve x^2 - 5x + 6 = 0?\n",
      "\u001b[1;3;38;5;200mThought: The current language of the user is: English. I need to use a tool to help me answer the question.\n",
      "Action: wolfram_tool\n",
      "Action Input: {'query': 'solve x^2 - 5x + 6 = 0'}\n",
      "\u001b[0m\u001b[1;3;34mObservation: ### Wolfram Information\n",
      "\n",
      "Input interpretation:\n",
      "\tsolve x^2 - 5 x + 6 = 0\n",
      "\n",
      "Results:\n",
      "\tx = 2\n",
      "\tx = 3\n",
      "\n",
      "Sum of roots:\n",
      "\t5\n",
      "\n",
      "Product of roots:\n",
      "\t6\n",
      "\n",
      "\u001b[0m> Running step 6c469f9c-6d5b-4906-9521-350e02e1d9d5. Step input: None\n",
      "\u001b[1;3;38;5;200mThought: I can answer without using any more tools. I'll use the user's language to answer.\n",
      "Answer: To solve the equation \\(x^2 - 5x + 6 = 0\\), you can factor it as \\((x - 2)(x - 3) = 0\\). This gives the solutions \\(x = 2\\) and \\(x = 3\\).\n",
      "\u001b[0m"
     ]
    }
   ],
   "source": [
    "response = chatbot.get_response(\"How do I solve x^2 - 5x + 6 = 0?\", reset=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "73e546b4-2966-4e4e-adf7-6eea38e05369",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "> Running step d749d972-edb1-4d52-b032-8a4376da3c4e. Step input: How much energy does a 5 kg object have if it falls from 10 meters?\n",
      "\u001b[1;3;38;5;200mThought: I need to calculate the gravitational potential energy of a 5 kg object falling from a height of 10 meters. I'll use the formula for gravitational potential energy, which is given by PE = m * g * h, where m is mass, g is the acceleration due to gravity, and h is height. The standard value for g is approximately 9.81 m/s².\n",
      "Action: wolfram_tool\n",
      "Action Input: {'query': '5 kg * 9.81 m/s^2 * 10 m'}\n",
      "\u001b[0m\u001b[1;3;34mObservation: ### Wolfram Information\n",
      "\n",
      "Input interpretation:\n",
      "\t5 kg (kilograms)×9.81 m/s^2 (meters per second squared)×10 meters\n",
      "\n",
      "Result:\n",
      "\t490.5 kg m^2/s^2 (kilogram meters squared per second squared)\n",
      "\n",
      "Unit conversions:\n",
      "\t490.5 N m (newton meters)\n",
      "\t490.5 J (joules)\n",
      "\t0.4905 kJ (kilojoules)\n",
      "\t4.905×10^9 ergs\n",
      " (unit officially deprecated)\n",
      "\t0.1363 W h (watt hours)\n",
      "\n",
      "Comparisons as energy:\n",
      "\t ≈ ( 0.12 ≈ 1/9 ) × energy released by explosion of one gram of TNT ( 1 g TNT )\n",
      "\t ≈ 0.36 × energy received from the sun at the earth's orbit by one square meter in one second ( 1360 J )\n",
      "\t ≈ 0.5 × energy stored in a typical photography studio strobe unit ( ≈ 1000 J )\n",
      "\n",
      "Comparison as work:\n",
      "\t ≈ 5 × approximate work done in moving 100 coulomb of charge between a potential difference of 1 volt ( ≈ 100 J )\n",
      "\n",
      "Comparisons as torque:\n",
      "\t ≈ ( 0.039 ≈ 1/26 ) × approximate torque on the blades of a wind turbine rated at 2 megawatts ( ≈ 13000 N m )\n",
      "\t ≈ (0.04 to 0.1) × approximate torque of a micro hydro turbine rated between 100 kW and 600 kW for a permanent magnet generator (PMG) ( 2700 to 15000 N m )\n",
      "\t ≈ 0.39 × peak engine torque of a Bugatti Veyron ( ≈ 1250 N m )\n",
      "\n",
      "Interpretations:\n",
      "\tenergy\n",
      "\twork\n",
      "\ttorque\n",
      "\n",
      "Basic unit dimensions:\n",
      "\t[mass] [length]^2 [time]^(-2)\n",
      "\n",
      "Corresponding quantities:\n",
      "\tRelativistic mass m from E = mc^2:\n",
      " | 5.5 pg (picograms)\n",
      "\tSpectroscopic wavenumber for a photon from the Planck relation connecting spectroscopic wavenumber ν^~ with energy E = hcν^~:\n",
      " | 2.469×10^27 m^(-1) (reciprocal meters)\n",
      "\tAngular torque τ_a from τ = rads τ_a:\n",
      " | 491 J/rad (joules per radian)\n",
      " | 491 N m/rad (newton meters per radian)\n",
      " | 8.6 N m/° (newton meters per degree)\n",
      " | 76 lbf in/° (pound-force inches per degree)\n",
      "\n",
      "\u001b[0m> Running step d8bdc46f-c95d-460c-b2da-7fed6d55e0e6. Step input: None\n",
      "\u001b[1;3;38;5;200mThought: I can answer without using any more tools. I'll use the user's language to answer.\n",
      "Answer: The energy of a 5 kg object falling from a height of 10 meters is 490.5 joules.\n",
      "\u001b[0m"
     ]
    }
   ],
   "source": [
    "response = chatbot.get_response(\"How much energy does a 5 kg object have if it falls from 10 meters?\", reset=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "43c7b795-5fed-4cf5-a942-2a2784596391",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "> Running step fb3a79c4-3a4f-42b6-8c81-1fce24c0beff. Step input: How long did the Roman Empire last?\n",
      "\u001b[1;3;38;5;200mThought: The current language of the user is: English. I need to use a tool to help me answer the question.\n",
      "Action: wolfram_tool\n",
      "Action Input: {'query': 'duration of the Roman Empire'}\n",
      "\u001b[0m\u001b[1;3;34mObservation: ### Wolfram Information\n",
      "\n",
      "Input interpretation:\n",
      "\tRoman Empire | dates\n",
      "\n",
      "Result:\n",
      "\t16-01-27 BC to 395 AD\n",
      "\n",
      "\u001b[0m> Running step 7b130c8e-7db8-4e96-b3b6-ed8e5b966923. Step input: None\n",
      "\u001b[1;3;38;5;200mThought: I can answer without using any more tools. I'll use the user's language to answer.\n",
      "Answer: The Roman Empire lasted from 27 BC to 395 AD, which is approximately 422 years.\n",
      "\u001b[0m"
     ]
    }
   ],
   "source": [
    "response = chatbot.get_response(\"How long did the Roman Empire last?\", reset=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "41ee747d-06ce-40bf-9beb-30435be3bb85",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "> Running step b01b8ff0-f69c-45a0-9670-3b57421e2f05. Step input: Why do plants need sunlight for photosynthesis?\n",
      "\u001b[1;3;38;5;200mThought: The current language of the user is: English. I need to use a tool to help me answer the question.\n",
      "Action: wolfram_tool\n",
      "Action Input: {'query': 'photosynthesis process in plants'}\n",
      "\u001b[0m\u001b[1;3;34mObservation: Try another query using as few words as possible to communicate the general concept. If you are still unsuccessful, try using separate, single word queries.\n",
      "\u001b[0m> Running step b669a0b5-dbae-41fe-9b96-ade7cdcf69b6. Step input: None\n",
      "\u001b[1;3;38;5;200mThought: I need to refine my query to get the relevant information about why plants need sunlight for photosynthesis.\n",
      "Action: wolfram_tool\n",
      "Action Input: {'query': 'why plants need sunlight for photosynthesis'}\n",
      "\u001b[0m\u001b[1;3;34mObservation: Try another query using as few words as possible to communicate the general concept. If you are still unsuccessful, try using separate, single word queries.\n",
      "\u001b[0m> Running step 58fd4163-9a1e-4bd2-83c7-0f11f1bfd367. Step input: None\n",
      "\u001b[1;3;38;5;200mThought: I will simplify my query further to focus on the essential aspect of sunlight in photosynthesis.\n",
      "Action: wolfram_tool\n",
      "Action Input: {'query': 'sunlight photosynthesis'}\n",
      "\u001b[0m\u001b[1;3;34mObservation: Try another query using as few words as possible to communicate the general concept. If you are still unsuccessful, try using separate, single word queries.\n",
      "\u001b[0m> Running step f263d8bb-5a33-4cdd-a5ef-ff7cdfbfc8e0. Step input: None\n",
      "\u001b[1;3;38;5;200mThought: I will break down the query into single words to find the necessary information about sunlight and photosynthesis.\n",
      "Action: wolfram_tool\n",
      "Action Input: {'query': 'photosynthesis'}\n",
      "\u001b[0m\u001b[1;3;34mObservation: ### Wolfram Information\n",
      "\n",
      "Input interpretation:\n",
      "\tphotosynthesis (English word)\n",
      "\n",
      "Definition:\n",
      "\tnoun | synthesis of compounds with the aid of radiant energy (especially in plants)\n",
      "\n",
      "American pronunciation:\n",
      "\tf, ohtohs'inthuhsuhs (IPA: fˌoʊtoʊsˈɪnθəsəs)\n",
      "\n",
      "Hyphenation:\n",
      "\tpho-to-syn-the-sis (14 letters | 5 syllables)\n",
      "\n",
      "First known use in English:\n",
      "\t1898 (Victorian era) (126 years ago)\n",
      "\n",
      "Inflected form:\n",
      "\tphotosyntheses\n",
      "\n",
      "Broader terms:\n",
      "\tchemical action | chemical change | chemical process\n",
      "\n",
      "Rhymes:\n",
      "\tsynthesis\n",
      "(based on typical American pronunciation)\n",
      "\n",
      "Lexically close words:\n",
      "\tphotosynthesizes\n",
      "\n",
      "Anagrams:\n",
      "\t(none among common words)\n",
      "\n",
      "Translations:\n",
      "\tGerman: | Fotosynthese° (general)\n",
      "Spanish: | fotosíntesis (general)\n",
      "French: | photosynthèse (general)\n",
      "Portuguese: | fotossíntese (general)\n",
      "Japanese: | 光合成 (common noun)\n",
      "\n",
      "Other notable uses:\n",
      "\tInternet domains:\tphotosynthesis.com | photosynthesis.net | photosynthesis.org | photosynthesis.info | photosynthesis.biz (total: 5)\n",
      "\n",
      "Crossword puzzle clues:\n",
      "\t(none)\n",
      "\n",
      "Scrabble score:\n",
      "\t25 (International English) | 25 (North American English)\n",
      "\n",
      "\u001b[0m> Running step 92b4afc0-4497-438d-9268-6c86c3a535b7. Step input: None\n",
      "\u001b[1;3;38;5;200mThought: I have retrieved information about photosynthesis, but I need to connect it specifically to the role of sunlight in the process.\n",
      "Action: wolfram_tool\n",
      "Action Input: {'query': 'role of sunlight in photosynthesis'}\n",
      "\u001b[0m\u001b[1;3;34mObservation: Try another query using as few words as possible to communicate the general concept. If you are still unsuccessful, try using separate, single word queries.\n",
      "\u001b[0m> Running step 52ed5bc1-c5fb-4ac7-b1c0-44b44a201ff6. Step input: None\n",
      "\u001b[1;3;38;5;200mThought: I will simplify my query even further to focus specifically on sunlight's role in photosynthesis.\n",
      "Action: wolfram_tool\n",
      "Action Input: {'query': 'sunlight role photosynthesis'}\n",
      "\u001b[0m\u001b[1;3;34mObservation: Try another query using as few words as possible to communicate the general concept. If you are still unsuccessful, try using separate, single word queries.\n",
      "\u001b[0m> Running step 0c305725-01e0-4602-a432-c1159bc4c85b. Step input: None\n",
      "\u001b[1;3;38;5;200mThought: I will break down the query into single words to find the necessary information about sunlight's role in photosynthesis.\n",
      "Action: wolfram_tool\n",
      "Action Input: {'query': 'sunlight'}\n",
      "\u001b[0m\u001b[1;3;34mObservation: ### Wolfram Information\n",
      "\n",
      "Input interpretation:\n",
      "\tsunlight (English word)\n",
      "\n",
      "Definition:\n",
      "\tnoun | the rays of the sun\n",
      "\n",
      "American pronunciation:\n",
      "\ts'uhnl, ahyt (IPA: sˈʌnlˌaɪt)\n",
      "\n",
      "Hyphenation:\n",
      "\tsun-light (8 letters | 2 syllables)\n",
      "\n",
      "Inflected form:\n",
      "\tsunlights\n",
      "\n",
      "Synonyms:\n",
      "\tsun | sunshine\n",
      "\n",
      "Narrower terms:\n",
      "\tsunburst\n",
      "\n",
      "Broader terms:\n",
      "\tlight | visible light | visible radiation\n",
      "\n",
      "Rhymes:\n",
      "\t(none among common words)\n",
      "\n",
      "Lexically close words:\n",
      "\tfanlight | gunfight | penlight | skylight\n",
      "\n",
      "Anagram:\n",
      "\thustling\n",
      "\n",
      "Translations:\n",
      "\tGerman: | Sonnenlicht (general) | Tageslicht (daylight) | Sonnenlicht (daylight)\n",
      "Spanish: | luz del sol (general) | luz del día (daylight) | luz del sol (daylight) | luz (daylight)\n",
      "French: | lumière du soleil (general) | lumière du jour (daylight) | lumière du soleil (daylight)\n",
      "Portuguese: | luz do sol (general) | luz do dia (daylight) | luz (daylight) | luz do sol (daylight)\n",
      "Japanese: | 日 (adverbial noun) | 陽 (adverbial noun) | 天日 (common noun) | 日光 (common noun) | 日照 (common noun) | 陽光 (common noun) | 陽射 (common noun) | 太陽光 (common noun) | 日ざし (common noun) | 日の目 (common noun) | 日射し (common noun) | 日差し (common noun) | 陽射し (common noun) | 太陽光線 (common noun)\n",
      "\n",
      "Other notable uses:\n",
      "\tMountains:\tSunlight Peak (United States, 4287 m)\n",
      "\tInternet domains:\tsunlight.com | sunlight.net | sunlight.org | sunlight.info | sunlight.biz (total: 5)\n",
      "\n",
      "Crossword puzzle clues:\n",
      "\tBenefit of a southern exposure | Source of vitamin D\n",
      "(based on all New York Times crossword puzzles 1994 to 2009)\n",
      "\n",
      "Scrabble score:\n",
      "\t12 (International English) | 12 (North American English)\n",
      "\n",
      "\u001b[0m> Running step 3692aaed-cab8-47d2-89f5-1672511bc00b. Step input: None\n",
      "\u001b[1;3;38;5;200mThought: I have gathered information about sunlight, but I still need to connect it to its role in photosynthesis. I will now summarize the relationship based on what I know.\n",
      "Answer: Plants need sunlight for photosynthesis because sunlight provides the energy required to convert carbon dioxide and water into glucose and oxygen. This process occurs in the chloroplasts of plant cells, where chlorophyll absorbs sunlight, initiating the chemical reactions that produce food for the plant.\n",
      "\u001b[0m"
     ]
    }
   ],
   "source": [
    "response = chatbot.get_response(\"Why do plants need sunlight for photosynthesis?\", reset=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "113ebf27-59bb-4edb-bf63-c33234a1057d",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "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.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}