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": [
    {
     "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": "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": 3,
   "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": 4,
   "id": "5f022dd4-0027-416e-b9c8-15a80eb0a80c",
   "metadata": {
    "tags": []
   },
   "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": "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": 5,
   "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": 6,
   "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": 7,
   "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, and the task requires generating rhyming words and a poem.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: To complete the remainder of the task, I need to first find five words that rhyme with \"cool\" and then create a four-sentence poem using those words.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: Generate a list of five words that rhyme with \"cool\".\u001b[0m\n",
      "Getting LLM to perform the following task: Generate a list of five words that rhyme with \"cool\".\n",
      "> I generated a list of five words that rhyme with \"cool\": 1. Pool 2. Tool 3. Fool 4. Rule 5. School. These words share the same ending sound as \"cool,\" making them perfect rhymes for various creative uses such as poetry, songwriting, or word games.\n",
      "\n",
      "\u001b[1m\u001b[30mObservation: I generated a list of five words that rhyme with \"cool\": 1. Pool 2. Tool 3. Fool 4. Rule 5. School. These words can be used to create a poem.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: Now that I have the rhyming words, I need to construct a 4-sentence poem using them. I can creatively incorporate each word into the poem while maintaining a coherent theme.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: Create a 4-sentence poem using the words: pool, tool, fool, rule, and school.\u001b[0m\n",
      "Getting LLM to perform the following task: Create a 4-sentence poem using the words: pool, tool, fool, rule, and school.\n",
      "> In the summer sun, we gather by the pool,  \n",
      "With laughter and joy, we play the perfect fool.  \n",
      "A trusty tool in hand, we follow the golden rule,  \n",
      "Learning and growing together, just like in school.\n",
      "\n",
      "\u001b[1m\u001b[30mObservation: I have successfully generated a list of five words that rhyme with \"cool\" and created a 4-sentence poem using those words.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: Since the Assigned Task has been completed with both the list of rhyming words and the poem provided, I can now finalize the task and present the output 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": 8,
   "id": "afe503c9-ad37-4962-8099-8d62b7844692",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['I generated a list of five words that rhyme with \"cool\": 1. Pool 2. Tool 3. Fool 4. Rule 5. School. These words share the same ending sound as \"cool,\" making them perfect rhymes for various creative uses such as poetry, songwriting, or word games.', 'In the summer sun, we gather by the pool,  \\nWith laughter and joy, we play the perfect fool.  \\nA trusty tool in hand, we follow the golden rule,  \\nLearning and growing together, just like in school.']\n"
     ]
    }
   ],
   "source": [
    "# visualise the subtask outputs of the task\n",
    "print(output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "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 a list of five words that rhyme with \"cool\".\u001b[0m\n",
      "I generated a list of five words that rhyme with \"cool\": 1. Pool 2. Tool 3. Fool 4. Rule 5. School. These words share the same ending sound as \"cool,\" making them perfect rhymes for various creative uses such as poetry, songwriting, or word games.\n",
      "\n",
      "\u001b[1m\u001b[34mSubtask: Create a 4-sentence poem using the words: pool, tool, fool, rule, and school.\u001b[0m\n",
      "In the summer sun, we gather by the pool,  \n",
      "With laughter and joy, we play the perfect fool.  \n",
      "A trusty tool in hand, we follow the golden rule,  \n",
      "Learning and growing together, just like in school.\n",
      "\n",
      "Is Task Completed: True\n"
     ]
    }
   ],
   "source": [
    "# see the updated agent status\n",
    "my_agent.status()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "79a8a4ba-3375-4ff0-9057-b3073420ed00",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I generated a list of five words that rhyme with \"cool\": 1. Pool 2. Tool 3. Fool 4. Rule 5. School. These words share the same ending sound as \"cool,\" making them perfect rhymes for various creative uses such as poetry, songwriting, or word games. Additionally, I created a 4-sentence poem using these words: In the summer sun, we gather by the pool,  \n",
      "With laughter and joy, we play the perfect fool.  \n",
      "A trusty tool in hand, we follow the golden rule,  \n",
      "Learning and growing together, just like in school.\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": 11,
   "id": "e1cbbce6-27b4-47f4-afc1-08e763de82fa",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The pool is a location where people gather, especially in the summer sun, as mentioned in the poem I created. It serves as a place for relaxation and enjoyment, where laughter and joy are shared among friends. While I did not provide a specific physical location for the pool, it is often associated with leisure activities and social gatherings, making it a popular spot in many communities.\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": 12,
   "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 a list of five words that rhyme with \"cool\".\u001b[0m\n",
      "I generated a list of five words that rhyme with \"cool\": 1. Pool 2. Tool 3. Fool 4. Rule 5. School. These words share the same ending sound as \"cool,\" making them perfect rhymes for various creative uses such as poetry, songwriting, or word games.\n",
      "\n",
      "\u001b[1m\u001b[34mSubtask: Create a 4-sentence poem using the words: pool, tool, fool, rule, and school.\u001b[0m\n",
      "In the summer sun, we gather by the pool,  \n",
      "With laughter and joy, we play the perfect fool.  \n",
      "A trusty tool in hand, we follow the golden rule,  \n",
      "Learning and growing together, just like in school.\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",
      "I generated a list of five words that rhyme with \"cool\": 1. Pool 2. Tool 3. Fool 4. Rule 5. School. These words share the same ending sound as \"cool,\" making them perfect rhymes for various creative uses such as poetry, songwriting, or word games. Additionally, I created a 4-sentence poem using these words: In the summer sun, we gather by the pool,  \n",
      "With laughter and joy, we play the perfect fool.  \n",
      "A trusty tool in hand, we follow the golden rule,  \n",
      "Learning and growing together, just like in school.\n",
      "\n",
      "Is Task Completed: True\n"
     ]
    }
   ],
   "source": [
    "# see the updated agent status\n",
    "my_agent.status()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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": 14,
   "id": "e449c92b-6f85-487f-a4e2-7fff4c06bd69",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "my_agent.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "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": 16,
   "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 have compiled the following list: 1. Mask, 2. Flask, 3. Brask, 4. Ask, 5. Bask. Each of these words shares a similar ending sound with \"task,\" making them suitable rhymes. This outcome not only meets the requirement of the task 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 Bask. This completes the first part of the assigned task.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: Now that I have the rhyming words, I need to create a 4-sentence poem using these words. I can combine them creatively to form a cohesive and engaging poem.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: Compose a 4-sentence poem using the rhyming words: Mask, Flask, Brask, Ask, and Bask.\u001b[0m\n",
      "Getting LLM to perform the following task: Compose a 4-sentence poem using the rhyming words: Mask, Flask, Brask, Ask, and Bask.\n",
      "> In the shadows, I wear a mask,  \n",
      "Holding secrets in my flask.  \n",
      "With a smile, I dare to ask,  \n",
      "As the sun sets, I find my bask.\n",
      "\n",
      "\u001b[1m\u001b[30mObservation: I have successfully identified five words that rhyme with \"task\" and composed a 4-sentence poem using those words. The rhyming words are Mask, Flask, Brask, Ask, and Bask, and the poem captures a thematic essence using these rhymes effectively.\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 creating 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": 17,
   "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 have compiled the following list: 1. Mask, 2. Flask, 3. Brask, 4. Ask, 5. Bask. Each of these words shares a similar ending sound with \"task,\" making them suitable rhymes. This outcome not only meets the requirement of the task 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 rhyming words: Mask, Flask, Brask, Ask, and Bask.\u001b[0m\n",
      "In the shadows, I wear a mask,  \n",
      "Holding secrets in my flask.  \n",
      "With a smile, I dare to ask,  \n",
      "As the sun sets, I find my bask.\n",
      "\n",
      "Is Task Completed: True\n"
     ]
    }
   ],
   "source": [
    "# see the updated agent staus\n",
    "my_agent.status()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "0e16e821-a564-4ae4-96f1-b8318f54386f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Words': ['Mask', 'Flask', 'Brask', 'Ask', 'Bask'],\n",
       " 'Words and their meaning': {'Mask': 'A covering for all or part of the face, used for disguise or protection.',\n",
       "  'Flask': 'A container, typically a bottle with a narrow neck, used for holding liquids.',\n",
       "  'Brask': 'A term used in some dialects, often referring to a type of drink or beverage.',\n",
       "  'Ask': 'To request information or an answer to a question.',\n",
       "  'Bask': 'To lie exposed to warmth and light for relaxation or enjoyment.'}}"
      ]
     },
     "execution_count": 18,
     "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": 97,
   "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": 98,
   "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 generating three random numbers, calculating their sum, and creating a math question based on that sum.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: To complete the assigned task, I need to generate three random numbers between 1 and 50, calculate their sum, and then formulate a math question using that 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 were 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, give me their sum, then generate a math question based on it', num_subtasks = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "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 were 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": 100,
   "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, give me their sum, then generate a math question based on it\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 were 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": 101,
   "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) from 1 to 50 and calculated their sum, which is 74.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: The next step is to generate a math question based on the sum of 74. This could involve creating a simple arithmetic problem that incorporates this sum.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: Create a math question that involves the sum of 74, such as asking what two numbers add up to 74 or creating a word problem that results in 74.\u001b[0m\n",
      "Getting LLM to perform the following task: Create a math question that involves the sum of 74, such as asking what two numbers add up to 74 or creating a word problem that results in 74.\n",
      "> I created a math question that involves the sum of 74. The question is: \"If you have a total of 74 apples and you give away some to your friend, you are left with 29 apples. How many apples did you give to your friend?\" This word problem not only incorporates the sum of 74 but also encourages problem-solving skills as the user must calculate the number of apples given away by subtracting 29 from 74, resulting in 45 apples given to the friend.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Runs the task for another step\n",
    "output = my_agent.run('List me three random numbers from 1 to 50, give me their sum, then generate a math question based on it', num_subtasks = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "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 were 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.', 'I created a math question that involves the sum of 74. The question is: \"If you have a total of 74 apples and you give away some to your friend, you are left with 29 apples. How many apples did you give to your friend?\" This word problem not only incorporates the sum of 74 but also encourages problem-solving skills as the user must calculate the number of apples given away by subtracting 29 from 74, resulting in 45 apples given to the friend.']\n"
     ]
    }
   ],
   "source": [
    "# visualise the outputs of the task at the subtask level\n",
    "print(output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "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, give me their sum, then generate a math question based on it\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 were 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",
      "\u001b[1m\u001b[34mSubtask: Create a math question that involves the sum of 74, such as asking what two numbers add up to 74 or creating a word problem that results in 74.\u001b[0m\n",
      "I created a math question that involves the sum of 74. The question is: \"If you have a total of 74 apples and you give away some to your friend, you are left with 29 apples. How many apples did you give to your friend?\" This word problem not only incorporates the sum of 74 but also encourages problem-solving skills as the user must calculate the number of apples given away by subtracting 29 from 74, resulting in 45 apples given to the friend.\n",
      "\n",
      "Is Task Completed: False\n"
     ]
    }
   ],
   "source": [
    "# Visualise the first and second subtasks\n",
    "my_agent.status()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "1ce7cc99-f460-444b-a243-acf09535629d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[30mObservation: I have successfully generated three random numbers (12, 27, and 35) from the range of 1 to 50, calculated their sum (74), and created a math question based on that sum.\u001b[0m\n",
      "\u001b[1m\u001b[32mThoughts: The assigned task is now complete as I have provided the three random numbers, their sum, and a relevant math question. The next step is to finalize the output and pass it to the user.\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, give me their sum, then generate a math question based on it', num_subtasks = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "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 were 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. Additionally, I created a math question that involves the sum of 74. The question is: \"If you have a total of 74 apples and you give away some to your friend, you are left with 29 apples. How many apples did you give to your friend?\" This word problem incorporates the sum of 74 and requires the user to calculate the number of apples given away by subtracting 29 from 74, resulting in 45 apples given to the friend.\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": 28,
   "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": 29,
   "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": 30,
   "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": 31,
   "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": 32,
   "id": "e63f4b8f-8d1f-4728-983a-9e371178e94a",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<agentjo.agent.Agent at 0x14ee19ca0>"
      ]
     },
     "execution_count": 32,
     "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": 33,
   "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": 34,
   "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 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 generate a happy sentence that includes this number and a ball.\u001b[0m\n",
      "\u001b[1m\u001b[34mSubtask identified: Use the sentence_with_objects_entities_emotion function to create a happy sentence that incorporates the number 9 and a ball.\u001b[0m\n",
      "Calling function sentence_with_objects_entities_emotion with parameters {'obj': 'a ball', 'entity': 9, 'emotion': 'happy'}\n",
      "> {'output': 'The 9 kids laughed joyfully as they kicked the ball around in the sunny park.'}\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, 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"
     ]
    }
   ],
   "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": 35,
   "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=\"a ball\", entity=9, emotion=\"happy\")\u001b[0m\n",
      "{'output': 'The 9 kids laughed joyfully as they kicked the ball around in the sunny park.'}\n",
      "\n",
      "Is Task Completed: True\n"
     ]
    }
   ],
   "source": [
    "# Show the agent's status\n",
    "my_agent.status()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "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 9 kids laughed joyfully as they kicked the ball around in the sunny park.\" This sentence incorporates the number 9 and the object \"a ball,\" along with the emotion \"happy.\"\n"
     ]
    }
   ],
   "source": [
    "# give a response to user\n",
    "output = my_agent.reply_user()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "cf326e37-a9fe-41c7-acc3-69f9f757aeaa",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The 9 kids laughed joyfully as they kicked the ball around in the sunny park.\n"
     ]
    }
   ],
   "source": [
    "# query according to what you need\n",
    "output = my_agent.reply_user('Output only the sentence')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "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=\"a ball\", entity=9, emotion=\"happy\")\u001b[0m\n",
      "{'output': 'The 9 kids laughed joyfully as they kicked the ball around in the sunny park.'}\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 9 kids laughed joyfully as they kicked the ball around in the sunny park.\" This sentence incorporates the number 9 and the object \"a ball,\" along with the emotion \"happy.\"\n",
      "\n",
      "\u001b[1m\u001b[34mSubtask: Output only the sentence\u001b[0m\n",
      "The 9 kids laughed joyfully as they kicked the ball around in the sunny park.\n",
      "\n",
      "Is Task Completed: True\n"
     ]
    }
   ],
   "source": [
    "# show the agent's status\n",
    "my_agent.status()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "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=\"a ball\", entity=9, emotion=\"happy\")': {'output': 'The 9 kids laughed joyfully as they kicked the ball around in the sunny park.'},\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 9 kids laughed joyfully as they kicked the ball around in the sunny park.\" This sentence incorporates the number 9 and the object \"a ball,\" along with the emotion \"happy.\"',\n",
       " 'Output only the sentence': 'The 9 kids laughed joyfully as they kicked the ball around in the sunny park.'}"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# show the subtasks completed\n",
    "my_agent.subtasks_completed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "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 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 generate a happy sentence that includes this number and a ball.',\n",
       "  'Current Subtask': 'Use the sentence_with_objects_entities_emotion function to create 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': 'a ball',\n",
       "   'entity': 9,\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 the conversion and sentence generation, the next step is to finalize the task and provide the output to the user.',\n",
       "  'Current Subtask': 'End the task and pass the final output to the user.',\n",
       "  'Equipped Function Name': 'end_task',\n",
       "  'Equipped Function Inputs': {}}]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# show the agent's detailed observation and thoughts for each subtask\n",
    "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": 41,
   "id": "b8663646-7e7c-4859-8a8f-25493cdeeede",
   "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 conveys a sense of \"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 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": 41,
     "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": 42,
   "id": "04a9086a-acce-4bd4-bd5e-8219e4884220",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[30mObservation: The task requires converting the binary number 101 into its decimal representation. No subtasks have been completed yet.\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": 42,
     "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": 43,
   "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 is known to improve cardiovascular health by strengthening the heart and improving circulation, which can reduce the risk of heart disease. Secondly, exercise plays a crucial role in weight management by burning calories and increasing metabolism, which helps in maintaining a healthy body weight. Additionally, engaging in physical activity has been shown to enhance mental health by reducing symptoms of anxiety and depression, as well as improving mood and cognitive function through the release of endorphins. Furthermore, exercise contributes to stronger muscles and bones, which is particularly important as individuals age, helping to prevent osteoporosis and frailty. Lastly, regular exercise can improve sleep quality, boost energy levels, and enhance overall quality of life, making it a vital component of a healthy lifestyle.\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'Detailed Outcome': 'Exercise has numerous benefits supported by extensive research findings. Firstly, regular physical activity is known to improve cardiovascular health by strengthening the heart and improving circulation, which can reduce the risk of heart disease. Secondly, exercise plays a crucial role in weight management by burning calories and increasing metabolism, which helps in maintaining a healthy body weight. Additionally, engaging in physical activity has been shown to enhance mental health by reducing symptoms of anxiety and depression, as well as improving mood and cognitive function through the release of endorphins. Furthermore, exercise contributes to stronger muscles and bones, which is particularly important as individuals age, helping to prevent osteoporosis and frailty. Lastly, regular exercise can improve sleep quality, boost energy levels, and enhance overall quality of life, making it a vital component of a healthy lifestyle.'}"
      ]
     },
     "execution_count": 43,
     "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": 44,
   "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": 45,
   "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 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 the word \"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 equipped function to create a sentence that incorporates the number 9 and a ball in a happy style.\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 completed with the conversion and sentence generation, I can now 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"
     ]
    }
   ],
   "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": 46,
   "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 conveys a sense of joy associated with the number of balls mentioned.\n"
     ]
    }
   ],
   "source": [
    "output = await my_agent.reply_user()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "108188b2-a25c-4d90-9514-6f4be23b1b5b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Binary': '1001', 'Integer': 9}"
      ]
     },
     "execution_count": 47,
     "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": 48,
   "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 conveys a sense of joy associated with the number of balls mentioned.\n",
      "\n",
      "Is Task Completed: True\n"
     ]
    }
   ],
   "source": [
    "my_agent.status()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "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": 49,
     "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": 50,
   "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": 51,
   "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": 52,
   "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": 53,
   "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": 54,
   "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
}