AOAI_FunctionCalling.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Azure OpenAI - Function Calling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import required packages\n",
    "import openai\n",
    "import os\n",
    "import json\n",
    "import datetime\n",
    "import requests\n",
    "\n",
    "# Define Azure OpenAI endpoint parameters\n",
    "openai.api_type = \"azure\"\n",
    "openai.api_version = \"2023-07-01-preview\"\n",
    "    # openai.api_version = \"2023-05-15\"\n",
    "    # openai.api_version = \"2023-03-15-preview\"\n",
    "openai.api_base = os.getenv(\"OPENAI_API_BASE\") # Set AOAI endpoint value as env variable\n",
    "openai.api_key = os.getenv(\"OPENAI_API_KEY\") # Set AOAI API key as env variable\n",
    "aoai_deployment = os.getenv(\"OPENAI_API_DEPLOY\") # Set AOAI deployment name as env variable\n",
    "\n",
    "# Define Alpha Vantage API parameter\n",
    "av_api_key = os.getenv(\"ALPHAVANTAGE_API_KEY\") # Set Alpha Vantage API key as env variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Testing stock retrieval from Alpha Vantage API"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2023-07-23'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get current date\n",
    "today = datetime.date.today().strftime(\"%Y-%m-%d\")\n",
    "today"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to get stock price from Alpha Vantage API\n",
    "def get_stock_price(symbol, date):\n",
    "    print(f\"Getting stock price for {symbol} on {date}\")\n",
    "    try:\n",
    "        stock_url = f\"https://www.alphavantage.co/query?function=TIME_SERIES_DAILY&symbol={symbol}&apikey={av_api_key}\"\n",
    "        stock_data = requests.get(stock_url)\n",
    "        stock_low = stock_data.json()[\"Time Series (Daily)\"][date][\"3. low\"]\n",
    "        stock_high = stock_data.json()[\"Time Series (Daily)\"][date][\"2. high\"]\n",
    "        return stock_low, stock_high\n",
    "    except:\n",
    "        return \"NA\", \"NA\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Getting stock price for MSFT on 2023-07-23\n",
      "NA NA\n"
     ]
    }
   ],
   "source": [
    "# Testing stock price function\n",
    "stock_low, stock_high = get_stock_price(\"MSFT\", today)\n",
    "print(stock_low, stock_high)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Describing available functions to GPT model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Describing required parameters for available functions\n",
    "functions = [\n",
    "    {\n",
    "        \"name\": \"get_stock_price\",\n",
    "        \"description\": \"Retrieve lowest and highest stock price for a given stock symbol and date\",\n",
    "        \"parameters\": {\n",
    "            \"type\": \"object\",\n",
    "            \"properties\": {\n",
    "                \"symbol\": {\n",
    "                    \"type\": \"string\",\n",
    "                    \"description\": \"Stock symbol, for example MSFT for Microsoft\"\n",
    "                },\n",
    "                \"date\": {\n",
    "                    \"type\": \"string\",\n",
    "                    \"description\": \"Date in YYYY-MM-DD format\"\n",
    "                }\n",
    "            },\n",
    "            \"required\": [\"symbol\", \"date\"],\n",
    "        }   \n",
    "    }\n",
    "]\n",
    "\n",
    "available_functions = {\n",
    "    \"get_stock_price\": get_stock_price,\n",
    "} "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Helper functions\n",
    "(Adopted from https://github.com/Azure-Samples/openai/tree/main/Basic_Samples/Functions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import inspect\n",
    "\n",
    "# Helper method used to check if the correct arguments are provided to a function\n",
    "def check_args(function, args):\n",
    "    sig = inspect.signature(function)\n",
    "    params = sig.parameters\n",
    "\n",
    "    # Check if there are extra arguments\n",
    "    for name in args:\n",
    "        if name not in params:\n",
    "            return False\n",
    "    # Check if the required arguments are provided \n",
    "    for name, param in params.items():\n",
    "        if param.default is param.empty and name not in args:\n",
    "            return False\n",
    "\n",
    "    return True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_conversation(messages, functions, available_functions, deployment_id):\n",
    "    \n",
    "    # Step 1: Send the conversation and available functions to GPT\n",
    "    response = openai.ChatCompletion.create(\n",
    "        deployment_id=aoai_deployment,\n",
    "        messages=messages,\n",
    "        functions=functions,\n",
    "        function_call=\"auto\", \n",
    "    )\n",
    "    response_message = response[\"choices\"][0][\"message\"]\n",
    "\n",
    "    # Step 2: Check if GPT model wanted to call a function\n",
    "    if response_message.get(\"function_call\"):\n",
    "        print(\"Recommended function call:\")\n",
    "        print(response_message.get(\"function_call\"))\n",
    "        print()\n",
    "        \n",
    "        # Step 3: call the function\n",
    "\n",
    "        # Note: the JSON response may not always be valid; be sure to handle errors        \n",
    "        function_name = response_message[\"function_call\"][\"name\"]\n",
    "        \n",
    "        # Verify that function exists\n",
    "        if function_name not in available_functions:\n",
    "            return \"Function \" + function_name + \" does not exist\"\n",
    "        function_to_call = available_functions[function_name] \n",
    "        \n",
    "        # Verify function has correct number of arguments\n",
    "        function_args = json.loads(response_message[\"function_call\"][\"arguments\"])\n",
    "        function_args = {k : v for k, v in function_args.items() if v != \"\"}\n",
    "\n",
    "        if check_args(function_to_call, function_args) is False:\n",
    "            return \"Invalid number of arguments for function: \" + function_name\n",
    "        \n",
    "        function_response1, function_response2 = function_to_call(function_args[\"symbol\"], function_args[\"date\"])\n",
    "        function_response = f\"Lowest stock price: {function_response1}, Highest stock price: {function_response2}\"\n",
    "        \n",
    "        print(\"Output of function call:\")\n",
    "        print(function_response)\n",
    "        print()\n",
    "        \n",
    "        # Step 4: send the info on the function call and function response to GPT\n",
    "        \n",
    "        # Adding assistant response to messages\n",
    "        messages.append(\n",
    "            {\n",
    "                \"role\": \"assistant\",\n",
    "                \"name\": function_name,\n",
    "                \"content\": response_message[\"function_call\"][\"arguments\"],\n",
    "            }\n",
    "        )\n",
    "\n",
    "        # Adding function response to messages\n",
    "        messages.append(\n",
    "            {\n",
    "                \"role\": \"function\",\n",
    "                \"name\": function_name,\n",
    "                \"content\": function_response,\n",
    "            }\n",
    "        )\n",
    "\n",
    "        # Complete messages with function response\n",
    "        print(\"Messages in second request:\")\n",
    "        for message in messages:\n",
    "            print(message)\n",
    "        print()\n",
    "\n",
    "        # Retrieval of second response from GPT\n",
    "        second_response = openai.ChatCompletion.create(\n",
    "            messages=messages,\n",
    "            deployment_id=aoai_deployment\n",
    "        )  \n",
    "        return second_response"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Practical testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recommended function call:\n",
      "{\n",
      "  \"name\": \"get_stock_price\",\n",
      "  \"arguments\": \"{\\n  \\\"symbol\\\": \\\"MSFT\\\",\\n  \\\"date\\\": \\\"2023-07-20\\\"\\n}\"\n",
      "}\n",
      "\n",
      "Getting stock price for MSFT on 2023-07-20\n",
      "Output of function call:\n",
      "Lowest stock price: 345.3700, Highest stock price: 357.9700\n",
      "\n",
      "Messages in second request:\n",
      "{'role': 'user', 'content': 'What was the stock price of Microsoft shares on 20th of July 2023?'}\n",
      "{'role': 'assistant', 'name': 'get_stock_price', 'content': '{\\n  \"symbol\": \"MSFT\",\\n  \"date\": \"2023-07-20\"\\n}'}\n",
      "{'role': 'function', 'name': 'get_stock_price', 'content': 'Lowest stock price: 345.3700, Highest stock price: 357.9700'}\n",
      "\n",
      "{\n",
      "  \"role\": \"assistant\",\n",
      "  \"content\": \"On the 20th of July 2023, the stock price of Microsoft (MSFT) had a low of $345.37 and a high of $357.97.\"\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "messages = [{\"role\": \"user\", \"content\": \"What was the stock price of Microsoft shares on 20th of July 2023?\"}]\n",
    "assistant_response = run_conversation(messages, functions, available_functions, aoai_deployment)\n",
    "print(assistant_response['choices'][0]['message'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.10"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}