lec5_plan_and_execute_with_tool_execute.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plan and execute with tool - Execute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from openai import OpenAI\n",
    "from typing import List, Dict\n",
    "\n",
    "def ask(messages: List[Dict], is_json:bool = False):\n",
    "        client = OpenAI(api_key='YOUR DEEPSEEK KEY', base_url=\"https://api.deepseek.com\")\n",
    "\n",
    "        if is_json:\n",
    "                response = client.chat.completions.create(\n",
    "                        model = 'deepseek-chat',\n",
    "                        temperature = 0,\n",
    "                        messages = messages,\n",
    "                        response_format={ \"type\": \"json_object\" }\n",
    "                )\n",
    "        else:\n",
    "                response = client.chat.completions.create(\n",
    "                        model = 'deepseek-chat',\n",
    "                        temperature = 0,\n",
    "                        messages = messages,\n",
    "                )\n",
    "\n",
    "        return response"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Web Search\n",
    "from search import internet_search, process_content\n",
    "\n",
    "class WebSearch:\n",
    "    def __init__(self, name:str='web_search', threhold:int=8000):\n",
    "        self.system_prompt = \"\"\"\n",
    "You are a Insight Researcher.\n",
    "\n",
    "1. To find detail informtion for the user query\n",
    "and summary the content into one sentence as simple as possible\n",
    "2. If the user's question is about specific numerical values, \n",
    "only return the numerical results without any additional explanation.\n",
    "\"\"\"\n",
    "        self.name = name\n",
    "        self.description = \"the tool use for web search\"\n",
    "        self.threhold = threhold\n",
    "\n",
    "    def __call__(self, query:str):\n",
    "        results = internet_search(query)\n",
    "        # print(results)\n",
    "        all_text = \"\"\n",
    "        windows_size = 0\n",
    "        for item in results:\n",
    "            if windows_size >= self.threhold:\n",
    "                break\n",
    "            page_content = process_content(item['href'])\n",
    "            for page in page_content:\n",
    "                if windows_size + len(page) > self.threhold:\n",
    "                    remaining_space = self.threhold - windows_size\n",
    "                    all_text += page[:remaining_space].strip() + \"\\n\\n\"\n",
    "                    windows_size = self.threhold\n",
    "                    break\n",
    "                else:\n",
    "                    windows_size += len(page)\n",
    "                    all_text += page + \"\\n\\n\"\n",
    "            if windows_size >= self.threhold:\n",
    "                break\n",
    "\n",
    "        msg = [{\"role\":\"system\",\"content\":self.system_prompt},\n",
    "               {\"role\":\"user\", \"content\": f\"The search query {query}\\nThe search results are {all_text}\"}]\n",
    "        \n",
    "        answer = ask(messages=msg)\n",
    "\n",
    "        return answer.choices[0].message.content\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AbsDifference:\n",
    "    def __init__(self, name:str=\"subtractions\"):\n",
    "        self.system_prompt = \"You are a calculation assistant.\"\n",
    "\n",
    "        self.name = name\n",
    "        self.description = \"math tool for calculating subtractions\"\n",
    "        \n",
    "    def __call__(self, question:str) -> str:\n",
    "\n",
    "        user_content = f\"\"\"\n",
    "Answer the Question based on the Context. When you write down a expression, it MUST ONLY consists of numbers and operators. Here are some guidelines that you will be PANALIZED if you don't follow:\n",
    "\n",
    "  - When you are asked for differences, you consider the absolute value of the difference. Difference of two numbers is always positive.For instance, the difference between 1 and 2 is 1, not -1.\n",
    "  - When you are applying operations (e.g. difference, summation, ratio, etc.) between multiple values in the Context, you must unify the units of those numbers. For instance, you cannot add 1 meter to 1 foot.\n",
    "     - You must pick the values in the same units if all the values are available in the same units.\n",
    "     - If not, you must convert them to the same units before applying the operation.\n",
    "  - You MUST strictly follow the unit (e.g. meter, kilometer, million, etc.) you were asked.\n",
    "     - If the Context has the numbers in same units as the question, you can directly use them.\n",
    "     - If the Context has the numbers in different units than the question, you must convert them to the units asked in the question.For example, if the question asks for the distance between two cities in kilometers, but the Context has the distance in miles, you must convert the distance to kilometers.\n",
    "  - If you are asked about a particular number in millions, billions, or any other unit, the number should be written without specifying the unit. For example, if you are asked for 100 millions, it should be written as 100, not 100 million or 100,000,000.\n",
    " - Never introduce a variable. For instance \"gazelle_max_speed * 1.4\" is not allowed. Pick up a correct number from the given context.\n",
    "\n",
    " Question: {question}\n",
    " \n",
    "\"\"\"\n",
    "        messages = [\n",
    "            {\"role\":\"system\", \"content\":self.system_prompt},\n",
    "            {\"role\":\"user\", \"content\":user_content}\n",
    "        ]\n",
    "\n",
    "        response = ask(messages=messages)\n",
    "        return response.choices[0].message.content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "search_tool = WebSearch(name=\"search\")\n",
    "math_tool = AbsDifference(name=\"math\")\n",
    "\n",
    "tools = [search_tool, math_tool]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Execute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plans = \"\"\"\n",
    "Plan:\n",
    "1. search('Toronto population 2023')\n",
    "2. search('New York City population 2023')\n",
    "3. math('population difference between New York City and Toronto', ['$1', '$2'])\n",
    "Thought: I can answer the question now.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "ACTION_PATTERN = r\"\\n*(\\d+)\\. (\\w+)\\((.*)\\)(\\s*#\\w+\\n)?\"\n",
    "matches = re.findall(ACTION_PATTERN, plans)\n",
    "print(matches)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Any, Sequence, Union, Callable, Collection, Dict, List, Optional\n",
    "class Step:\n",
    "    def __init__(self, \n",
    "                 idx: int, \n",
    "                 name: str, \n",
    "                 tool: callable,\n",
    "                 args: Collection[Any],\n",
    "                 dependencies: Collection[int]):\n",
    "        self.idx = idx\n",
    "        self.name = name\n",
    "        self.tool = tool\n",
    "        self.args = args\n",
    "        self.dependencies = dependencies\n",
    "        self.observation = None\n",
    "\n",
    "    def exec(self):\n",
    "        self.observation = self.tool(self.args)\n",
    "        return self.observation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ID_PATTERN = r\"\\$\\{?(\\d+)\\}?\"\n",
    "\n",
    "def default_dependency_rule(idx, args: str):\n",
    "    matches = re.findall(ID_PATTERN, args)\n",
    "    numbers = [int(match) for match in matches]\n",
    "    return idx in numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_tool(tool_name:str, tools: Sequence[Callable]=tools):\n",
    "    for tool in tools:\n",
    "        if tool.name == tool_name:\n",
    "            return tool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "steps = []\n",
    "for item in matches:\n",
    "    idx, tool_name, tool_args, _ = item\n",
    "    idx = int(idx)\n",
    "    print(f\"step {idx}\")\n",
    "    print(f\"tool name is {tool_name}, args is {tool_args}\")\n",
    "    \n",
    "    # match tool\n",
    "    tool = find_tool(tool_name)\n",
    "\n",
    "    # get dependencies\n",
    "    dependencies = [i for i in range(1, idx) if default_dependency_rule(i, tool_args)]\n",
    "    print(f\"the dependencies are {dependencies}\")\n",
    "\n",
    "    # build step object\n",
    "    step = Step(\n",
    "        idx=idx,\n",
    "        name=tool_name,\n",
    "        tool=tool,\n",
    "        args=tool_args,\n",
    "        dependencies=dependencies\n",
    "    )\n",
    "\n",
    "    steps.append(step)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "step1 = steps[0]\n",
    "print(f\"the args of step1 {step1.args}\")\n",
    "result1 = step1.exec()\n",
    "print(\"the result of step1\", result1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "step2 = steps[1]\n",
    "print(f\"the args of step2 {step2.args}\")\n",
    "result2 = step2.exec()\n",
    "print(\"the result of step2\", result2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "step3 = steps[2]\n",
    "for dependency in sorted(step3.dependencies, reverse=True):\n",
    "    for arg_mask in [\"${\" + str(dependency) + \"}\", \"$\" + str(dependency)]:\n",
    "        if arg_mask in step3.args:\n",
    "            print(arg_mask)\n",
    "            if steps[dependency-1].observation is not None:\n",
    "                print(steps[dependency -1].observation)\n",
    "                step3.args = step3.args.replace(\n",
    "                                arg_mask, str(steps[dependency-1].observation)\n",
    "                            )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"the args of step3 {step3.args}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "result3 = step3.exec()\n",
    "print(result3)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "agent",
   "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.14"
  },
  "vscode": {
   "interpreter": {
    "hash": "bf9bbd8761e205a067c272e6ed0abbdf91f38ae4d8d5f3f65ae82c28409ae2c6"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}