Experiment-AGIent.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copyright &copy; 2023-2024 Praneeth Vadlapati"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup:\n",
    "\n",
    "Example of .env: \n",
    "```bash\n",
    "# Groq API to use LLMs - https://console.groq.com/keys\n",
    "# Groq is preferred for fast responses\n",
    "LM_PROVIDER_BASE_URL=https://api.groq.com/openai/v1\n",
    "LM_API_KEY=\n",
    "LM_MODEL=\n",
    "\n",
    "```\n",
    "\n",
    "Installing packages:\n",
    "```bash\n",
    "pip install openai python-dotenv pandas\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading an LLM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: llama-3.1-70b-versatile\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "import os\n",
    "import sys\n",
    "import io\n",
    "\n",
    "import pandas as pd\n",
    "from common_functions import get_lm_response, extract_data, \\\n",
    "    print_progress, print_error, model, display_md, load_env\n",
    "\n",
    "print(f'Model: {model}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A. \tCreation of a table of tools\n",
    "## B. \tIncorporating new tools into the table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculator added successfully\n",
      "Code Interpreter added successfully\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>toolID</th>\n",
       "      <th>tool_name</th>\n",
       "      <th>tool_desc</th>\n",
       "      <th>python_function</th>\n",
       "      <th>input_desc</th>\n",
       "      <th>pip_packages</th>\n",
       "      <th>keywords</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>calc</td>\n",
       "      <td>Calculator</td>\n",
       "      <td>Performs basic arithmetic operations as a calc...</td>\n",
       "      <td>def main(a: float, o: str, b: float) -&gt; float:...</td>\n",
       "      <td>{'a': 'first number as a float', 'o': 'operato...</td>\n",
       "      <td>None</td>\n",
       "      <td>[calculator, math operations, arithmetic, addi...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>exec</td>\n",
       "      <td>Code Interpreter</td>\n",
       "      <td>Runs any Python code and returns what is printed</td>\n",
       "      <td>import io\\nimport sys\\n\\ndef main(code: str) -...</td>\n",
       "      <td>{'code': 'source code in Python with \"print\" s...</td>\n",
       "      <td>None</td>\n",
       "      <td>[python interpreter, code execution, execute p...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  toolID         tool_name                                          tool_desc  \\\n",
       "0   calc        Calculator  Performs basic arithmetic operations as a calc...   \n",
       "1   exec  Code Interpreter   Runs any Python code and returns what is printed   \n",
       "\n",
       "                                     python_function  \\\n",
       "0  def main(a: float, o: str, b: float) -> float:...   \n",
       "1  import io\\nimport sys\\n\\ndef main(code: str) -...   \n",
       "\n",
       "                                          input_desc pip_packages  \\\n",
       "0  {'a': 'first number as a float', 'o': 'operato...         None   \n",
       "1  {'code': 'source code in Python with \"print\" s...         None   \n",
       "\n",
       "                                            keywords  \n",
       "0  [calculator, math operations, arithmetic, addi...  \n",
       "1  [python interpreter, code execution, execute p...  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tools_data = [\n",
    "\t# {\n",
    "\t# \t'toolID': 'weathr1',\n",
    "\t# \t'tool_name': 'Weather API',\n",
    "\t# \t'tool_desc': 'Provides weather information',\n",
    "\t# \t'python_function': '''\n",
    "\t# \t\tdef main(location: str) -> str:\n",
    "\t# \t\t\treturn '30 degrees Fahrenheit, cloudy'\n",
    "\t# \t'''.strip(),\n",
    "\t# \t'input_desc': { 'location': 'should be a string in the format of \"city, country\"' },\n",
    "\t# \t'pip_packages': ['requests'],\n",
    "\t# \t'keywords': None,\n",
    "\t# },\n",
    "\t{\n",
    "\t\t'toolID': 'calc',\n",
    "\t\t'tool_name': 'Calculator',\n",
    "\t\t'tool_desc': 'Performs basic arithmetic operations as a calculator',\n",
    "\t\t'python_function': '''\n",
    "def main(a: float, o: str, b: float) -> float:\n",
    "\tif o == '+':\n",
    "\t\treturn a + b\n",
    "\telif o == '-':\n",
    "\t\treturn a - b\n",
    "\telif o == '*':\n",
    "\t\treturn a * b\n",
    "\telif o == '/':\n",
    "\t\treturn a / b\n",
    "\telse:\n",
    "\t\treturn 'Invalid operator'\n",
    "\n",
    "\t\t'''.strip(),\n",
    "\t\t'input_desc': { 'a': 'first number as a float', 'o': 'operator like +,-,*,/', 'b': 'second number as a float' },\n",
    "\t\t'pip_packages': None,\n",
    "\t\t'keywords': None,\n",
    "\t},\n",
    "\t# exec - code interpreter of python\n",
    "\t{\n",
    "\t\t'toolID': 'exec',\n",
    "\t\t'tool_name': 'Code Interpreter',\n",
    "\t\t'tool_desc': 'Runs any Python code and returns what is printed',\n",
    "\t\t'python_function': '''\n",
    "import io\n",
    "import sys\n",
    "\n",
    "def main(code: str) -> str:\n",
    "\told_stdout = sys.stdout\n",
    "\tnew_stdout = io.StringIO()\n",
    "\tsys.stdout = new_stdout\n",
    "\ttry:\n",
    "\t\texec(code)\n",
    "\t\toutput = new_stdout.getvalue()\n",
    "\t\tif output and output.strip():\n",
    "\t\t\treturn output\n",
    "\t\telse:\n",
    "\t\t\traise Exception('No output')\n",
    "\texcept Exception as e:\n",
    "\t\treturn str(e)\n",
    "\tfinally:\n",
    "\t\tsys.stdout = old_stdout\n",
    "\n",
    "\t\t'''.strip(),\n",
    "\t\t'input_desc': { 'code': 'source code in Python with \"print\" statements to print the outputs' },\n",
    "\t\t'pip_packages': None,\n",
    "\t\t'keywords': None,\n",
    "\t},\n",
    "]\n",
    "\n",
    "\n",
    "sample_val_prompt_template = '''\n",
    "Act as a QA engineer and provide a sample value to test the code.\n",
    "\n",
    "Input description:\n",
    "{input_desc}\n",
    "---\n",
    "Return the sample value in json format like:\n",
    "<sample_value>\n",
    "{{ \"<key>\": \"<value>\" }}\n",
    "</sample_value>\n",
    "'''.strip()\n",
    "# Code:\n",
    "# {python_function}\n",
    "# ---\n",
    "\n",
    "keywords_prompt_template = '''\n",
    "Tool details:\n",
    "Tool Name: {tool_name}\n",
    "Tool Description: {tool_desc}\n",
    "---\n",
    "Provide keywords that can be used to search for this tool.\n",
    "Keywords should be separated by commas.\n",
    "Sample response:\n",
    "`Weather, Temperature, Cloudy`\n",
    "'''.strip()\n",
    "\n",
    "# create a DataFrame using the given columns without data\n",
    "tool_df = pd.DataFrame(columns=tools_data[0].keys())\n",
    "all_tool_keywords = set()\n",
    "\n",
    "for tool_data in tools_data:\n",
    "\t# install the required packages, and test the code by generating a sample value\n",
    "\tpip_packages = tool_data.get('pip_packages', []) or []\n",
    "\tfor package in pip_packages:\n",
    "\t\tos.system(f'pip install {package} > /dev/null 2>&1')\n",
    "\n",
    "\tpython_function = tool_data['python_function']\n",
    "\tif 'def main(' not in python_function:\n",
    "\t\traise Exception('The code should contain a function named \"main\"')\n",
    "\n",
    "\ttry:\n",
    "\t\tsample_val_response = get_lm_response(sample_val_prompt_template.format(\n",
    "\t\t\t\t\t\t\t\t\t\t\t\t# python_function=tool_data['python_function']))\n",
    "\t\t\t\t\t\t\t\t\t\t\t\tinput_desc=tool_data['input_desc']))\n",
    "\t\tsample_values = extract_data(sample_val_response, tag='sample_value')\n",
    "\t\tsample_values = json.loads(sample_values)\n",
    "\t\t# print(f'Sample value: {sample_values}')\n",
    "\n",
    "\t\t# execute the function using sample values\n",
    "\t\tlocal_vars = {}\n",
    "\t\texec(python_function, local_vars)\n",
    "\t\tmain_func = local_vars.get('main')\n",
    "\t\tif not main_func:\n",
    "\t\t\traise Exception('Function \"main\" not found in the provided code')\n",
    "\t\tsample_response = main_func(**sample_values)\n",
    "\t\tif not sample_response:\n",
    "\t\t\traise Exception('Function did not return any value')\n",
    "\t\t# print(f'Sample response: {sample_response}')\n",
    "\n",
    "\t\t# generate the keywords for the tool\n",
    "\t\tkeywords_response = get_lm_response(keywords_prompt_template.format(**tool_data))\n",
    "\t\tkeywords = extract_data(keywords_response)\n",
    "\t\tkeywords = [keyword.lower().strip() for keyword in keywords.split(',')]\n",
    "\t\ttool_data['keywords'] = keywords\n",
    "\t\tall_tool_keywords.update(keywords)\n",
    "\n",
    "\t\t# add the tool to the DataFrame\n",
    "\t\tnew_row = pd.DataFrame([tool_data])\n",
    "\t\ttool_df = pd.concat([tool_df, new_row], ignore_index=True)\n",
    "\t\tprint(f'{tool_data[\"tool_name\"]} added successfully')\n",
    "\texcept Exception as e:\n",
    "\t\tprint(f'Error adding {tool_data[\"tool_name\"]}')\n",
    "\t\tprint(e)\n",
    "\n",
    "tool_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## C. \tUser query processing using tools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "User Response: `1 + 1 = 2.0`\n",
      "User Response: `The result of 1-1 is 0`\n",
      "User Response: `The number of \"r\"s in \"strawberry\" is: 3`\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Query</th>\n",
       "      <th>Tools_used</th>\n",
       "      <th>Response</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>What is 1+1?</td>\n",
       "      <td>calc</td>\n",
       "      <td>8\\n0\\n</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>What is 1-1?</td>\n",
       "      <td>calc</td>\n",
       "      <td>8\\n0\\n</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>How many “r”s are in “strawberry?”</td>\n",
       "      <td>exec</td>\n",
       "      <td>8\\n0\\n</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                Query Tools_used Response\n",
       "0                        What is 1+1?       calc   8\\n0\\n\n",
       "1                        What is 1-1?       calc   8\\n0\\n\n",
       "2  How many “r”s are in “strawberry?”       exec   8\\n0\\n"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "query_required_prompt_template = '''\n",
    "User Query: {user_query}\n",
    "---\n",
    "Does the user query require any of the tools?\n",
    "Respond with `YES` or `NO`, in uppercase inside the backticks.\n",
    "Note: Consider to use tools for anything in which calculations, executions, etc. can be involved in any way.\n",
    "\tUse tools for even the most basic tasks like simple calculation, counting, code execution, etc.\n",
    "'''.strip()\n",
    "\n",
    "tool_keywords_prompt_template = '''\n",
    "User Query: {user_query}\n",
    "Available tool keywords:\n",
    "{available_tool_keywords}\n",
    "---\n",
    "Provide the keywords that the user query can match with.\n",
    "Select all the relevant keywords from the list.\n",
    "Keywords should be separated by commas.\n",
    "Sample response:\n",
    "`Weather, Temperature`\n",
    "'''.strip()\n",
    "\n",
    "tool_selection_prompt_template = '''\n",
    "Relevant Tools:\n",
    "{relevant_tools}\n",
    "---\n",
    "User Query:\n",
    "{user_query}\n",
    "---\n",
    "Select the tool that can be used to answer the user query.\n",
    "Provide the tool ID of the selected tool exactly as shown in the list.\n",
    "Return ID inside backticks.\n",
    "Sample response:\n",
    "`weathr1`\n",
    "'''.strip()\n",
    "\n",
    "input_args_prompt_template = '''\n",
    "Tool Name: {tool_name}\n",
    "Tool Description: {tool_desc}\n",
    "---\n",
    "Input Description:\n",
    "{input_desc}\n",
    "---\n",
    "User Query:\n",
    "{user_query}\n",
    "---\n",
    "Provide the input arguments for the selected tool.\n",
    "Input arguments should be in json format.\n",
    "Sample response:\n",
    "`{{ \"location\": \"New York, US\" }}`\n",
    "'''.strip()\n",
    "\n",
    "user_response_prompt_template = '''\n",
    "Tool name:\n",
    "{tool_name}\n",
    "Input details:\n",
    "{input_desc}\n",
    "Tool input arguments:\n",
    "{input_args}\n",
    "Tool Response:\n",
    "{tool_response}\n",
    "---\n",
    "User Query: {user_query}\n",
    "---\n",
    "Provide the response to the user query.\n",
    "Return the response inside backticks.\n",
    "Sample response:\n",
    "`The weather in New York is 30 degrees Fahrenheit and cloudy`\n",
    "'''.strip()\n",
    "\n",
    "execution_results_df = pd.DataFrame(columns=['Query', 'Tools_used', 'Response'])\n",
    "\n",
    "user_queries = [\n",
    "    # 'Hi',\n",
    "    'What is 1+1?',\n",
    "\t'What is 1-1?',\n",
    "\t'How many “r”s are in “strawberry?”',\n",
    "\t# 'Show the news',\n",
    "]\n",
    "\n",
    "for user_query in user_queries:\n",
    "\tquery_required_response = get_lm_response(\n",
    "\t\tquery_required_prompt_template.format(user_query=user_query))\n",
    "\tquery_required = extract_data(query_required_response)\n",
    "\tquery_required = 'YES' in query_required.upper()\n",
    "\n",
    "\tif not query_required:\n",
    "\t\tprint('No tools required for the user query')\n",
    "\t\tcontinue\n",
    "\n",
    "\ttool_keywords_response = get_lm_response(tool_keywords_prompt_template.format(\n",
    "\t\t\t\t\t\t\t\tavailable_tool_keywords=', '.join(all_tool_keywords)))\n",
    "\ttool_keywords = extract_data(tool_keywords_response)\n",
    "\ttool_keywords = [keyword.lower().strip() for keyword in tool_keywords.split(',')]\n",
    "\t# print(f'Tool Keywords: {tool_keywords}')\n",
    "\n",
    "\t# fetch tools based that contain the selected keywords\n",
    "\trelevant_tools_df = tool_df[tool_df['keywords'].apply(  # select tools\n",
    "\t\t\tlambda x: any(keyword in x for keyword in tool_keywords))]\n",
    "\tif relevant_tools_df.empty:\n",
    "\t\t# raise Exception('No tools found for the user query')\n",
    "\t\tprint('No tools available for the user query')\n",
    "\t\tselected_tool_ID = None\n",
    "  \n",
    "\telse:\n",
    "\t\t# print(f'Relevant Tools: {relevant_tools_df}')\n",
    "\n",
    "\t\t# selecting a tool from the relevant tools\n",
    "\t\trelevant_tools_str = '\\n'.join(relevant_tools_df.apply(  # [['toolID', 'tool_name', 'tool_desc']]\n",
    "\t\t\t\t\t\t\t\tlambda x: f'{x[\"toolID\"]}: {x[\"tool_name\"]} - {x[\"tool_desc\"]}', axis=1))\n",
    "\t\ttool_selection_response = get_lm_response(tool_selection_prompt_template.format(\n",
    "\t\t\t\t\t\t\t\t\trelevant_tools=relevant_tools_str, user_query=user_query))\n",
    "\t\tselected_tool_ID = extract_data(tool_selection_response)\n",
    "\t\tselected_tool_ID = selected_tool_ID.strip()\n",
    "\t\t# print(f'Selected Tool ID: {selected_tool_ID}')\n",
    "\n",
    "\t\t# generating input arguments based on selected tool and user query\n",
    "\t\tselected_tool = tool_df[tool_df['toolID'] == selected_tool_ID].iloc[0]\n",
    "\t\tinput_args_response = get_lm_response(input_args_prompt_template.format(\n",
    "\t\t\t\t\t\t\t\ttool_name=selected_tool['tool_name'],\n",
    "\t\t\t\t\t\t\t\ttool_desc=selected_tool['tool_desc'],\n",
    "\t\t\t\t\t\t\t\tuser_query=user_query,\n",
    "\t\t\t\t\t\t\t\tinput_desc=str(selected_tool['input_desc']),\n",
    "\t\t\t\t\t\t\t))\n",
    "\t\tinput_args = extract_data(input_args_response)\n",
    "\t\tinput_args = json.loads(input_args)\n",
    "\t\t# print(f'Input Args: {input_args}')\n",
    "\n",
    "\t\t# execute the function using input values\n",
    "\t\tlocal_vars = {}\n",
    "\t\texec(selected_tool['python_function'], local_vars)\n",
    "\t\tmain_func = local_vars.get('main')\n",
    "\t\ttool_response = main_func(**input_args)\n",
    "\t\t# print(f'Tool Response: {tool_response}')\n",
    "\n",
    "\t\t# provide the response to the user query\n",
    "\t\tuser_response_response = get_lm_response(user_response_prompt_template.format(\n",
    "\t\t\t\t\t\t\t\t\ttool_name=selected_tool['tool_name'],\n",
    "\t\t\t\t\t\t\t\t\tinput_args=input_args,\n",
    "\t\t\t\t\t\t\t\t\ttool_response=tool_response,\n",
    "        \t\t\t\t\t\t\tinput_desc=str(selected_tool['input_desc']),\n",
    "\t\t\t\t\t\t\t\t\tuser_query=user_query))\n",
    "\t\tuser_response = extract_data(user_response_response)\n",
    "\t\tprint(f'User Response: `{user_response}`')\n",
    "\n",
    "\t# add execution results\n",
    "\tnew_execution_row = pd.DataFrame([{\n",
    "\t\t'Query': user_query,\n",
    "\t\t'Tools_used': selected_tool_ID,\n",
    "\t\t'Response': user_response\n",
    "\t}])\n",
    "\texecution_results_df = pd.concat([execution_results_df, new_execution_row], ignore_index=True)\n",
    "\n",
    "execution_results_df"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "venv",
   "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}