Tutorial 1 - Agent.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "28aa7e46-feca-4d00-af73-9a91165b4a0b",
   "metadata": {},
   "source": [
    "# Tutorial 1: Agents\n",
    "- Video: https://www.youtube.com/watch?v=twG08FeX1xs\n",
    "\n",
    "## Functionalities:\n",
    "- Task-based Agents which will break down tasks into subtasks and solve them in bite-sized portions\n",
    "- Agents with registered functions as skills"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd14d526-e68f-4657-9f94-838a890ad7ab",
   "metadata": {},
   "source": [
    "# Setup Guide"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "633b0fe6-7a3a-4d58-97e8-c0719f09662c",
   "metadata": {},
   "source": [
    "## Step 1: Install AgentJo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "bcf706f0-ded6-4031-a0dd-31f954dc97e8",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# !pip install agentjo"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c3118e0-c10e-469d-8a8f-99f8820c33e3",
   "metadata": {},
   "source": [
    "## Step 2: Import required functions and setup relevant API keys for your LLM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "03fc8ddf-e44d-4dce-b5c3-34b47a0ca2ef",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Set up API key and do the necessary imports\n",
    "from agentjo import *\n",
    "import os\n",
    "\n",
    "# this is only if you use OpenAI as your LLM\n",
    "os.environ['OPENAI_API_KEY'] = '<YOUR API KEY HERE>'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72e048af-8d9c-49a6-8896-908709eaeb00",
   "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": 4,
   "id": "a6d8f0ef-76c5-4508-8dba-e81932714bde",
   "metadata": {
    "tags": []
   },
   "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": 5,
   "id": "5f022dd4-0027-416e-b9c8-15a80eb0a80c",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Neutral'"
      ]
     },
     "execution_count": 5,
     "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": "e2b7f892-eb78-49c1-96db-e553ac2d6727",
   "metadata": {
    "tags": []
   },
   "source": [
    "# 1. Agent Basics\n",
    "- Create an agent by entering your agent's name and description\n",
    "- Agents are task-based, so they will help generate subtasks to fulfil your main task\n",
    "\n",
    "- Agents are made to be non-verbose, so they will just focus only on task instruction (Much more efficient compared to conversational-based agentic frameworks like AutoGen)\n",
    "- Agent's interactions will be stored into `subtasks_completed` by default, which will serve as a memory buffer for future interactions\n",
    "\n",
    "- **Inputs for Agent**:\n",
    "    - **agent_name**: String. Name of agent, hinting at what the agent does\n",
    "    - **agent_description**: String. Short description of what the agent does\n",
    "    - **max_subtasks**: Int. Default: 5. The maximum number of subtasks the agent can have\n",
    "    - **verbose**: Bool. Default: True. Whether to print out agent's intermediate thoughts\n",
    "    - **llm**: Function. The LLM to be used by the Agent\n",
    "<br/><br/>\n",
    "\n",
    "- **Agent Internal Parameters**:\n",
    "    - **Task**: String. The task the agent has been assigned to - Defaults to \"No task assigned\"\n",
    "    - **Subtasks Completed**: Dict. The keys are the subtask names and the values are the result of the respective subtask\n",
    "    - **Is Task Completed**: Bool. Whether the current Task is completed\n",
    "<br/><br/>\n",
    "\n",
    "- **Task Running**\n",
    "    - **reset()**: Resets the Agent Internal Parameters and Subtasks Completed. You should do this at the start of every new task assigned to the Agent to minimise potential confusion of what has been done for this task versus previous tasks\n",
    "    - **run(task: str, num_subtasks: int = max_subtasks)**: Performs the task. Do note that agent's state will not be reset, so if you want to reset it, call reset() prior to running this. Runs the task for **num_subtasks** steps. If not specified, we will take the **max_subtasks**.\n",
    "<br/><br/>\n",
    "\n",
    "- **Give User Output**\n",
    "    - **reply_user(query: str = '', stateful: bool = True)**: Using all information from subtasks, give a reply about the `query` to the user. If `query` is not given, then it replies based on the current task the agent is doing. If `stateful` is True, saves this query and reply into `subtasks_completed`\n",
    "<br/><br/>\n",
    "\n",
    "     - **answer(query, output_format = {'Answer': 'Concise Answer'})**: Using all information from subtasks, give a reply about the `query` to the user. Answers in the given `output_format`\n",
    "<br/><br/>\n",
    "\n",
    "    \n",
    "- **Check status of Agent**:\n",
    "    - **status()**: Lists out Agent Name, Agent Description, Available Functions (default function is to use the LLM), Task, Subtasks Completed and Is Task Completed\n",
    "    \n",
    "## Example Agent Creation\n",
    "```python\n",
    "my_agent = Agent('Helpful assistant', 'You are a generalist agent')\n",
    "```\n",
    "\n",
    "## Example Agent Task Running - Split the assigned task into subtasks and execute each of them\n",
    "\n",
    "```python\n",
    "output = my_agent.run('Give me 5 words rhyming with cool, and make a 4-sentence poem using them')\n",
    "```\n",
    "\n",
    "`Subtask identified: Find 5 words that rhyme with 'cool'`\n",
    "\n",
    "`Getting LLM to perform the following task: Find 5 words that rhyme with 'cool'`\n",
    "> pool, rule, fool, tool, school\n",
    "\n",
    "`Subtask identified: Compose a 4-sentence poem using the words 'pool', 'rule', 'fool', 'tool', and 'school'`\n",
    "\n",
    "`Getting LLM to perform the following task: Compose a 4-sentence poem using the words 'pool', 'rule', 'fool', 'tool', and 'school'`\n",
    "> In the school, the golden rule is to never be a fool. Use your mind as a tool, and always follow the pool.\n",
    "\n",
    "`Task completed successfully!`\n",
    "\n",
    "## Check Agent's Status\n",
    "```python\n",
    "my_agent.status()\n",
    "```\n",
    "\n",
    "`Agent Name: Helpful assistant`\n",
    "\n",
    "`Agent Description: You are a generalist agent`\n",
    "\n",
    "`Available Functions: ['use_llm', 'end_task']`\n",
    "\n",
    "`Task: Give me 5 words rhyming with cool, and make a 4-sentence poem using them`\n",
    "\n",
    "`Subtasks Completed:`\n",
    "\n",
    "`Subtask: Find 5 words that rhyme with 'cool'`\n",
    "\n",
    "`pool, rule, fool, tool, school`\n",
    "\n",
    "`Subtask: Compose a 4-sentence poem using the words 'pool', 'rule', 'fool', 'tool', and 'school'`\n",
    "\n",
    "`In the school, the golden rule is to never be a fool. Use your mind as a tool, and always follow the pool.`\n",
    "\n",
    "`Is Task Completed: True`\n",
    "\n",
    "## Example Agent Reply to User - Reference the subtasks' output to answer the user's query\n",
    "```python\n",
    "output = my_agent.reply_user()\n",
    "```\n",
    "\n",
    "`\n",
    "Here are 5 words that rhyme with \"cool\": pool, rule, fool, tool, school. Here is a 4-sentence poem using these words: \"In the school, the golden rule is to never be a fool. Use your mind as a tool, and always follow the pool.\"\n",
    "`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15f83723-ad19-4422-9826-81a3a734dc2b",
   "metadata": {},
   "source": [
    "## Create Agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5993aad2-112d-4952-bfcd-43a71c7e2cb3",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Create your agent by specifying name and description\n",
    "my_agent = Agent('Helpful assistant', 'You are a generalist agent', llm = llm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "89cc5918-5bd4-468c-8ff9-b4449e050c22",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agent Name: Helpful assistant\n",
      "Agent Description: You are a generalist agent\n",
      "Available Functions: ['use_llm', 'end_task']\n",
      "Shared Variables: ['agent']\n",
      "\u001b[1m\u001b[32mTask: No task assigned\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtasks Completed: None\u001b[0m\n",
      "Is Task Completed: False\n"
     ]
    }
   ],
   "source": [
    "# Show the agent status - By default agent comes equipped with default function `use_llm` which queries the llm\n",
    "# end_task is to end the current task if it is completed\n",
    "my_agent.status()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a4fa06e-f2a6-4405-a0f6-f7ec51a6a84e",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Automatic Running of Task"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "2e86738a-05d0-4e04-a2f0-1b7c29d0b729",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[30mObservation: No subtasks have been completed yet for the assigned task of generating rhyming words and a poem.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: To complete the assigned task, I need to first generate five words that rhyme with \"cool\". Once I have those words, I can then create a four-sentence poem using them.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: Generate five words that rhyme with \"cool\".\u001b[0m\n",
      "Getting LLM to perform the following task: Generate five words that rhyme with \"cool\".\n",
      "> The five words that rhyme with \"cool\" are: 1. School, 2. Pool, 3. Tool, 4. Fool, 5. Rule. These words share the same ending sound as \"cool,\" making them perfect rhymes. Each word can be used in various contexts, such as \"school\" referring to an educational institution, \"pool\" as a recreational water area, \"tool\" indicating an instrument for work, \"fool\" describing a person who acts unwisely, and \"rule\" denoting a guideline or principle.\n",
      "\n",
      "\u001b[1m\u001b[30mObservation: Five words that rhyme with \"cool\" have been successfully generated: school, pool, tool, fool, and rule. Each word has been contextualized to show its meaning and usage.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: The next step is to create a four-sentence poem using the rhyming words provided. I can combine these words creatively to form a cohesive and engaging poem.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: Compose a four-sentence poem that incorporates the words school, pool, tool, fool, and rule, ensuring that each word is used meaningfully within the context of the poem.\u001b[0m\n",
      "Getting LLM to perform the following task: Compose a four-sentence poem that incorporates the words school, pool, tool, fool, and rule, ensuring that each word is used meaningfully within the context of the poem.\n",
      "> In a bright and lively school, where laughter is the rule,  \n",
      "Children gather by the pool, splashing like a playful fool.  \n",
      "With every game, they find a tool, to build their dreams and break the mold,  \n",
      "Creating memories, precious and cool, as stories of their youth unfold.\n",
      "\n",
      "\u001b[1m\u001b[30mObservation: The task of generating five rhyming words with \"cool\" has been successfully completed, along with a four-sentence poem that incorporates those words meaningfully.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: Since the assigned task has been fully completed, 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": [
    "# Do the task by subtasks. This does generation to fulfil task\n",
    "my_agent.reset()\n",
    "output = my_agent.run('Give me 5 words rhyming with cool, and then make a 4-sentence poem using them')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "afe503c9-ad37-4962-8099-8d62b7844692",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['The five words that rhyme with \"cool\" are: 1. School, 2. Pool, 3. Tool, 4. Fool, 5. Rule. These words share the same ending sound as \"cool,\" making them perfect rhymes. Each word can be used in various contexts, such as \"school\" referring to an educational institution, \"pool\" as a recreational water area, \"tool\" indicating an instrument for work, \"fool\" describing a person who acts unwisely, and \"rule\" denoting a guideline or principle.', 'In a bright and lively school, where laughter is the rule,  \\nChildren gather by the pool, splashing like a playful fool.  \\nWith every game, they find a tool, to build their dreams and break the mold,  \\nCreating memories, precious and cool, as stories of their youth unfold.']\n"
     ]
    }
   ],
   "source": [
    "# visualise the subtask outputs of the task\n",
    "print(output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "b5d4c3a7-5ded-4eea-bf36-5120c885de2b",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agent Name: Helpful assistant\n",
      "Agent Description: You are a generalist agent\n",
      "Available Functions: ['use_llm', 'end_task']\n",
      "Shared Variables: ['agent']\n",
      "\u001b[1m\u001b[32mTask: Give me 5 words rhyming with cool, and then make a 4-sentence poem using them\u001b[0m\n",
      "\u001b[1m\u001b[30mSubtasks Completed:\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask: Generate five words that rhyme with \"cool\".\u001b[0m\n",
      "The five words that rhyme with \"cool\" are: 1. School, 2. Pool, 3. Tool, 4. Fool, 5. Rule. These words share the same ending sound as \"cool,\" making them perfect rhymes. Each word can be used in various contexts, such as \"school\" referring to an educational institution, \"pool\" as a recreational water area, \"tool\" indicating an instrument for work, \"fool\" describing a person who acts unwisely, and \"rule\" denoting a guideline or principle.\n",
      "\n",
      "\u001b[1m\u001b[34mSubtask: Compose a four-sentence poem that incorporates the words school, pool, tool, fool, and rule, ensuring that each word is used meaningfully within the context of the poem.\u001b[0m\n",
      "In a bright and lively school, where laughter is the rule,  \n",
      "Children gather by the pool, splashing like a playful fool.  \n",
      "With every game, they find a tool, to build their dreams and break the mold,  \n",
      "Creating memories, precious and cool, as stories of their youth unfold.\n",
      "\n",
      "Is Task Completed: True\n"
     ]
    }
   ],
   "source": [
    "# see the updated agent status\n",
    "my_agent.status()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "79a8a4ba-3375-4ff0-9057-b3073420ed00",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The five words that rhyme with \"cool\" are: 1. School, 2. Pool, 3. Tool, 4. Fool, 5. Rule. These words share the same ending sound as \"cool,\" making them perfect rhymes. Each word can be used in various contexts, such as \"school\" referring to an educational institution, \"pool\" as a recreational water area, \"tool\" indicating an instrument for work, \"fool\" describing a person who acts unwisely, and \"rule\" denoting a guideline or principle. \n",
      "\n",
      "Here is a four-sentence poem incorporating these words: \n",
      "In a bright and lively school, where laughter is the rule,  \n",
      "Children gather by the pool, splashing like a playful fool.  \n",
      "With every game, they find a tool, to build their dreams and break the mold,  \n",
      "Creating memories, precious and cool, as stories of their youth unfold.\n"
     ]
    }
   ],
   "source": [
    "# Generates a meaningful reply to the user about the task according to its current state. Functions like a QA bot\n",
    "# The reply will go into subtasks_completed to store the conversation with the user for future context\n",
    "output = my_agent.reply_user()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "e1cbbce6-27b4-47f4-afc1-08e763de82fa",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The pool is mentioned in the context of a lively school where children gather to splash and play. It serves as a recreational area for the children, providing a space for fun and enjoyment. The poem describes the pool as a place where laughter is abundant, and children engage in playful activities, highlighting its importance in their school experience.\n"
     ]
    }
   ],
   "source": [
    "# You can also ask your questions to the agent, and the agent will reply according to its current state. Functions like a QA bot\n",
    "# Here, we set stateful is false because we do not want this to go into subtasks_completed\n",
    "output = my_agent.reply_user('Where is the pool?', stateful = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "d5b6b2b9-4d8a-47ec-a190-819de5e3f051",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agent Name: Helpful assistant\n",
      "Agent Description: You are a generalist agent\n",
      "Available Functions: ['use_llm', 'end_task']\n",
      "Shared Variables: ['agent']\n",
      "\u001b[1m\u001b[32mTask: Give me 5 words rhyming with cool, and then make a 4-sentence poem using them\u001b[0m\n",
      "\u001b[1m\u001b[30mSubtasks Completed:\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask: Generate five words that rhyme with \"cool\".\u001b[0m\n",
      "The five words that rhyme with \"cool\" are: 1. School, 2. Pool, 3. Tool, 4. Fool, 5. Rule. These words share the same ending sound as \"cool,\" making them perfect rhymes. Each word can be used in various contexts, such as \"school\" referring to an educational institution, \"pool\" as a recreational water area, \"tool\" indicating an instrument for work, \"fool\" describing a person who acts unwisely, and \"rule\" denoting a guideline or principle.\n",
      "\n",
      "\u001b[1m\u001b[34mSubtask: Compose a four-sentence poem that incorporates the words school, pool, tool, fool, and rule, ensuring that each word is used meaningfully within the context of the poem.\u001b[0m\n",
      "In a bright and lively school, where laughter is the rule,  \n",
      "Children gather by the pool, splashing like a playful fool.  \n",
      "With every game, they find a tool, to build their dreams and break the mold,  \n",
      "Creating memories, precious and cool, as stories of their youth unfold.\n",
      "\n",
      "\u001b[1m\u001b[34mSubtask: Give me 5 words rhyming with cool, and then make a 4-sentence poem using them\u001b[0m\n",
      "The five words that rhyme with \"cool\" are: 1. School, 2. Pool, 3. Tool, 4. Fool, 5. Rule. These words share the same ending sound as \"cool,\" making them perfect rhymes. Each word can be used in various contexts, such as \"school\" referring to an educational institution, \"pool\" as a recreational water area, \"tool\" indicating an instrument for work, \"fool\" describing a person who acts unwisely, and \"rule\" denoting a guideline or principle. \n",
      "\n",
      "Here is a four-sentence poem incorporating these words: \n",
      "In a bright and lively school, where laughter is the rule,  \n",
      "Children gather by the pool, splashing like a playful fool.  \n",
      "With every game, they find a tool, to build their dreams and break the mold,  \n",
      "Creating memories, precious and cool, as stories of their youth unfold.\n",
      "\n",
      "Is Task Completed: True\n"
     ]
    }
   ],
   "source": [
    "# see the updated agent status\n",
    "my_agent.status()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "b34cc9ef-950e-4ddf-90eb-5b764005c9e3",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: use_llm\n",
      "Description: For general tasks. Used only when no other function can do the task\n",
      "Input: []\n",
      "Output: {'Output': 'Output of LLM'}\n",
      "\n",
      "Name: end_task\n",
      "Description: Passes the final output to the user\n",
      "Input: []\n",
      "Output: {}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "my_agent.print_functions()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "e449c92b-6f85-487f-a4e2-7fff4c06bd69",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_agent.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "634f9a23-94e8-4d8a-a3f3-2df5679a38a9",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agent Name: Helpful assistant\n",
      "Agent Description: You are a generalist agent\n",
      "Available Functions: ['use_llm', 'end_task']\n",
      "Shared Variables: ['agent']\n",
      "\u001b[1m\u001b[32mTask: No task assigned\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtasks Completed: None\u001b[0m\n",
      "Is Task Completed: False\n"
     ]
    }
   ],
   "source": [
    "my_agent.status()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "594b2d07-31fd-47b2-ad81-937f6227f27c",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[30mObservation: No subtasks have been completed yet for the assigned task of generating rhyming words and a poem.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: To complete the assigned task, I need to first find five words that rhyme with \"task\". Once I have those words, I can then create a four-sentence poem using them.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: Identify five words that rhyme with \"task\" to fulfill the first part of the assigned task.\u001b[0m\n",
      "Getting LLM to perform the following task: Identify five words that rhyme with \"task\" to fulfill the first part of the assigned task.\n",
      "> To fulfill the assigned subtask of identifying five words that rhyme with \"task,\" I analyzed the phonetic structure of the word. The ending sound of \"task\" is crucial for finding suitable rhymes. After considering various options, I identified the following five words that rhyme with \"task\": \"mask,\" \"flask,\" \"brask,\" \"ask,\" and \"cask.\" Each of these words shares the same ending sound, making them perfect rhymes for \"task.\" This outcome not only meets the requirement of the subtask but also provides a variety of options that can be useful in different contexts, such as poetry, songwriting, or word games.\n",
      "\n",
      "\u001b[1m\u001b[30mObservation: I have successfully identified five words that rhyme with \"task\": \"mask,\" \"flask,\" \"brask,\" \"ask,\" and \"cask.\" This completes the first part of the assigned task.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: Now, I need to create a 4-sentence poem using the identified rhyming words. I can brainstorm a theme or scenario that incorporates these words effectively.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: Compose a 4-sentence poem using the words \"mask,\" \"flask,\" \"brask,\" \"ask,\" and \"cask.\" The poem should creatively integrate these words while maintaining a coherent theme.\u001b[0m\n",
      "Getting LLM to perform the following task: Compose a 4-sentence poem using the words \"mask,\" \"flask,\" \"brask,\" \"ask,\" and \"cask.\" The poem should creatively integrate these words while maintaining a coherent theme.\n",
      "> In the dim light, a mask hides the face, \n",
      "While a flask holds secrets, a hidden embrace. \n",
      "With a brask of laughter, we gather and ask, \n",
      "What treasures await in the old wooden cask?\n",
      "\n",
      "\u001b[1m\u001b[30mObservation: I have successfully identified five words that rhyme with \"task\": \"mask,\" \"flask,\" \"brask,\" \"ask,\" and \"cask.\" Additionally, I have composed a coherent 4-sentence poem using these words, creatively integrating them into a thematic narrative.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: Since the assigned task has been fully completed, there is no further action required. The task of providing rhyming words and composing a poem has been fulfilled.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: End Task\u001b[0m\n",
      "Task completed successfully!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# when you change the task, we will set the task completed to False so you can do it again. \n",
    "# Do note that the earlier subtasks_history might affect your new task and should be reset if it is not relevant\n",
    "my_agent.reset()\n",
    "output = my_agent.run('Give me 5 words rhyming with task, and then make a 4-sentence poem using them')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "038ee3e2-0c08-470f-adec-2179f2adc63e",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agent Name: Helpful assistant\n",
      "Agent Description: You are a generalist agent\n",
      "Available Functions: ['use_llm', 'end_task']\n",
      "Shared Variables: ['agent']\n",
      "\u001b[1m\u001b[32mTask: Give me 5 words rhyming with task, and then make a 4-sentence poem using them\u001b[0m\n",
      "\u001b[1m\u001b[30mSubtasks Completed:\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask: Identify five words that rhyme with \"task\" to fulfill the first part of the assigned task.\u001b[0m\n",
      "To fulfill the assigned subtask of identifying five words that rhyme with \"task,\" I analyzed the phonetic structure of the word. The ending sound of \"task\" is crucial for finding suitable rhymes. After considering various options, I identified the following five words that rhyme with \"task\": \"mask,\" \"flask,\" \"brask,\" \"ask,\" and \"cask.\" Each of these words shares the same ending sound, making them perfect rhymes for \"task.\" This outcome not only meets the requirement of the subtask but also provides a variety of options that can be useful in different contexts, such as poetry, songwriting, or word games.\n",
      "\n",
      "\u001b[1m\u001b[34mSubtask: Compose a 4-sentence poem using the words \"mask,\" \"flask,\" \"brask,\" \"ask,\" and \"cask.\" The poem should creatively integrate these words while maintaining a coherent theme.\u001b[0m\n",
      "In the dim light, a mask hides the face, \n",
      "While a flask holds secrets, a hidden embrace. \n",
      "With a brask of laughter, we gather and ask, \n",
      "What treasures await in the old wooden cask?\n",
      "\n",
      "Is Task Completed: True\n"
     ]
    }
   ],
   "source": [
    "# see the updated agent staus\n",
    "my_agent.status()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "0e16e821-a564-4ae4-96f1-b8318f54386f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Words': ['mask', 'flask', 'brask', 'ask', 'cask'],\n",
       " 'Words and their meaning': {'mask': 'a covering for all or part of the face',\n",
       "  'flask': 'a container for liquids, typically with a narrow neck',\n",
       "  'brask': 'a term used in some dialects, often referring to a lively or boisterous person',\n",
       "  'ask': 'to request information or an answer',\n",
       "  'cask': 'a barrel-shaped container, typically used for storing liquids'}}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# possible to ask a query and get an answer in structured format\n",
    "my_agent.answer(\"What are the five words\", \n",
    "                output_format = {\"Words\": \"type: list\", \n",
    "                 \"Words and their meaning\": \"type: dict\"})"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab96ab55-5749-4338-9a8f-f21fb6be1c85",
   "metadata": {},
   "source": [
    "## Running of Task Step by Step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "a38366c2-1467-4de8-bb41-144ecbdbcf0d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Create your agent by specifying name and description\n",
    "my_agent = Agent('Number Expert', 'You are great with numbers', llm = llm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "e3b7d66b-f3a3-4139-948a-56badd9638cc",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[30mObservation: No subtasks have been completed yet for the assigned task of listing three random numbers and calculating their sum.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: To complete the assigned task, I need to generate three random numbers between 1 and 50 and then calculate their sum.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: Generate three random numbers from 1 to 50 and calculate their sum.\u001b[0m\n",
      "Getting LLM to perform the following task: Generate three random numbers from 1 to 50 and calculate their sum.\n",
      "> I generated three random numbers from the range of 1 to 50. The numbers selected are 12, 27, and 35. To find their sum, I added these numbers together: 12 + 27 + 35 = 74. Therefore, the sum of the three random numbers is 74.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Runs a task for 1 step by editing num_subtasks variable to 1\n",
    "output = my_agent.run('List me three random numbers from 1 to 50, then give me their sum', num_subtasks = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "582dd4a0-b666-42a3-90c6-d5fa47007a75",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['I generated three random numbers from the range of 1 to 50. The numbers selected are 12, 27, and 35. To find their sum, I added these numbers together: 12 + 27 + 35 = 74. Therefore, the sum of the three random numbers is 74.']\n"
     ]
    }
   ],
   "source": [
    "# visualise the outputs of the task at the subtask level\n",
    "print(output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "4c898f28-c34a-4414-a57a-900471388006",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agent Name: Number Expert\n",
      "Agent Description: You are great with numbers\n",
      "Available Functions: ['use_llm', 'end_task']\n",
      "Shared Variables: ['agent']\n",
      "\u001b[1m\u001b[32mTask: List me three random numbers from 1 to 50, then give me their sum\u001b[0m\n",
      "\u001b[1m\u001b[30mSubtasks Completed:\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask: Generate three random numbers from 1 to 50 and calculate their sum.\u001b[0m\n",
      "I generated three random numbers from the range of 1 to 50. The numbers selected are 12, 27, and 35. To find their sum, I added these numbers together: 12 + 27 + 35 = 74. Therefore, the sum of the three random numbers is 74.\n",
      "\n",
      "Is Task Completed: False\n"
     ]
    }
   ],
   "source": [
    "# Visualise the first subtask\n",
    "my_agent.status()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "92dca0bf-5b84-4011-89ca-c3ce48648efe",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[30mObservation: I have generated three random numbers: 12, 27, and 35, and calculated their sum to be 74.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: The Assigned Task is now complete as I have provided both the three random numbers and their sum.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: End Task\u001b[0m\n",
      "Task completed successfully!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Runs the task for another step\n",
    "output = my_agent.run('List me three random numbers from 1 to 50, then give me their sum', num_subtasks = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "913af15e-c395-4579-a0b8-c369e43f12c3",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['I generated three random numbers from the range of 1 to 50. The numbers selected are 12, 27, and 35. To find their sum, I added these numbers together: 12 + 27 + 35 = 74. Therefore, the sum of the three random numbers is 74.']\n"
     ]
    }
   ],
   "source": [
    "# visualise the outputs of the task at the subtask level\n",
    "print(output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "c8e89a05-51f2-4801-82d2-1d184f43697a",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agent Name: Number Expert\n",
      "Agent Description: You are great with numbers\n",
      "Available Functions: ['use_llm', 'end_task']\n",
      "Shared Variables: ['agent']\n",
      "\u001b[1m\u001b[32mTask: List me three random numbers from 1 to 50, then give me their sum\u001b[0m\n",
      "\u001b[1m\u001b[30mSubtasks Completed:\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask: Generate three random numbers from 1 to 50 and calculate their sum.\u001b[0m\n",
      "I generated three random numbers from the range of 1 to 50. The numbers selected are 12, 27, and 35. To find their sum, I added these numbers together: 12 + 27 + 35 = 74. Therefore, the sum of the three random numbers is 74.\n",
      "\n",
      "Is Task Completed: True\n"
     ]
    }
   ],
   "source": [
    "# Visualise the first and second subtasks\n",
    "my_agent.status()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "1ce7cc99-f460-444b-a243-acf09535629d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[30mObservation: I generated three random numbers from the range of 1 to 50: 12, 27, and 35, and calculated their sum to be 74.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: The Assigned Task is now complete as I have provided both the three random numbers and their sum.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: End Task\u001b[0m\n",
      "Task completed successfully!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# if task already completed, then no need to do further\n",
    "output = my_agent.run('List me three random numbers from 1 to 50, then give me their sum', num_subtasks = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "d6397200-ee22-4e96-b002-4d65115f5b9b",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I generated three random numbers from the range of 1 to 50. The numbers selected are 12, 27, and 35. To find their sum, I added these numbers together: 12 + 27 + 35 = 74. Therefore, the three random numbers are 12, 27, and 35, and their sum is 74.\n"
     ]
    }
   ],
   "source": [
    "# Generates a meaningful reply to the user\n",
    "output = my_agent.reply_user()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "746bd68c-34e2-4a3c-af10-668e703c8a25",
   "metadata": {
    "tags": []
   },
   "source": [
    "# 2. Power Up your Agents - Bring in Functions (aka Tools)\n",
    "- First define the functions, either using class `Function` (see Tutorial 0), or just any Python function with input and output types defined in the signature and with a docstring\n",
    "- After creating your agent, use `assign_functions` to assign a list of functions of class `Function`, or general Python functions (which will be converted to AsyncFunction)\n",
    "- Function names will be automatically inferred if not specified\n",
    "- Proceed to run tasks by using `run()`\n",
    "\n",
    "```python\n",
    "# This is an example of an LLM-based function (see Tutorial 0)\n",
    "sentence_style = Function(fn_description = 'Output a sentence with words <var1> and <var2> in the style of <var3>', \n",
    "                         output_format = {'output': 'sentence'},\n",
    "                         fn_name = 'sentence_with_objects_entities_emotion',\n",
    "                         llm = llm)\n",
    "\n",
    "# This is an example of an external user-defined function (see Tutorial 0)\n",
    "def binary_to_decimal(binary_number: str) -> int:\n",
    "    '''Converts binary_number to integer of base 10'''\n",
    "    return int(str(binary_number), 2)\n",
    "\n",
    "# Initialise your Agent\n",
    "my_agent = Agent('Helpful assistant', 'You are a generalist agent')\n",
    "\n",
    "# Assign the functions\n",
    "my_agent.assign_functions([sentence_style, binary_to_decimal])\n",
    "\n",
    "# Run the Agent\n",
    "output = my_agent.run('First convert binary string 1001 to a number, then generate me a happy sentence with that number and a ball')\n",
    "```\n",
    "\n",
    "`Subtask identified: Convert the binary number 1001 to decimal`\n",
    "`Calling function binary_to_decimal with parameters {'x': '1001'}`\n",
    "\n",
    "> {'output1': 9}\n",
    "\n",
    "`Subtask identified: Generate a happy sentence with the decimal number and a ball`\n",
    "`Calling function sentence_with_objects_entities_emotion with parameters {'obj': '9', 'entity': 'ball', 'emotion': 'happy'}`\n",
    "\n",
    "> {'output': 'I am so happy with my 9 balls.'}\n",
    "\n",
    "`Task completed successfully!`\n",
    "\n",
    "- Approach 1: Automatically Run your agent using `run()`\n",
    "\n",
    "- Approach 2: Manually select and use functions for your task\n",
    "    - **select_function(task: str)**: Based on the task, output the next function name and input parameters\n",
    "    - **use_function(function_name: str, function_params: dict, subtask: str = '', stateful: bool = True)**: Uses the function named `function_name` with `function_params`. `stateful` controls whether the output of this function will be saved to `subtasks_completed` under the key of `subtask`\n",
    "<br/><br/>\n",
    "\n",
    "- **Assign/Remove Functions**:\n",
    "    - **assign_functions(function_list: list)**: Assigns a list of functions to the agent\n",
    "    - **remove_function(function_name: str)**: Removes function named function_name from the list of assigned functions\n",
    "<br/><br/>\n",
    "\n",
    "- **Show Functions**:\n",
    "    - **list_functions()**: Returns the list of functions of the agent\n",
    "    - **print_functions()**: Prints the list of functions of the agent\n",
    "<br/><br/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "9a66d4ff-46a6-410f-8543-d114634740cd",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Example Internal Function\n",
    "sentence_style = Function(fn_description = 'Output a sentence with <obj> and <entity> in the style of <emotion>', \n",
    "                     output_format = {'output': 'sentence'}, fn_name = 'sentence_with_objects_entities_emotion',\n",
    "                         llm = llm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "5afe8127-069e-444f-a32c-01983357cb14",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Description: Output a sentence with <obj> and <entity> in the style of <emotion>\n",
      "Input: ['obj', 'entity', 'emotion']\n",
      "Output: {'output': 'sentence'}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(sentence_style)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "55273389-800b-403c-a15c-c185f78c9f2d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Example External Function\n",
    "def binary_to_decimal(binary_string: str) -> int:\n",
    "    '''Converts binary_string to integer of base 10'''\n",
    "    return int(str(binary_string), 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "9b50df6b-48e9-4e37-bd60-35a93dd7bdfe",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Initialise your agent\n",
    "my_agent = Agent('Helpful assistant', 'You are a generalist agent', llm = llm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "e63f4b8f-8d1f-4728-983a-9e371178e94a",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<agentjo.agent.Agent at 0x3231d4f50>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Assign functions\n",
    "my_agent.assign_functions(function_list = [sentence_style, binary_to_decimal])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "e84e8def-3202-461e-8502-32022e4ab9c5",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: use_llm\n",
      "Description: For general tasks. Used only when no other function can do the task\n",
      "Input: []\n",
      "Output: {'Output': 'Output of LLM'}\n",
      "\n",
      "Name: end_task\n",
      "Description: Passes the final output to the user\n",
      "Input: []\n",
      "Output: {}\n",
      "\n",
      "Name: sentence_with_objects_entities_emotion\n",
      "Description: Output a sentence with <obj> and <entity> in the style of <emotion>\n",
      "Input: ['obj', 'entity', 'emotion']\n",
      "Output: {'output': 'sentence'}\n",
      "\n",
      "Name: binary_to_decimal\n",
      "Description: Converts <binary_string: str> to integer of base 10\n",
      "Input: ['binary_string']\n",
      "Output: {'output_1': 'int'}\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Show the functions the agent has\n",
    "my_agent.print_functions()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1734206-5b82-4fce-b140-79ad6f71564b",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Approach 1: Automatic Running of Task"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "5fd3a834-fce4-4fdf-9113-886e1ed9e1b4",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[30mObservation: No subtasks have been completed yet for the assigned task, which involves converting a binary string to a number and generating a happy sentence.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: To complete the assigned task, I need to first convert the binary string 1001 into its decimal equivalent. Once I have that number, I can then use it to create a happy sentence that includes the number and a ball.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: Convert the binary string 1001 to its decimal equivalent.\u001b[0m\n",
      "Calling function binary_to_decimal with parameters {'binary_string': '1001'}\n",
      "> {'output_1': 9}\n",
      "\n",
      "\u001b[1m\u001b[30mObservation: The binary string 1001 has been successfully converted to the decimal number 9.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: Now that I have the number 9, I need to create a happy sentence that includes the number 9 and a ball.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: Generate a happy sentence that incorporates the number 9 and a ball.\u001b[0m\n",
      "Calling function sentence_with_objects_entities_emotion with parameters {'obj': 9, 'entity': 'ball', 'emotion': 'happy'}\n",
      "> {'output': 'The ball bounced joyfully as the children played with it, filling the air with laughter and happiness.'}\n",
      "\n",
      "\u001b[1m\u001b[30mObservation: The binary string 1001 has been successfully converted to the number 9, and a happy sentence has been generated using that number and a ball.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: Since the assigned task has been fully completed with both subtasks done, there is no further action needed. The task can now be concluded.\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('First convert binary string 1001 to a number, then generate me a happy sentence with that number and a ball')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "add22966-a6c5-40c1-9f94-ec8e6964e0e8",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agent Name: Helpful assistant\n",
      "Agent Description: You are a generalist agent\n",
      "Available Functions: ['use_llm', 'end_task', 'sentence_with_objects_entities_emotion', 'binary_to_decimal']\n",
      "Shared Variables: ['agent']\n",
      "\u001b[1m\u001b[32mTask: First convert binary string 1001 to a number, then generate me a happy sentence with that number and a ball\u001b[0m\n",
      "\u001b[1m\u001b[30mSubtasks Completed:\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask: binary_to_decimal(binary_string=\"1001\")\u001b[0m\n",
      "{'output_1': 9}\n",
      "\n",
      "\u001b[1m\u001b[34mSubtask: sentence_with_objects_entities_emotion(obj=9, entity=\"ball\", emotion=\"happy\")\u001b[0m\n",
      "{'output': 'The ball bounced joyfully as the children played with it, filling the air with laughter and happiness.'}\n",
      "\n",
      "Is Task Completed: True\n"
     ]
    }
   ],
   "source": [
    "my_agent.status()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "681a4eea-fa16-4679-a330-5f567a0e80d3",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The binary string \"1001\" has been converted to the decimal number 9. Using this number, I generated a happy sentence: \"The ball bounced joyfully as the children played with it, filling the air with laughter and happiness.\" This sentence incorporates the number 9, the entity \"ball,\" and the emotion \"happy.\"\n"
     ]
    }
   ],
   "source": [
    "# give a response to user\n",
    "output = my_agent.reply_user()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "cf326e37-a9fe-41c7-acc3-69f9f757aeaa",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The ball bounced joyfully as the children played with it, filling the air with laughter and happiness.\n"
     ]
    }
   ],
   "source": [
    "# query according to what you need\n",
    "output = my_agent.reply_user('Output only the sentence')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "669ddfba-7b61-4b66-87a0-8fbddc3bc890",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agent Name: Helpful assistant\n",
      "Agent Description: You are a generalist agent\n",
      "Available Functions: ['use_llm', 'end_task', 'sentence_with_objects_entities_emotion', 'binary_to_decimal']\n",
      "Shared Variables: ['agent']\n",
      "\u001b[1m\u001b[32mTask: First convert binary string 1001 to a number, then generate me a happy sentence with that number and a ball\u001b[0m\n",
      "\u001b[1m\u001b[30mSubtasks Completed:\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask: binary_to_decimal(binary_string=\"1001\")\u001b[0m\n",
      "{'output_1': 9}\n",
      "\n",
      "\u001b[1m\u001b[34mSubtask: sentence_with_objects_entities_emotion(obj=9, entity=\"ball\", emotion=\"happy\")\u001b[0m\n",
      "{'output': 'The ball bounced joyfully as the children played with it, filling the air with laughter and happiness.'}\n",
      "\n",
      "\u001b[1m\u001b[34mSubtask: First convert binary string 1001 to a number, then generate me a happy sentence with that number and a ball\u001b[0m\n",
      "The binary string \"1001\" has been converted to the decimal number 9. Using this number, I generated a happy sentence: \"The ball bounced joyfully as the children played with it, filling the air with laughter and happiness.\" This sentence incorporates the number 9, the entity \"ball,\" and the emotion \"happy.\"\n",
      "\n",
      "\u001b[1m\u001b[34mSubtask: Output only the sentence\u001b[0m\n",
      "The ball bounced joyfully as the children played with it, filling the air with laughter and happiness.\n",
      "\n",
      "Is Task Completed: True\n"
     ]
    }
   ],
   "source": [
    "my_agent.status()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "c55f5059-6654-4c18-b234-d83f22179d6a",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'binary_to_decimal(binary_string=\"1001\")': {'output_1': 9},\n",
       " 'sentence_with_objects_entities_emotion(obj=9, entity=\"ball\", emotion=\"happy\")': {'output': 'The ball bounced joyfully as the children played with it, filling the air with laughter and happiness.'},\n",
       " 'First convert binary string 1001 to a number, then generate me a happy sentence with that number and a ball': 'The binary string \"1001\" has been converted to the decimal number 9. Using this number, I generated a happy sentence: \"The ball bounced joyfully as the children played with it, filling the air with laughter and happiness.\" This sentence incorporates the number 9, the entity \"ball,\" and the emotion \"happy.\"',\n",
       " 'Output only the sentence': 'The ball bounced joyfully as the children played with it, filling the air with laughter and happiness.'}"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_agent.subtasks_completed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "f37158a5-5475-428b-8e17-637ca8a29cb4",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'Observation': 'No subtasks have been completed yet for the assigned task, which involves converting a binary string to a number and generating a happy sentence.',\n",
       "  'Thoughts': 'To complete the assigned task, I need to first convert the binary string 1001 into its decimal equivalent. Once I have that number, I can then use it to create a happy sentence that includes the number and a ball.',\n",
       "  'Current Subtask': 'Convert the binary string 1001 to its decimal equivalent.',\n",
       "  'Equipped Function Name': 'binary_to_decimal',\n",
       "  'Equipped Function Inputs': {'binary_string': '1001'}},\n",
       " {'Observation': 'The binary string 1001 has been successfully converted to the decimal number 9.',\n",
       "  'Thoughts': 'Now that I have the number 9, I need to create a happy sentence that includes the number 9 and a ball.',\n",
       "  'Current Subtask': 'Generate a happy sentence that incorporates the number 9 and a ball.',\n",
       "  'Equipped Function Name': 'sentence_with_objects_entities_emotion',\n",
       "  'Equipped Function Inputs': {'obj': 9,\n",
       "   'entity': 'ball',\n",
       "   'emotion': 'happy'}},\n",
       " {'Observation': 'The binary string 1001 has been successfully converted to the number 9, and a happy sentence has been generated using that number and a ball.',\n",
       "  'Thoughts': 'Since the assigned task has been fully completed with both subtasks done, there is no further action needed. The task can now be concluded.',\n",
       "  'Current Subtask': 'Finalize the task and provide the output to the user.',\n",
       "  'Equipped Function Name': 'end_task',\n",
       "  'Equipped Function Inputs': {}}]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_agent.thoughts"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b37cf760-3d1c-4619-a0c3-4b81b492bc26",
   "metadata": {},
   "source": [
    "### Approach 2: Manual Selection and Running of Functions\n",
    "- If you want to just see what the agent would choose for a hypothetical task, use `select_function`. This will not update the internal state, and will output function name and function params\n",
    "- If you want specificity in the process, you can just execute the agent's functions yourself using `use_function`\n",
    "- `use_function`: Uses an agent's function using name and params. Note that by default there will be updating of subtasks_completed when performing the function. In order not to update subtasks_completed, set `stateful = False`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "b8663646-7e7c-4859-8a8f-25493cdeeede",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[30mObservation: The Assigned Task requires generating a sentence that includes the words \"bell,\" \"dog,\" and conveys a sense of \"happy.\"\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: To complete the Assigned Task, I need to use the equipped function that can create a sentence incorporating the specified objects and emotion.\u001b[0m\n",
      "Selected function name: sentence_with_objects_entities_emotion\n",
      "Selected function params: {'obj': 'bell', 'entity': 'dog', 'emotion': 'happy'}\n",
      "Calling function sentence_with_objects_entities_emotion with parameters {'obj': 'bell', 'entity': 'dog', 'emotion': 'happy'}\n",
      "> {'output': 'The dog joyfully barked at the ringing bell, its tail wagging with excitement.'}\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'output': 'The dog joyfully barked at the ringing bell, its tail wagging with excitement.'}"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# this should call generate_sentence_with_emotion\n",
    "my_agent.reset()\n",
    "function_name, function_params = my_agent.select_function(\n",
    "    task = 'Output a sentence with bell, dog and happy')\n",
    "print(f'Selected function name: {function_name}\\nSelected function params: {function_params}')\n",
    "\n",
    "my_agent.use_function(function_name, function_params, stateful = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "04a9086a-acce-4bd4-bd5e-8219e4884220",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[30mObservation: The binary number 101 has been identified as the input for conversion to its decimal representation.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: To complete the task, I need to convert the binary string 101 into its decimal equivalent using the appropriate function.\u001b[0m\n",
      "Selected function name: binary_to_decimal\n",
      "Selected function params: {'binary_string': '101'}\n",
      "Calling function binary_to_decimal with parameters {'binary_string': '101'}\n",
      "> {'output_1': 5}\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'output_1': 5}"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# this should call binary_to_decimal\n",
    "my_agent.reset()\n",
    "function_name, function_params = my_agent.select_function(\n",
    "    task = 'What is the decimal representation of binary number 101?')\n",
    "print(f'Selected function name: {function_name}\\nSelected function params: {function_params}')\n",
    "\n",
    "my_agent.use_function(function_name, function_params, stateful = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "dcf2db16-6bd3-4396-9fdf-d74d9d4b02be",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[30mObservation: I have researched various aspects of exercise and its benefits using the LLM, gathering information on physical, mental, and emotional health improvements.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: To complete the remainder of the task, I need to synthesize the gathered information into a coherent summary that highlights the key benefits of exercise.\u001b[0m\n",
      "Selected function name: use_llm\n",
      "Selected function params: {'instruction': 'Summarize the benefits of exercise based on the research findings from the LLM.'}\n",
      "Getting LLM to perform the following task: Summarize the benefits of exercise based on the research findings from the LLM.\n",
      "> Exercise has numerous benefits supported by extensive research findings. Firstly, regular physical activity improves cardiovascular health by strengthening the heart and enhancing circulation, which can reduce the risk of heart disease. Secondly, exercise is known to aid in weight management by burning calories and increasing metabolism, which is crucial for preventing obesity. Additionally, engaging in physical activity can enhance mental health by reducing symptoms of anxiety and depression, as it promotes the release of endorphins, often referred to as \"feel-good\" hormones. Furthermore, exercise has been linked to improved cognitive function, including better memory and concentration, which can be particularly beneficial as individuals age. It also strengthens muscles and bones, reducing the risk of osteoporosis and frailty in older adults. Lastly, regular exercise can improve sleep quality, leading to better overall health and well-being. Overall, the research highlights that incorporating exercise into daily routines can lead to a healthier, longer life.\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'Detailed Outcome': 'Exercise has numerous benefits supported by extensive research findings. Firstly, regular physical activity improves cardiovascular health by strengthening the heart and enhancing circulation, which can reduce the risk of heart disease. Secondly, exercise is known to aid in weight management by burning calories and increasing metabolism, which is crucial for preventing obesity. Additionally, engaging in physical activity can enhance mental health by reducing symptoms of anxiety and depression, as it promotes the release of endorphins, often referred to as \"feel-good\" hormones. Furthermore, exercise has been linked to improved cognitive function, including better memory and concentration, which can be particularly beneficial as individuals age. It also strengthens muscles and bones, reducing the risk of osteoporosis and frailty in older adults. Lastly, regular exercise can improve sleep quality, leading to better overall health and well-being. Overall, the research highlights that incorporating exercise into daily routines can lead to a healthier, longer life.'}"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# this should call use_llm\n",
    "my_agent.reset()\n",
    "function_name, function_params = my_agent.select_function(\n",
    "    task = 'Research on the benefits of exercise based on LLM')\n",
    "print(f'Selected function name: {function_name}\\nSelected function params: {function_params}')\n",
    "\n",
    "my_agent.use_function(function_name, function_params, stateful = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f20c1b8-ba3c-48a6-b468-720ab00c4d58",
   "metadata": {
    "tags": []
   },
   "source": [
    "# 3. AsyncAgent\n",
    "\n",
    "- `AsyncAgent` works the same way as `Agent`, only much faster due to parallelisation of tasks\n",
    "- It can only be assigned functions of class `AsyncFunction`, or general Python functions (which will be converted to AsyncFunction)\n",
    "- If you define your own `AsyncFunction`, you should define the fn_name as well if it is not an External Function\n",
    "- As a rule of thumb, just add the `await` keyword to any function that you run with the `AsyncAgent`\n",
    "\n",
    "#### Example LLM in Async Mode\n",
    "```python\n",
    "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-3.5-turbo',\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\n",
    "```\n",
    "\n",
    "#### Example Agentic Workflow\n",
    "```python\n",
    "# This is an example of an LLM-based function (see Tutorial 0)\n",
    "sentence_style = AsyncFunction(fn_description = 'Output a sentence with words <var1> and <var2> in the style of <var3>', \n",
    "                         output_format = {'output': 'sentence'},\n",
    "                         fn_name = 'sentence_with_objects_entities_emotion', # you must define fn_name for LLM-based functions\n",
    "                         llm = llm_async) # use an async LLM function\n",
    "\n",
    "# This is an example of an external user-defined function (see Tutorial 0)\n",
    "def binary_to_decimal(binary_number: str) -> int:\n",
    "    '''Converts binary_number to integer of base 10'''\n",
    "    return int(str(binary_number), 2)\n",
    "\n",
    "# Initialise your Agent\n",
    "my_agent = AsyncAgent('Helpful assistant', 'You are a generalist agent', llm = llm_async)\n",
    "\n",
    "# Assign the functions\n",
    "my_agent.assign_functions([sentence_style, binary_to_decimal])\n",
    "\n",
    "# Run the Agent\n",
    "output = await my_agent.run('Generate me a happy sentence with a number and a ball. The number is b1001 converted to decimal')\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "79ddfa23-df79-4a46-a5de-11f55c99cd05",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Define an Async LLM function\n",
    "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": 46,
   "id": "c8b8bfd3-53e8-4399-bbae-0da571a2423d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[30mObservation: No subtasks have been completed yet for the assigned task, which involves converting a binary string to a number and generating a sentence.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: To complete the assigned task, I need to first convert the binary string 1001 into its decimal equivalent. Once I have that number, I can then use it to create a happy sentence that includes the number and a ball.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: Convert the binary string 1001 to its decimal equivalent.\u001b[0m\n",
      "Calling function binary_to_decimal with parameters {'binary_number': '1001'}\n",
      "> {'output_1': 9}\n",
      "\n",
      "\u001b[1m\u001b[30mObservation: The binary string 1001 has been successfully converted to the number 9.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: Now that I have the number 9, I need to generate a happy sentence that includes the number 9 and a ball.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: Use the sentence_with_objects_entities_emotion function to create a happy sentence incorporating the number 9 and a ball.\u001b[0m\n",
      "Calling function sentence_with_objects_entities_emotion with parameters {'var1': 9, 'var2': 'ball', 'var3': 'happy'}\n",
      "> {'output': 'I am so happy to see the 9 colorful balls bouncing around!'}\n",
      "\n",
      "\u001b[1m\u001b[30mObservation: The binary string 1001 has been successfully converted to the number 9, and a happy sentence has been generated using that number and a ball.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: Since the assigned task has been fully completed with the conversion and sentence generation, I can now proceed to finalize the task.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: End Task\u001b[0m\n",
      "Task completed successfully!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# This is an example of an LLM-based function (see Tutorial 0)\n",
    "sentence_style = AsyncFunction(fn_description = 'Output a sentence with words <var1> and <var2> in the style of <var3>', \n",
    "                         output_format = {'output': 'sentence'},\n",
    "                         fn_name = 'sentence_with_objects_entities_emotion', # you must define fn_name for LLM-based functions\n",
    "                         llm = llm_async) # you must use an Async LLM function\n",
    "\n",
    "# This is an example of an external user-defined function (see Tutorial 0)\n",
    "def binary_to_decimal(binary_number: str) -> int:\n",
    "    '''Converts binary_number to integer of base 10'''\n",
    "    return int(str(binary_number), 2)\n",
    "\n",
    "# Initialise your Agent\n",
    "my_agent = AsyncAgent('Helpful assistant', 'You are a generalist agent', llm = llm_async)\n",
    "\n",
    "# Assign the functions\n",
    "my_agent.assign_functions([sentence_style, binary_to_decimal])\n",
    "\n",
    "# Run the Agent\n",
    "output = await my_agent.run('First convert binary string 1001 to a number, then generate me a happy sentence with that number and a ball')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "d204a954-4ec0-43e3-9fb0-2f257840b726",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The binary string \"1001\" has been successfully converted to its decimal equivalent, which is 9. Following this conversion, a happy sentence was generated that incorporates the number 9 and the object \"ball\". The resulting sentence is: \"I am so happy to see the 9 colorful balls bouncing around!\" This sentence effectively combines the number derived from the binary conversion with the specified object and emotion.\n"
     ]
    }
   ],
   "source": [
    "output = await my_agent.reply_user()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "108188b2-a25c-4d90-9514-6f4be23b1b5b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Binary': '1001', 'Integer': 9}"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "await my_agent.answer(\"What is the number?\",\n",
    "                      output_format = {\"Binary\": \"type: str\", \n",
    "                                       \"Integer\": \"type: int\"})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "2a7b5f28-69c2-40a0-b2a8-acf8da545f1a",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agent Name: Helpful assistant\n",
      "Agent Description: You are a generalist agent\n",
      "Available Functions: ['use_llm', 'end_task', 'sentence_with_objects_entities_emotion', 'binary_to_decimal']\n",
      "Shared Variables: ['agent']\n",
      "\u001b[1m\u001b[32mTask: First convert binary string 1001 to a number, then generate me a happy sentence with that number and a ball\u001b[0m\n",
      "\u001b[1m\u001b[30mSubtasks Completed:\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask: binary_to_decimal(binary_number=\"1001\")\u001b[0m\n",
      "{'output_1': 9}\n",
      "\n",
      "\u001b[1m\u001b[34mSubtask: sentence_with_objects_entities_emotion(var1=9, var2=\"ball\", var3=\"happy\")\u001b[0m\n",
      "{'output': 'I am so happy to see the 9 colorful balls bouncing around!'}\n",
      "\n",
      "\u001b[1m\u001b[34mSubtask: First convert binary string 1001 to a number, then generate me a happy sentence with that number and a ball\u001b[0m\n",
      "The binary string \"1001\" has been successfully converted to its decimal equivalent, which is 9. Following this conversion, a happy sentence was generated that incorporates the number 9 and the object \"ball\". The resulting sentence is: \"I am so happy to see the 9 colorful balls bouncing around!\" This sentence effectively combines the number derived from the binary conversion with the specified object and emotion.\n",
      "\n",
      "Is Task Completed: True\n"
     ]
    }
   ],
   "source": [
    "my_agent.status()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "bbf73ba3-854a-432b-98c2-3aa89a040cb2",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[30mObservation: The task requires generating a sentence that includes the words \"bell,\" \"dog,\" and \"happy.\"\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: To complete the task, I need to use the equipped function that can create a sentence incorporating the specified words in a stylistic manner.\u001b[0m\n",
      "Selected function name: sentence_with_objects_entities_emotion\n",
      "Selected function params: {'var1': 'bell', 'var2': 'dog', 'var3': 'joyful'}\n",
      "Calling function sentence_with_objects_entities_emotion with parameters {'var1': 'bell', 'var2': 'dog', 'var3': 'joyful'}\n",
      "> {'output': 'The joyful bell rang as the dog wagged its tail in delight.'}\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'output': 'The joyful bell rang as the dog wagged its tail in delight.'}"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# this should call generate_sentence_with_emotion\n",
    "my_agent.reset()\n",
    "function_name, function_params = await my_agent.select_function(\n",
    "    task = 'Output a sentence with bell, dog and happy')\n",
    "print(f'Selected function name: {function_name}\\nSelected function params: {function_params}')\n",
    "\n",
    "await my_agent.use_function(function_name, function_params, stateful = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2361b2f-5f2d-48e6-bf09-7276ccca4afc",
   "metadata": {},
   "source": [
    "# Saving and Loading Agents\n",
    "Sometimes you want to configure your agents and save them and load them elsewhere, while maintaining the current agent state\n",
    "\n",
    "- When you use the `save_agent` function, we store the entire agent's internal state, include name, description, list of functions, subtasks history and all other internal variables into a pickle file\n",
    "- When you use the `load_agent` function, and we will load the entire agent saved in the pickle file into the existing agent\n",
    "\n",
    "Key functions:\n",
    "- **save_agent(pickle_file_name: str)**: Saves the agent's internal parameters to a pickle file named pickle_file_name (include .pkl), returns the pickle file\n",
    "- **load_agent(pickle_file_name: str)**: Loads the agent's internal parameters from a pickle file named pickle_file_name (include .pkl), returns loaded agent\n",
    "\n",
    "#### Example 1: Saving Agent\n",
    "```python\n",
    "my_agent.save_agent('myagent.pkl')\n",
    "```\n",
    "\n",
    "#### Example Output\n",
    "```Agent saved to myagent.pkl```\n",
    "\n",
    "#### Example 2: Loading Agent\n",
    "```python\n",
    "new_agent = Agent().load_agent('myagent.pkl')\n",
    "```\n",
    "\n",
    "#### Example Output\n",
    "```Agent loaded from myagent.pkl```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "55055628-0738-4996-bd45-b5d50814b94b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# run one task to add something to subtasks_completed\n",
    "my_agent.reset()\n",
    "output = my_agent.run('What is the decimal representation of binary number 101?')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "e4b26d2b-915a-4201-8c5e-74c9d614af03",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agent Name: Helpful assistant\n",
      "Agent Description: You are a generalist agent\n",
      "Available Functions: ['use_llm', 'end_task', 'sentence_with_objects_entities_emotion', 'binary_to_decimal']\n",
      "Shared Variables: ['agent']\n",
      "\u001b[1m\u001b[32mTask: No task assigned\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtasks Completed: None\u001b[0m\n",
      "Is Task Completed: False\n"
     ]
    }
   ],
   "source": [
    "# see status of agent before saving\n",
    "my_agent.status()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "4b7ba9d3-c5c0-4cf3-b2b0-1a253e2b93fa",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agent saved to myagent.pkl\n"
     ]
    }
   ],
   "source": [
    "# save agent\n",
    "my_agent.save_agent('myagent.pkl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "30aa1504-3a15-411e-858e-3c4efc330971",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agent loaded from myagent.pkl\n"
     ]
    }
   ],
   "source": [
    "# load agent using load_agent code\n",
    "new_agent = Agent().load_agent('myagent.pkl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "60a367af-24da-4f0c-aca1-bdd891e9da42",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agent Name: Helpful assistant\n",
      "Agent Description: You are a generalist agent\n",
      "Available Functions: ['use_llm', 'end_task', 'sentence_with_objects_entities_emotion', 'binary_to_decimal']\n",
      "Shared Variables: ['agent']\n",
      "\u001b[1m\u001b[32mTask: No task assigned\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtasks Completed: None\u001b[0m\n",
      "Is Task Completed: False\n"
     ]
    }
   ],
   "source": [
    "# see status of loaded agent (which also includes what is saved in subtasks_completed, and shared_variables)\n",
    "new_agent.status()"
   ]
  }
 ],
 "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
}