Tutorial 3 - Memory.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "2fa1e388-b8f4-4fa3-be5a-ba7c6caae038",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Tutorial 3 - Memory\n",
    "- Video: https://www.youtube.com/watch?v=75Px54vzCIQ\n",
    "\n",
    "## Key Philosophy\n",
    "- It would be important to learn from past experience and improve the agentic framework - memory is key to that\n",
    "- You can add to the memory bank of your Agents pre-inference (by collecting from a pool of data prior to running the Agent), or during inference (add on in between running subtasks)\n",
    "\n",
    "- In general, for the various Memory classes, you use:\n",
    "    - `append(list_of_memories)`: append a list of memories to the memory bank\n",
    "    - `retrieve(task: str)`: retrieves top_k memories based on task \n",
    "    \n",
    "## Use Memory in Agents\n",
    "- Agent class takes `memory_bank` as a parameter during initialisation of an `Agent`\n",
    "- memory_bank: class Dict[Memory]. Stores multiple types of memory for use by the agent. Customise the Memory config within the Memory class."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16e38089",
   "metadata": {},
   "source": [
    "# Setup Guide"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01cf10ed",
   "metadata": {},
   "source": [
    "## Step 1: Install AgentJo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e017dd68",
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip install agentjo"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ae7b95a",
   "metadata": {},
   "source": [
    "## Step 2: Import required functions and setup relevant API keys for your LLM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "707028fa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Set up API key and do the necessary imports\n",
    "from agentjo import *\n",
    "import os\n",
    "\n",
    "from dotenv import load_dotenv\n",
    "load_dotenv()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5953438",
   "metadata": {},
   "source": [
    "## Step 3: Define your own LLM\n",
    "- Take in a `system_prompt`, `user_prompt`, and outputs llm response string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d49dcf6c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def llm(system_prompt: str, user_prompt: str) -> str:\n",
    "    ''' Here, we use OpenAI for illustration, you can change it to your own LLM '''\n",
    "    # ensure your LLM imports are all within this function\n",
    "    from openai import OpenAI\n",
    "    \n",
    "    # define your own LLM here\n",
    "    client = OpenAI()\n",
    "    response = client.chat.completions.create(\n",
    "        model='gpt-4o-mini',\n",
    "        temperature = 0,\n",
    "        messages=[\n",
    "            {\"role\": \"system\", \"content\": system_prompt},\n",
    "            {\"role\": \"user\", \"content\": user_prompt}\n",
    "        ]\n",
    "    )\n",
    "    return response.choices[0].message.content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c013f7ef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Neutral'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Verify that llm function is working\n",
    "llm(system_prompt = 'You are a classifier to classify the sentiment of a sentence', \n",
    "    user_prompt = 'It is a hot and sunny day')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b04eacda-4d82-4187-a93e-dd770c95bedc",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Memory Class 1: Base Memory Class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24a176e3-fb39-47f2-910e-eb051b4ead77",
   "metadata": {
    "tags": []
   },
   "source": [
    "- In-house Vector DB that can store anything in a Python list for retrieval to augment the Agent's prompt\n",
    "- Retrieves top k memory items based on task \n",
    "- Inputs:\n",
    "    - `memory`: List. Default: Empty List. The list containing the memory items\n",
    "    - `top_k`: Int. Default: 5. The number of memory list items to retrieve\n",
    "    - `mapper`: Function. Maps the memory item to another form for comparison by ranker or LLM. Default: `lambda x: x`\n",
    "        - Example mapping: `lambda x: x.fn_description` (If x is a Class and the string you want to compare for similarity is the fn_description attribute of that class)\n",
    "    - `approach`: str. Either `retrieve_by_ranker` or `retrieve_by_llm` to retrieve memory items.\n",
    "        - Ranker is faster and cheaper as it compares via embeddings, but are inferior to LLM-based methods for contextual information\n",
    "    - `retrieve_fn`: Default: None. Takes in task and outputs top_k similar memories in a list\n",
    "    - `ranker`: `Ranker`. The Ranker which defines a similarity score between a query and a key. Default: OpenAI `text-embedding-3-small` model. \n",
    "        - Can be replaced with a function which returns similarity score from 0 to 1 when given a query and key\n",
    "        \n",
    "## In-built Memory in AgentJo: Function Memory\n",
    "- Default: `memory_bank = {'Function': Memory(top_k = 5, mapper = lambda x: x.fn_description, approach = 'retrieve_by_ranker'), llm = self.llm}`\n",
    "- Does RAG over Task -> Function mapping"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a04abb86-6f74-4af5-8b72-b26a6029eb9f",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Use Case 1: Filtering Functions by Task\n",
    "- AgentJo chooses `top k` (default k: 5) functions according to similarity to subtask\n",
    "- In addition to `top k` functions, we will also give agent all the compulsory functions\n",
    "    - `is_compulsory` variable of Function set to `True` means that we will always have it as one of the functions for planning and bypass Function RAG\n",
    "    \n",
    "## Example Use Case\n",
    "- Helps to reduce number of functions present in LLM context for more accurate generation\n",
    "```python\n",
    "output = my_agent.run('Calculate 2**10 * (5 + 1) / 10')\n",
    "```\n",
    "`Original Function List: add_numbers, subtract_numbers, add_three_numbers, multiply_numbers, divide_numbers, power_of, GCD_of_two_numbers, modulo_of_numbers, absolute_difference, generate_poem_with_numbers, List_related_words, generate_quote`\n",
    "\n",
    "`Filtered Function Names: add_three_numbers, multiply_numbers, divide_numbers, power_of, modulo_of_numbers`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "72b4bd9f-b3b8-40e5-baec-3f41c616132a",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import math\n",
    "def sum_numbers(num_list: List[float]) -> float:\n",
    "    '''Adds all numbers in num_list'''\n",
    "    return sum(x for x in num_list)\n",
    "\n",
    "def subtract_numbers(num1: float, num2: float) -> float:\n",
    "    '''Subtracts num1 from num2'''\n",
    "    return num1 - num2\n",
    "\n",
    "def multiply_numbers(num1: float, num2: float) -> float:\n",
    "    '''Multiplies num1 by num2'''\n",
    "    return num1 * num2\n",
    "\n",
    "def divide_numbers(num1: float, num2: float) -> float:\n",
    "    '''Divides num1 by num2'''\n",
    "    if num2 == 0:\n",
    "        return -1\n",
    "    return num1/num2\n",
    "\n",
    "def power_operation(num1: float, num2: float) -> float:\n",
    "    '''Returns num1 to the power of num2 (num1**num2)'''\n",
    "    return math.pow(num1, num2)\n",
    "\n",
    "def greatest_common_divisor(num1: int, num2: int) -> int:\n",
    "    '''Returns greatest common divisor of num1 and num2'''\n",
    "    return math.gcd(num1, num2)\n",
    "\n",
    "def modulo(num1: int, num2: int) -> int:\n",
    "    '''Returns modulo of num1 over num2'''\n",
    "    return num1%num2\n",
    "\n",
    "def absolute_difference(num1: int, num2: int) -> int:\n",
    "    '''Returns absolute difference between num1 and num2'''\n",
    "    return math.abs(num1-num2)\n",
    "\n",
    "# Put this to make sum_numbers always appear for any task and bypass Function RAG\n",
    "sum_numbers = Function(external_fn = sum_numbers, is_compulsory = True)\n",
    "\n",
    "# This is for Internal Functions\n",
    "generate_poem_with_numbers = Function(\"Generates a poem containing <num1: float> and <num2: float>\", output_format = {\"Poem\": \"Poem\"}, fn_name = 'generate_poem_with_numbers', llm = llm)\n",
    "list_related_words = Function(\"Lists out <num: int> words related to <word: str>\", output_format = {\"List of words\": \"List of words, type: list\"}, fn_name = 'list_related_words', llm = llm)\n",
    "generate_quote = Function(\"Generates a quote about <topic: str>\", output_format = {\"Quote\": \"Quote\"}, fn_name = 'generate_quote', llm = llm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "3aa5ac81-b850-44ca-a812-44fbe43d9943",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_agent = Agent('Generalist Agent', \n",
    "'''Does everything''',\n",
    "                default_to_llm = False,\n",
    "                llm = llm).assign_functions([sum_numbers, subtract_numbers, multiply_numbers, \n",
    "            divide_numbers, power_operation, greatest_common_divisor, modulo, absolute_difference, \n",
    "            generate_poem_with_numbers, list_related_words, generate_quote])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b1a95964-28c6-457b-bda2-49f750013d9f",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: end_task\n",
      "Description: Passes the final output to the user\n",
      "Input: []\n",
      "Output: {}\n",
      "\n",
      "Name: sum_numbers\n",
      "Description: Adds all numbers in <num_list: list[float]>\n",
      "Input: ['num_list']\n",
      "Output: {'output_1': 'float'}\n",
      "\n",
      "Name: subtract_numbers\n",
      "Description: Subtracts <num1: float> from <num2: float>\n",
      "Input: ['num1', 'num2']\n",
      "Output: {'output_1': 'float'}\n",
      "\n",
      "Name: multiply_numbers\n",
      "Description: Multiplies <num1: float> by <num2: float>\n",
      "Input: ['num1', 'num2']\n",
      "Output: {'output_1': 'float'}\n",
      "\n",
      "Name: divide_numbers\n",
      "Description: Divides <num1: float> by <num2: float>\n",
      "Input: ['num1', 'num2']\n",
      "Output: {'output_1': 'float'}\n",
      "\n",
      "Name: power_operation\n",
      "Description: Returns <num1: float> to the power of <num2: float> (<num1: float>**<num2: float>)\n",
      "Input: ['num1', 'num2']\n",
      "Output: {'output_1': 'float'}\n",
      "\n",
      "Name: greatest_common_divisor\n",
      "Description: Returns greatest common divisor of <num1: int> and <num2: int>\n",
      "Input: ['num1', 'num2']\n",
      "Output: {'output_1': 'int'}\n",
      "\n",
      "Name: modulo\n",
      "Description: Returns modulo of <num1: int> over <num2: int>\n",
      "Input: ['num1', 'num2']\n",
      "Output: {'output_1': 'int'}\n",
      "\n",
      "Name: absolute_difference\n",
      "Description: Returns absolute difference between <num1: int> and <num2: int>\n",
      "Input: ['num1', 'num2']\n",
      "Output: {'output_1': 'int'}\n",
      "\n",
      "Name: generate_poem_with_numbers\n",
      "Description: Generates a poem containing <num1: float> and <num2: float>\n",
      "Input: ['num1', 'num2']\n",
      "Output: {'Poem': 'Poem'}\n",
      "\n",
      "Name: list_related_words\n",
      "Description: Lists out <num: int> words related to <word: str>\n",
      "Input: ['num', 'word']\n",
      "Output: {'List of words': 'List of words, type: list'}\n",
      "\n",
      "Name: generate_quote\n",
      "Description: Generates a quote about <topic: str>\n",
      "Input: ['topic']\n",
      "Output: {'Quote': 'Quote'}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# see the auto-generated names of your functions :)\n",
    "my_agent.print_functions()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "90dbed97-b966-4dff-b3b6-7beceee67e76",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Configure your top_k for function filtering here, default is 5\n",
    "my_agent.memory_bank['Function'].top_k = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "87357751-5f53-4e4b-adad-0487687d9ef4",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['modulo',\n",
       " 'subtract_numbers',\n",
       " 'multiply_numbers',\n",
       " 'divide_numbers',\n",
       " 'absolute_difference']"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# visualise how the Functions are chosen based on task - here you see subtract_numbers appearing at the front\n",
    "# this does not include the compulsory functions\n",
    "[f.fn_name for f in my_agent.memory_bank['Function'].retrieve('Evaluate 3 - 1')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "9ac84079-bb50-4fc8-83ac-167685a1b4a8",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Filtered Function Names: end_task, sum_numbers, subtract_numbers, multiply_numbers, divide_numbers, power_operation, modulo\n",
      "\u001b[1m\u001b[30mObservation: No subtasks have been completed yet for the assigned task of evaluating 2+3.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: To complete the assigned task, I need to perform the addition of the numbers 2 and 3.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: Use the sum_numbers function to add the numbers 2 and 3 together.\u001b[0m\n",
      "Calling function sum_numbers with parameters {'num_list': [2.0, 3.0]}\n",
      "> {'output_1': 5.0}\n",
      "\n",
      "Filtered Function Names: end_task, sum_numbers, subtract_numbers, multiply_numbers, divide_numbers, power_operation, modulo\n",
      "\u001b[1m\u001b[30mObservation: The sum of the numbers 2 and 3 has been successfully calculated, resulting in 5.0.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: Since the task of evaluating 2 + 3 is complete, I can now finalize the output and present it to the user.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: End Task\u001b[0m\n",
      "Task completed successfully!\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[{'output_1': 5.0}]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_agent.reset()\n",
    "my_agent.run('Evaluate 2+3')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ed842f9c-84b1-4176-9f70-e97f35e65639",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Filtered Function Names: end_task, sum_numbers, subtract_numbers, multiply_numbers, divide_numbers, power_operation, modulo\n",
      "\u001b[1m\u001b[30mObservation: No subtasks have been completed yet for the assigned task of evaluating the expression 2**10 * (3+5) / 10.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: To complete the assigned task, I need to break down the expression into manageable parts. First, I can calculate the exponentiation 2**10, then evaluate the sum (3+5), and finally perform the multiplication and division.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: Calculate 2 raised to the power of 10.\u001b[0m\n",
      "Calling function power_operation with parameters {'num1': 2.0, 'num2': 10.0}\n",
      "> {'output_1': 1024.0}\n",
      "\n",
      "Filtered Function Names: end_task, sum_numbers, subtract_numbers, multiply_numbers, divide_numbers, power_operation, modulo\n",
      "\u001b[1m\u001b[30mObservation: The power operation has been completed, calculating 2 raised to the power of 10, resulting in 1024.0.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: Next, I need to evaluate the expression (3 + 5) to get the sum, which is 8. After that, I will multiply 1024.0 by 8 and then divide the result by 10 to complete the assigned task.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: Calculate the sum of 3 and 5.\u001b[0m\n",
      "Calling function sum_numbers with parameters {'num_list': [3.0, 5.0]}\n",
      "> {'output_1': 8.0}\n",
      "\n",
      "Filtered Function Names: end_task, sum_numbers, subtract_numbers, multiply_numbers, divide_numbers, power_operation, modulo\n",
      "\u001b[1m\u001b[30mObservation: The power operation has been completed, resulting in 1024.0, and the sum of 3 and 5 has been calculated as 8.0.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: To complete the remainder of the task, I need to multiply the result of the power operation (1024.0) by the sum (8.0) and then divide that product by 10.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: Multiply 1024.0 by 8.0 and then divide the result by 10.\u001b[0m\n",
      "Calling function multiply_numbers with parameters {'num1': 1024.0, 'num2': 8.0}\n",
      "> {'output_1': 8192.0}\n",
      "\n",
      "Filtered Function Names: end_task, sum_numbers, subtract_numbers, multiply_numbers, divide_numbers, power_operation, modulo\n",
      "\u001b[1m\u001b[30mObservation: The power operation has been completed, resulting in 1024.0. The sum of 3 and 5 has been calculated as 8.0. The multiplication of 1024.0 and 8.0 has been performed, yielding 8192.0.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: The next step is to divide the result of the multiplication (8192.0) by 10 to complete the evaluation of the assigned task.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: Perform the division of 8192.0 by 10.\u001b[0m\n",
      "Calling function divide_numbers with parameters {'num1': 8192.0, 'num2': 10.0}\n",
      "> {'output_1': 819.2}\n",
      "\n",
      "Filtered Function Names: end_task, sum_numbers, subtract_numbers, multiply_numbers, divide_numbers, power_operation, modulo\n",
      "\u001b[1m\u001b[30mObservation: The task has been completed successfully by evaluating the expression 2**10 * (3+5) / 10, resulting in the final output of 819.2.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: Since the task is already completed, there is no further action required. The final output can be passed to the user.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: End Task\u001b[0m\n",
      "Task completed successfully!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "my_agent.reset()\n",
    "output = my_agent.run('Evaluate 2**10 * (3+5) / 10')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "a70c62c6-5325-47c2-a696-8b582809fcf7",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'Observation': 'No subtasks have been completed yet for the assigned task of evaluating the expression 2**10 * (3+5) / 10.',\n",
       "  'Thoughts': 'To complete the assigned task, I need to break down the expression into manageable parts. First, I can calculate the exponentiation 2**10, then evaluate the sum (3+5), and finally perform the multiplication and division.',\n",
       "  'Current Subtask': 'Calculate 2 raised to the power of 10.',\n",
       "  'Equipped Function Name': 'power_operation',\n",
       "  'Equipped Function Inputs': {'num1': 2.0, 'num2': 10.0}},\n",
       " {'Observation': 'The power operation has been completed, calculating 2 raised to the power of 10, resulting in 1024.0.',\n",
       "  'Thoughts': 'Next, I need to evaluate the expression (3 + 5) to get the sum, which is 8. After that, I will multiply 1024.0 by 8 and then divide the result by 10 to complete the assigned task.',\n",
       "  'Current Subtask': 'Calculate the sum of 3 and 5.',\n",
       "  'Equipped Function Name': 'sum_numbers',\n",
       "  'Equipped Function Inputs': {'num_list': [3.0, 5.0]}},\n",
       " {'Observation': 'The power operation has been completed, resulting in 1024.0, and the sum of 3 and 5 has been calculated as 8.0.',\n",
       "  'Thoughts': 'To complete the remainder of the task, I need to multiply the result of the power operation (1024.0) by the sum (8.0) and then divide that product by 10.',\n",
       "  'Current Subtask': 'Multiply 1024.0 by 8.0 and then divide the result by 10.',\n",
       "  'Equipped Function Name': 'multiply_numbers',\n",
       "  'Equipped Function Inputs': {'num1': 1024.0, 'num2': 8.0}},\n",
       " {'Observation': 'The power operation has been completed, resulting in 1024.0. The sum of 3 and 5 has been calculated as 8.0. The multiplication of 1024.0 and 8.0 has been performed, yielding 8192.0.',\n",
       "  'Thoughts': 'The next step is to divide the result of the multiplication (8192.0) by 10 to complete the evaluation of the assigned task.',\n",
       "  'Current Subtask': 'Perform the division of 8192.0 by 10.',\n",
       "  'Equipped Function Name': 'divide_numbers',\n",
       "  'Equipped Function Inputs': {'num1': 8192.0, 'num2': 10.0}},\n",
       " {'Observation': 'The task has been completed successfully by evaluating the expression 2**10 * (3+5) / 10, resulting in the final output of 819.2.',\n",
       "  'Thoughts': 'Since the task is already completed, there is no further action required. The final output can be passed to the user.',\n",
       "  'Current Subtask': 'Pass the final output of 819.2 to the user.',\n",
       "  'Equipped Function Name': 'end_task',\n",
       "  'Equipped Function Inputs': {}}]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_agent.thoughts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "1d0a41b3-b7ee-4763-a73f-4fbd9daaf181",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "To evaluate the expression 2**10 * (3+5) / 10, we can break it down using the subtasks completed. First, we calculate 2**10, which is the same as power_operation(num1=2.0, num2=10.0). The output from this subtask is 1024.0. Next, we need to calculate (3+5), which is 8.0, and this was obtained from the subtask sum_numbers(num_list=[3.0, 5.0]). Now we multiply the results of these two calculations: 1024.0 * 8.0. This multiplication can be found in the subtask multiply_numbers(num1=1024.0, num2=8.0), which gives us 8192.0. Finally, we divide this result by 10, as per the original expression: 8192.0 / 10. The division is represented in the subtask divide_numbers(num1=8192.0, num2=10.0), which results in 819.2. Therefore, the final result of the expression 2**10 * (3+5) / 10 is 819.2.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'To evaluate the expression 2**10 * (3+5) / 10, we can break it down using the subtasks completed. First, we calculate 2**10, which is the same as power_operation(num1=2.0, num2=10.0). The output from this subtask is 1024.0. Next, we need to calculate (3+5), which is 8.0, and this was obtained from the subtask sum_numbers(num_list=[3.0, 5.0]). Now we multiply the results of these two calculations: 1024.0 * 8.0. This multiplication can be found in the subtask multiply_numbers(num1=1024.0, num2=8.0), which gives us 8192.0. Finally, we divide this result by 10, as per the original expression: 8192.0 / 10. The division is represented in the subtask divide_numbers(num1=8192.0, num2=10.0), which results in 819.2. Therefore, the final result of the expression 2**10 * (3+5) / 10 is 819.2.'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_agent.reply_user()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "1ba75a65-7590-4552-a461-ec717d58a1f2",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agent Name: Generalist Agent\n",
      "Agent Description: Does everything\n",
      "Available Functions: ['end_task', 'sum_numbers', 'subtract_numbers', 'multiply_numbers', 'divide_numbers', 'power_operation', 'greatest_common_divisor', 'modulo', 'absolute_difference', 'generate_poem_with_numbers', 'list_related_words', 'generate_quote']\n",
      "Shared Variables: ['agent']\n",
      "\u001b[1m\u001b[32mTask: Evaluate 2**10 * (3+5) / 10\u001b[0m\n",
      "\u001b[1m\u001b[30mSubtasks Completed:\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask: power_operation(num1=2.0, num2=10.0)\u001b[0m\n",
      "{'output_1': 1024.0}\n",
      "\n",
      "\u001b[1m\u001b[34mSubtask: sum_numbers(num_list=[3.0, 5.0])\u001b[0m\n",
      "{'output_1': 8.0}\n",
      "\n",
      "\u001b[1m\u001b[34mSubtask: multiply_numbers(num1=1024.0, num2=8.0)\u001b[0m\n",
      "{'output_1': 8192.0}\n",
      "\n",
      "\u001b[1m\u001b[34mSubtask: divide_numbers(num1=8192.0, num2=10.0)\u001b[0m\n",
      "{'output_1': 819.2}\n",
      "\n",
      "\u001b[1m\u001b[34mSubtask: Evaluate 2**10 * (3+5) / 10\u001b[0m\n",
      "To evaluate the expression 2**10 * (3+5) / 10, we can break it down using the subtasks completed. First, we calculate 2**10, which is the same as power_operation(num1=2.0, num2=10.0). The output from this subtask is 1024.0. Next, we need to calculate (3+5), which is 8.0, and this was obtained from the subtask sum_numbers(num_list=[3.0, 5.0]). Now we multiply the results of these two calculations: 1024.0 * 8.0. This multiplication can be found in the subtask multiply_numbers(num1=1024.0, num2=8.0), which gives us 8192.0. Finally, we divide this result by 10, as per the original expression: 8192.0 / 10. The division is represented in the subtask divide_numbers(num1=8192.0, num2=10.0), which results in 819.2. Therefore, the final result of the expression 2**10 * (3+5) / 10 is 819.2.\n",
      "\n",
      "Is Task Completed: True\n"
     ]
    }
   ],
   "source": [
    "my_agent.status()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6260e2ee-5eae-44fb-8b70-76da88e16822",
   "metadata": {},
   "source": [
    "## Use Case 2: Adding more context based on task\n",
    "- You can add task-dependent context to the memory_bank so that `top k` will be added to prompt based on task"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6ace029-fde1-42f7-b2e2-cb34431ad9e3",
   "metadata": {},
   "source": [
    "### Using `memory_bank` for more context\n",
    "- Here, we have a mapping of nonsense words to numbers\n",
    "- Based on the subtask, we will augment the system prompt with relevant mappings to aid planning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "79cf809e-f14f-4c56-b070-87289a22df25",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# first append more context to the agent\n",
    "my_agent = Agent('Poem Creator', 'Create a poem according to a name', llm = llm)\n",
    "my_agent.memory_bank['Task Instructions'] = Memory(['For John, generate a poem about the sun', \n",
    "'For Mary, generate a poem about the wind', \n",
    "'For Peter, generate a poem about the sea'], # some task-specific instructions\n",
    "            top_k = 1,  # choose top 1\n",
    "            mapper = lambda x: x) # we compare with the task using only the first word, e.g. Azo, Boneti, Andkh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "60aa15b8-9bf5-4339-a264-11ea93157164",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[30mObservation: No subtasks have been completed yet for the task of creating a poem for John.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: To complete the task, I need to generate a poem about the sun specifically for John.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: Generate a poem about the sun for John.\u001b[0m\n",
      "Getting LLM to perform the following task: Generate a poem about the sun for John.\n",
      "> In the golden embrace of dawn, John awakens to the sun, a radiant orb that dances across the sky, casting warmth and light upon the world. The sun, a painter of the day, splashes hues of orange and pink, igniting the horizon with its fiery brush. As it climbs higher, it bathes the earth in a gentle glow, nurturing the flowers and whispering to the trees. John feels the sun’s kiss on his skin, a reminder of life’s vibrant energy, as it chases away the shadows of the night. With each passing hour, the sun reigns supreme, a steadfast companion, guiding John through the day with its unwavering presence. As evening approaches, the sun dips low, bidding farewell with a spectacular display, leaving behind a promise of return. In this celestial dance, John finds solace, knowing that the sun will always rise again, bringing hope and light to his journey.\n",
      "\n",
      "\u001b[1m\u001b[30mObservation: A poem about the sun for John has been successfully generated, capturing the essence of the sun and its impact on John’s day.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: Since the poem about the sun is complete, the next step is to finalize the task and present the poem to the user.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: End Task\u001b[0m\n",
      "Task completed successfully!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# If name is present in memory, can use this information (e.g. John -> sun)\n",
    "my_agent.reset()\n",
    "output = my_agent.run('John')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "fb0e121c-d22f-42ec-a1c7-88fbb7af44f4",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[30mObservation: No subtasks have been completed yet for the task of creating a poem about Isaac Newton.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: To complete the task, I need to generate a poem that reflects the life or contributions of Isaac Newton. Since there are no specific instructions provided for this name, I will create a general poem that captures his essence and achievements.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: Generate a poem about Isaac Newton that highlights his contributions to science and mathematics.\u001b[0m\n",
      "Getting LLM to perform the following task: Generate a poem about Isaac Newton that highlights his contributions to science and mathematics.\n",
      "> In the realm of science, a beacon so bright, Isaac Newton emerged, a true guiding light. With a mind like a comet, he soared through the skies, Unraveling mysteries, where knowledge lies. \n",
      "\n",
      "He gazed at the heavens, the stars in their dance, Formulated laws, giving nature a chance. The apple that fell, a moment profound, Gave birth to the theory of gravity found. \n",
      "\n",
      "His calculus, a marvel, a tool for the wise, Unlocking the secrets of motion and size. With each equation, he painted the world, A tapestry of numbers, in brilliance unfurled. \n",
      "\n",
      "From optics he ventured, with prisms in hand, Revealing the spectrum, a colorful band. Light's nature he pondered, its waves and its rays, Illuminating paths through the scientific maze. \n",
      "\n",
      "In the realm of alchemy, he sought the divine, A quest for the philosopher's stone, a grand design. Though gold was elusive, his insights were clear, Transforming our understanding, year after year. \n",
      "\n",
      "So here’s to Newton, a titan of thought, Whose legacy lingers in all that he taught. A poet of science, with wisdom so vast, His contributions to knowledge forever will last.\n",
      "\n",
      "\u001b[1m\u001b[30mObservation: A poem about Isaac Newton has been successfully generated, highlighting his contributions to science and mathematics.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: Since the poem is complete, the next step is to finalize the output and present it to the user.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: End Task\u001b[0m\n",
      "Task completed successfully!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# If the name is not in the memory, it will be interpreted according to the actual input\n",
    "my_agent.reset()\n",
    "output = my_agent.run('Isaac Newton')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cb509e2",
   "metadata": {},
   "source": [
    "## Use Case 3: Add memory directly using pdf, docx, csv, xls files\n",
    "Adding memory elements one by one can be cumbersome, AgentJo memory can take filepath as input and it will split the text content inside the file path either using default splitter or user provided splitter.\n",
    "\n",
    "- We currently support `pdf`, `docx`, `csv`, `xls` files\n",
    "- You can also input own `text_splitter` function which takes in text and returns a list of splitted text by that function. Default: LangChain's RecursiveCharacterTextSplitter\n",
    "- We recommend the async method for faster accessing of memory\n",
    "\n",
    "Example:\n",
    "\n",
    "`memory = Memory(top_k = 5)`\n",
    "\n",
    "`memory.add_file(file_path)`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "829dbc54",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# ## Run the sync version of add_file (Takes very long)\n",
    "\n",
    "# import time\n",
    "\n",
    "# start_time = time.time()\n",
    "# memory = Memory(top_k = 1)\n",
    "# memory.add_file(filepath=\"./react.pdf\")\n",
    "# memory.retrieve('What is react')\n",
    "\n",
    "# end_time = time.time()\n",
    "# print(\"Time taken to run the code:\", end_time - start_time, \"seconds\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "d697ee92",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time taken to run the code: 7.076565980911255 seconds\n"
     ]
    }
   ],
   "source": [
    "# Async version of memory (Faster)\n",
    "import time\n",
    "\n",
    "start_time = time.time()\n",
    "async_memory = AsyncMemory(top_k = 3)\n",
    "async_memory.add_file(filepath=\"./react.pdf\")\n",
    "await async_memory.retrieve('What is react')\n",
    "\n",
    "end_time = time.time()\n",
    "print(\"Time taken to run the code:\", end_time - start_time, \"seconds\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "d457badb-ffba-42c8-8e38-c7c1876243c7",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "async def llm_async(system_prompt: str, user_prompt: str):\n",
    "    ''' Here, we use OpenAI for illustration, you can change it to your own LLM '''\n",
    "    # ensure your LLM imports are all within this function\n",
    "    from openai import AsyncOpenAI\n",
    "    \n",
    "    # define your own LLM here\n",
    "    client = AsyncOpenAI()\n",
    "    response = await client.chat.completions.create(\n",
    "        model='gpt-4o-mini',\n",
    "        temperature = 0,\n",
    "        messages=[\n",
    "            {\"role\": \"system\", \"content\": system_prompt},\n",
    "            {\"role\": \"user\", \"content\": user_prompt}\n",
    "        ]\n",
    "    )\n",
    "    return response.choices[0].message.content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "1ed211d2-fedf-4172-a7c3-5f3c3b3d3513",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Equip this memory to the Agent and use it to answer a question\n",
    "agent = AsyncAgent('Content Answerer', 'Replies to questions factually based on given memory', llm = llm_async)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "9253c639-df16-4479-8ad6-601b4a091563",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "agent.memory_bank['Document'] = async_memory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "7b435042-51d7-4c0a-9398-28da4dd327d0",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['.\\nIn contrast to these methods, ReAct performs more than just isolated, ﬁxed reasoning, and integrates\\nmodel actions and their corresponding observations into a coherent stream of inputs for the model to\\nreason more accurately and tackle tasks beyond reasoning (e.g. interactive decision making)',\n",
       " 'space and thought-action occurrence format, ReAct works for diverse tasks with distinct action\\nspaces and reasoning needs, including but not limited to QA, fact veriﬁcation, text game, and web\\nnavigation. C) Performant and robust :ReAct shows strong generalization to new task instances\\nwhile learning solely from one to six in-context examples, consistently outperforming baselines with\\nonly reasoning or acting across different domains. We also show in Section 3 additional beneﬁts',\n",
       " '.\\nIn this work, we present ReAct , a general paradigm to combine reasoning and acting with language\\nmodels for solving diverse language reasoning and decision making tasks (Figure 1). ReAct\\nprompts LLMs to generate both verbal reasoning traces and actions pertaining to a task in an\\ninterleaved manner, which allows the model to perform dynamic reasoning to create, maintain, and\\nadjust high-level plans for acting (reason to act), while also interact with the external environments']"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "await async_memory.retrieve('What is ReAct?')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "5433055b-ac0c-416e-b2f8-20f9a76ce0c1",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[30mObservation: No subtasks have been completed yet for the assigned task of explaining ReAct. However, I have gathered relevant information about ReAct, including its definition and applications in reasoning and decision-making tasks.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: To complete the remainder of the assigned task, I need to synthesize the gathered information into a coherent explanation of ReAct, highlighting its purpose, functionality, and advantages.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: Generate a concise and informative response that explains what ReAct is, incorporating the gathered knowledge about its integration of reasoning and acting, its applications, and its performance.\u001b[0m\n",
      "Getting LLM to perform the following task: Generate a concise and informative response that explains what ReAct is, incorporating the gathered knowledge about its integration of reasoning and acting, its applications, and its performance.\n",
      "> ReAct is a novel paradigm designed to integrate reasoning and acting within language models, enabling them to tackle a variety of language reasoning and decision-making tasks effectively. Unlike traditional methods that rely on isolated reasoning, ReAct allows models to generate both verbal reasoning traces and corresponding actions in an interleaved manner. This dynamic approach facilitates the creation, maintenance, and adjustment of high-level plans for action, thereby enhancing the model’s ability to interact with external environments. ReAct is versatile, applicable to diverse tasks such as question answering, fact verification, text games, and web navigation. Its performance is robust, demonstrating strong generalization to new task instances with minimal in-context examples, consistently outperforming baseline models that focus solely on reasoning or acting across various domains. This integration of reasoning and acting not only improves accuracy but also expands the model's capabilities beyond mere reasoning, making it a powerful tool for interactive decision-making.\n",
      "\n",
      "\u001b[1m\u001b[30mObservation: A comprehensive explanation of ReAct has been generated, detailing its integration of reasoning and acting, its applications in various tasks, and its performance advantages over traditional methods.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: Since the explanation of ReAct is already complete, the next step is to finalize the task and provide the output to the user.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: End Task\u001b[0m\n",
      "Task completed successfully!\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[\"ReAct is a novel paradigm designed to integrate reasoning and acting within language models, enabling them to tackle a variety of language reasoning and decision-making tasks effectively. Unlike traditional methods that rely on isolated reasoning, ReAct allows models to generate both verbal reasoning traces and corresponding actions in an interleaved manner. This dynamic approach facilitates the creation, maintenance, and adjustment of high-level plans for action, thereby enhancing the model’s ability to interact with external environments. ReAct is versatile, applicable to diverse tasks such as question answering, fact verification, text games, and web navigation. Its performance is robust, demonstrating strong generalization to new task instances with minimal in-context examples, consistently outperforming baseline models that focus solely on reasoning or acting across various domains. This integration of reasoning and acting not only improves accuracy but also expands the model's capabilities beyond mere reasoning, making it a powerful tool for interactive decision-making.\"]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "await agent.run('What is ReAct?')"
   ]
  }
 ],
 "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.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}