07_Function_Calling.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "7ce8bc84",
   "metadata": {},
   "source": [
    "# **Function Calling** in LangChain\n",
    "In this notebook, we'll dive deep into a powerful feature offered by the latest versions of OpenAI's <br>\n",
    "GPT models (like gpt-3.5-turbo-0613 and gpt-4-0613): function calling.\n",
    "\n",
    "## Outline\n",
    "\n",
    "* Function Calling with OpenAI\n",
    "* Function Calling with LangChain (Simple)\n",
    "* Function Calling with LangChain (Complex)\n",
    "\n",
    "Let's imagine you're talking to a ChatGPT model and you want to have it use a tool. Traditionally you'd have to do some clever prompting to have it return the format you'd like.\n",
    "\n",
    "Now you can tell it about certain actions, or **\"functions\"**, it can take\n",
    "\n",
    "This doesn't mean the assistant actually performs these actions. Rather, it's aware of them and can instruct you on how to perform these actions based on the conversation at hand.\n",
    "\n",
    "For example, you can tell the assistant about a function that fetches weather data, and when asked \"What's the weather like in Boston?\", the assistant can reply with instructions on how to call this weather-fetching function with 'Boston' as the input.\n",
    "\n",
    "**Function calling** enables us to leverage the model's natural language understanding to effectively turn human language into structured data or specific function calls in our code.\n",
    "\n",
    "This capability is useful in numerous scenarios, from creating chatbots that can interact with other APIs, to automating tasks and extracting structured information from natural language inputs. See more information about [function calling](https://platform.openai.com/docs/guides/gpt/function-calling)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d8042fc3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip install langchain --upgrade\n",
    "# Version: 0.0.199 Make sure you're on the latest version\n",
    "\n",
    "import langchain\n",
    "import openai\n",
    "import json\n",
    "\n",
    "# Environment Variables\n",
    "import os\n",
    "from dotenv import load_dotenv\n",
    "\n",
    "load_dotenv()\n",
    "\n",
    "openai.api_key = os.getenv('OPENAI_API_KEY', 'YourAPIKeyIfNotSet')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "3ea3650a",
   "metadata": {},
   "source": [
    "## OpenAI Vanilla Example\n",
    "\n",
    "Let's run through OpenAI's vanilla example of calling a weather API.\n",
    "\n",
    "First let's define our functions. This is the meat and potatoes of the new update\n",
    "\n",
    "Functions are specified with the following fields:\n",
    "\n",
    "* **Name:** The name of the function.\n",
    "* **Description:** A description of what the function does. The model will use this to decide when to call the function.\n",
    "* **Parameters:** The parameters object contains all of the input fields the function requires. These inputs can be of the following types: String, Number, Boolean, Object, Null, AnyOf. Refer to the API reference docs for details.\n",
    "* **Required:** Which of the parameters are required to make a query. The rest will be treated as optional."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3bd25223",
   "metadata": {},
   "outputs": [],
   "source": [
    "function_descriptions = [\n",
    "            {\n",
    "                \"name\": \"get_current_weather\",\n",
    "                \"description\": \"Get the current weather in a given location\",\n",
    "                \"parameters\": {\n",
    "                    \"type\": \"object\",\n",
    "                    \"properties\": {\n",
    "                        \"location\": {\n",
    "                            \"type\": \"string\",\n",
    "                            \"description\": \"The city and state, e.g. San Francisco, CA\",\n",
    "                        },\n",
    "                        \"unit\": {\n",
    "                            \"type\": \"string\",\n",
    "                            \"description\": \"The temperature unit to use. Infer this from the users location.\",\n",
    "                            \"enum\": [\"celsius\", \"fahrenheit\"]\n",
    "                        },\n",
    "                    },\n",
    "                    \"required\": [\"location\", \"unit\"],\n",
    "                },\n",
    "            }\n",
    "        ]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "1bdb85b0",
   "metadata": {},
   "source": [
    "Then let's call the OpenAI API with this as a new parameter. Note: Make sure to use a model that can accept the function call. Here we are using `gpt-3.5-turbo-0613`.\n",
    "\n",
    "Let's first set a query that came from the user"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1afea666",
   "metadata": {},
   "outputs": [],
   "source": [
    "user_query = \"What's the weather like in San Francisco?\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "443aee72",
   "metadata": {},
   "source": [
    "Then let's set up our API call to OpenAI. Note: `function_call=\"auto\"` will allow the model to choose whether or not it responds with a function. You can set this to `none` if you *don't* want a function response"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6a565cf6",
   "metadata": {},
   "outputs": [],
   "source": [
    "response = openai.ChatCompletion.create(\n",
    "        model=\"gpt-4-0613\",\n",
    "        \n",
    "        # This is the chat message from the user\n",
    "        messages=[{\"role\": \"user\", \"content\": user_query}],\n",
    "    \n",
    "        \n",
    "        functions=function_descriptions,\n",
    "        function_call=\"auto\",\n",
    "    )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "9344b392",
   "metadata": {},
   "source": [
    "Great, let's take a look at the response"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d5067356",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  \"content\": null,\n",
      "  \"function_call\": {\n",
      "    \"arguments\": \"{\\n  \\\"location\\\": \\\"San Francisco, CA\\\",\\n  \\\"unit\\\": \\\"fahrenheit\\\"\\n}\",\n",
      "    \"name\": \"get_current_weather\"\n",
      "  },\n",
      "  \"role\": \"assistant\"\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "ai_response_message = response[\"choices\"][0][\"message\"]\n",
    "print(message)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "c158975c",
   "metadata": {},
   "source": [
    "Awesome, now we have our response w/ specific arguments called out.\n",
    "\n",
    "Let's clean up our response a bit better"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "04ada914",
   "metadata": {},
   "outputs": [],
   "source": [
    "user_location = eval(ai_response_message['function_call']['arguments']).get(\"location\")\n",
    "user_unit = eval(ai_response_message['function_call']['arguments']).get(\"unit\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "bbc81e28",
   "metadata": {},
   "source": [
    "Then let's make a function that will serve as an interface to a dummy api call"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "a7e4fe28",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_current_weather(location, unit):\n",
    "    \n",
    "    \"\"\"Get the current weather in a given location\"\"\"\n",
    "    \n",
    "    weather_info = {\n",
    "        \"location\": location,\n",
    "        \"temperature\": \"72\",\n",
    "        \"unit\": unit,\n",
    "        \"forecast\": [\"sunny\", \"windy\"],\n",
    "    }\n",
    "    return json.dumps(weather_info)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "505806ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "function_response = get_current_weather(\n",
    "    location=user_location,\n",
    "    unit=user_unit,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "6c24e71c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'{\"location\": \"San Francisco, CA\", \"temperature\": \"72\", \"unit\": \"fahrenheit\", \"forecast\": [\"sunny\", \"windy\"]}'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_response"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "89694ba3",
   "metadata": {},
   "source": [
    "Now that we have our reponse from our service, we can pass this information back to our model for a natural language response"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "2c4a5c78",
   "metadata": {},
   "outputs": [],
   "source": [
    "second_response = openai.ChatCompletion.create(\n",
    "    model=\"gpt-4-0613\",\n",
    "    messages=[\n",
    "        {\"role\": \"user\", \"content\": user_query},\n",
    "        ai_response_message,\n",
    "        {\n",
    "            \"role\": \"function\",\n",
    "            \"name\": \"get_current_weather\",\n",
    "            \"content\": function_response,\n",
    "        },\n",
    "    ],\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "e4020764",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Currently in San Francisco, CA the weather is sunny and windy with a temperature of 72°F.\n"
     ]
    }
   ],
   "source": [
    "print (second_response['choices'][0]['message']['content'])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "519f57b4",
   "metadata": {},
   "source": [
    "## LangChain Support For Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "1d3f216d",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain.chat_models import ChatOpenAI\n",
    "from langchain.schema import HumanMessage, AIMessage, ChatMessage\n",
    "from langchain.tools import format_tool_to_openai_function, YouTubeSearchTool, MoveFileTool"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "c30ea30c",
   "metadata": {},
   "source": [
    "Let's load up our models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "d4aa0e58",
   "metadata": {},
   "outputs": [],
   "source": [
    "llm = ChatOpenAI(model=\"gpt-4-0613\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "fd72917e",
   "metadata": {},
   "source": [
    "Let's load our tools and then transform them into OpenAI's function framework"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "93b8f50a",
   "metadata": {},
   "outputs": [],
   "source": [
    "tools = [MoveFileTool()]\n",
    "functions = [format_tool_to_openai_function(t) for t in tools]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "47e978c0",
   "metadata": {},
   "source": [
    "Let's take a look at what this tool was transformed as"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "4b56cdc6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'name': 'move_file',\n",
       "  'description': 'Move or rename a file from one location to another',\n",
       "  'parameters': {'title': 'FileMoveInput',\n",
       "   'description': 'Input for MoveFileTool.',\n",
       "   'type': 'object',\n",
       "   'properties': {'source_path': {'title': 'Source Path',\n",
       "     'description': 'Path of the file to move',\n",
       "     'type': 'string'},\n",
       "    'destination_path': {'title': 'Destination Path',\n",
       "     'description': 'New path for the moved file',\n",
       "     'type': 'string'}},\n",
       "   'required': ['source_path', 'destination_path']}}]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "aff6280a",
   "metadata": {},
   "outputs": [],
   "source": [
    "message = llm.predict_messages([HumanMessage(content='move file foo to bar')], functions=functions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "adf61d07",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'move_file',\n",
       " 'arguments': '{\\n  \"source_path\": \"foo\",\\n  \"destination_path\": \"bar\"\\n}'}"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "message.additional_kwargs['function_call']"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "4d139846",
   "metadata": {},
   "source": [
    "### Ad Hoc Example Financial Forecast Edit"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "12fd005b",
   "metadata": {},
   "source": [
    "I'm going to make a new function description that talks about updating a financial model. It'll take 3 params, year to update, category to update, and amount to update."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "fed0f289",
   "metadata": {},
   "outputs": [],
   "source": [
    "function_descriptions = [\n",
    "            {\n",
    "                \"name\": \"edit_financial_forecast\",\n",
    "                \"description\": \"Make an edit to a users financial forecast model\",\n",
    "                \"parameters\": {\n",
    "                    \"type\": \"object\",\n",
    "                    \"properties\": {\n",
    "                        \"year\": {\n",
    "                            \"type\": \"integer\",\n",
    "                            \"description\": \"The year the user would like to make an edit to their forecast for\",\n",
    "                        },\n",
    "                        \"category\": {\n",
    "                            \"type\": \"string\",\n",
    "                            \"description\": \"The category of the edit a user would like to edit\"\n",
    "                        },\n",
    "                        \"amount\": {\n",
    "                            \"type\": \"integer\",\n",
    "                            \"description\": \"The amount of units the user would like to change\"\n",
    "                        },\n",
    "                    },\n",
    "                    \"required\": [\"year\", \"category\", \"amount\"],\n",
    "                },\n",
    "            },\n",
    "            {\n",
    "                \"name\": \"print_financial_forecast\",\n",
    "                \"description\": \"Send the financial forecast to the printer\",\n",
    "                \"parameters\": {\n",
    "                    \"type\": \"object\",\n",
    "                    \"properties\": {\n",
    "                        \"printer_name\": {\n",
    "                            \"type\": \"string\",\n",
    "                            \"description\": \"the name of the printer that the forecast should be sent to\",\n",
    "                            \"enum\": [\"home_printer\", \"office_printer\"]\n",
    "                        }\n",
    "                    },\n",
    "                    \"required\": [\"printer_name\"],\n",
    "                },\n",
    "            }\n",
    "        ]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "2d43c0db",
   "metadata": {},
   "source": [
    "One of the cool parts about OpenAI's new function calls is that the LLM will decide if it should return a normal response to a user, or call the function again. Let's test this out with two different requests in the same query from the user"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "1d8033c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "user_request = \"\"\"\n",
    "Please do three things add 40 units to 2023 headcount\n",
    "and subtract 23 units from 2022 opex\n",
    "then print out the forecast at my home\n",
    "\"\"\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "255d1c12",
   "metadata": {},
   "source": [
    "We are going to keep track of the message history ourselves. As more support for function conversations comes in we won't need to do this.\n",
    "\n",
    "First we'll send the message from the user to the LLM along with our function calls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "ddc46318",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "AIMessage(content='', additional_kwargs={'function_call': {'name': 'edit_financial_forecast', 'arguments': '{\\n  \"year\": 2023,\\n  \"category\": \"headcount\",\\n  \"amount\": 40\\n}'}}, example=False)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first_response = llm.predict_messages([HumanMessage(content=user_request)],\n",
    "                                      functions=function_descriptions)\n",
    "first_response"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "8e81d80b",
   "metadata": {},
   "source": [
    "As you can see we get an AIMessage back with no content. However there are `additoinal_kwargs` with the information that we need. Let's pull these out to have a better look at them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "7722f24d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'function_call': {'name': 'edit_financial_forecast',\n",
       "  'arguments': '{\\n  \"year\": 2023,\\n  \"category\": \"headcount\",\\n  \"amount\": 40\\n}'}}"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first_response.additional_kwargs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "bb754ed6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'edit_financial_forecast'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_name = first_response.additional_kwargs[\"function_call\"][\"name\"]\n",
    "function_name"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "9b25db0b",
   "metadata": {},
   "source": [
    "Then print the arguments it gives back to us"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "172de619",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Year: 2023\n",
      "Category: headcount\n",
      "Amount: 40\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print (f\"\"\"\n",
    "Year: {eval(first_response.additional_kwargs['function_call']['arguments']).get('year')}\n",
    "Category: {eval(first_response.additional_kwargs['function_call']['arguments']).get('category')}\n",
    "Amount: {eval(first_response.additional_kwargs['function_call']['arguments']).get('amount')}\n",
    "\"\"\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "912a08ca",
   "metadata": {},
   "source": [
    "But we aren't done! There was a second request in the user query so let's pass it back into the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "daa08ebf",
   "metadata": {},
   "outputs": [],
   "source": [
    "second_response = llm.predict_messages([HumanMessage(content=user_request),\n",
    "                                        AIMessage(content=str(first_response.additional_kwargs)),\n",
    "                                        ChatMessage(role='function',\n",
    "                                                    additional_kwargs = {'name': function_name},\n",
    "                                                    content = \"Just updated the financial forecast for year 2023, category headcount amd amount 40\"\n",
    "                                                   )\n",
    "                                       ],\n",
    "                                       functions=function_descriptions)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "6a748f6b",
   "metadata": {},
   "source": [
    "Let's see the response from this one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "a015c49e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'function_call': {'name': 'edit_financial_forecast',\n",
       "  'arguments': '{\\n  \"year\": 2022,\\n  \"category\": \"opex\",\\n  \"amount\": -23\\n}'}}"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "second_response.additional_kwargs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "41c8bab8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'edit_financial_forecast'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_name = second_response.additional_kwargs['function_call']['name']\n",
    "function_name"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "74df9449",
   "metadata": {},
   "source": [
    "Cool! It saw that the first response was done and then it went back to our function for us. Let's see what it says if we do it a third time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "ff0cabd3",
   "metadata": {},
   "outputs": [],
   "source": [
    "third_response = llm.predict_messages([HumanMessage(content=user_request),\n",
    "                                       AIMessage(content=str(first_response.additional_kwargs)),\n",
    "                                       AIMessage(content=str(second_response.additional_kwargs)),\n",
    "                                       ChatMessage(role='function',\n",
    "                                                    additional_kwargs = {'name': function_name},\n",
    "                                                    content = \"\"\"\n",
    "                                                        Just made the following updates: 2022, opex -23 and\n",
    "                                                        Year: 2023\n",
    "                                                        Category: headcount\n",
    "                                                        Amount: 40\n",
    "                                                    \"\"\"\n",
    "                                                   )\n",
    "                                       ],\n",
    "                                       functions=function_descriptions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "4ee505df",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'function_call': {'name': 'print_financial_forecast',\n",
       "  'arguments': '{\\n  \"printer_name\": \"home_printer\"\\n}'}}"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "third_response.additional_kwargs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "aa33a75c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'print_financial_forecast'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_name = third_response.additional_kwargs['function_call']['name']\n",
    "function_name"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "ea1875f2",
   "metadata": {},
   "source": [
    "Nice! So it knew it was done with the financial forecasts (because we told it so) and then it sent our forecast to our home printer. Let's close it out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "b46f67ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "forth_response = llm.predict_messages([HumanMessage(content=user_request),\n",
    "                                       AIMessage(content=str(first_response.additional_kwargs)),\n",
    "                                       AIMessage(content=str(second_response.additional_kwargs)),\n",
    "                                       AIMessage(content=str(third_response.additional_kwargs)),\n",
    "                                       ChatMessage(role='function',\n",
    "                                                    additional_kwargs = {'name': function_name},\n",
    "                                                    content = \"\"\"\n",
    "                                                        just printed the document at home\n",
    "                                                    \"\"\"\n",
    "                                                   )\n",
    "                                       ],\n",
    "                                       functions=function_descriptions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "0bfd8982",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I have updated the financial forecast as per your instructions. It has also been printed at your home.'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "forth_response.content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "11a9d1e0",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}