OpenAI-Completion-function-tools.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "3mMp_NIgaCDR",
      "metadata": {
        "id": "3mMp_NIgaCDR"
      },
      "source": [
        "# External API with function calling"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3e67f200",
      "metadata": {
        "id": "3e67f200"
      },
      "source": [
        "# How to call functions with chat models\n",
        "\n",
        "This notebook covers how to use the Chat Completions API in combination with external functions to extend the capabilities of GPT models.\n",
        "\n",
        "`tools` is an optional parameter in the Chat Completion API which can be used to provide function specifications. The purpose of this is to enable models to generate function arguments which adhere to the provided specifications. Note that the API will not actually execute any function calls. It is up to developers to execute function calls using model outputs.\n",
        "\n",
        "Within the `tools` parameter, if the `functions` parameter is provided then by default the model will decide when it is appropriate to use one of the functions. The API can be forced to use a specific function by setting the `tool_choice` parameter to `{\"type\": \"function\", \"function\": {\"name\": \"my_function\"}}`. The API can also be forced to not use any function by setting the `tool_choice` parameter to `\"none\"`. If a function is used, the output will contain `\"finish_reason\": \"tool_calls\"` in the response, as well as a `tool_calls` object that has the name of the function and the generated function arguments.\n",
        "\n",
        "### Overview\n",
        "\n",
        "This notebook contains the following 2 sections:\n",
        "\n",
        "- **How to generate function arguments:** Specify a set of functions and use the API to generate function arguments.\n",
        "- **How to call functions with model generated arguments:** Close the loop by actually executing functions with model generated arguments."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "64c85e26",
      "metadata": {
        "id": "64c85e26"
      },
      "source": [
        "## How to generate function arguments"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "80e71f33",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "80e71f33",
        "outputId": "905f2d19-3164-4299-eb08-d11ba91e78e2",
        "pycharm": {
          "is_executing": true
        }
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.8/1.8 MB\u001b[0m \u001b[31m11.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m257.5/257.5 kB\u001b[0m \u001b[31m5.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m75.6/75.6 kB\u001b[0m \u001b[31m5.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m77.8/77.8 kB\u001b[0m \u001b[31m9.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m58.3/58.3 kB\u001b[0m \u001b[31m7.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h"
          ]
        }
      ],
      "source": [
        "!pip install scipy --quiet\n",
        "!pip install tenacity --quiet\n",
        "!pip install tiktoken --quiet\n",
        "!pip install termcolor --quiet\n",
        "!pip install openai --quiet"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "dab872c5",
      "metadata": {
        "id": "dab872c5"
      },
      "outputs": [],
      "source": [
        "import json\n",
        "from openai import OpenAI\n",
        "from tenacity import retry, wait_random_exponential, stop_after_attempt\n",
        "from termcolor import colored\n",
        "\n",
        "from google.colab import userdata\n",
        "oaikey = userdata.get('oaikey')\n",
        "\n",
        "GPT_MODEL = \"gpt-3.5-turbo-0613\"\n",
        "client = OpenAI(api_key=oaikey)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "mlDsL1hkb6pw",
      "metadata": {
        "id": "mlDsL1hkb6pw"
      },
      "source": []
    },
    {
      "cell_type": "markdown",
      "id": "69ee6a93",
      "metadata": {
        "id": "69ee6a93"
      },
      "source": [
        "### Utilities\n",
        "\n",
        "First let's define a few utilities for making calls to the Chat Completions API and for maintaining and keeping track of the conversation state."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "745ceec5",
      "metadata": {
        "id": "745ceec5"
      },
      "outputs": [],
      "source": [
        "@retry(wait=wait_random_exponential(multiplier=1, max=40), stop=stop_after_attempt(3))\n",
        "def chat_completion_request(messages, tools=None, tool_choice=None, model=GPT_MODEL):\n",
        "    try:\n",
        "        response = client.chat.completions.create(\n",
        "            model=model,\n",
        "            messages=messages,\n",
        "            tools=tools,\n",
        "            tool_choice=tool_choice,\n",
        "        )\n",
        "        return response\n",
        "    except Exception as e:\n",
        "        print(\"Unable to generate ChatCompletion response\")\n",
        "        print(f\"Exception: {e}\")\n",
        "        return e\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "id": "c4d1c99f",
      "metadata": {
        "id": "c4d1c99f"
      },
      "outputs": [],
      "source": [
        "def pretty_print_conversation(messages):\n",
        "    role_to_color = {\n",
        "        \"system\": \"red\",\n",
        "        \"user\": \"green\",\n",
        "        \"assistant\": \"blue\",\n",
        "        \"function\": \"magenta\",\n",
        "    }\n",
        "\n",
        "    for message in messages:\n",
        "        if message[\"role\"] == \"system\":\n",
        "            print(colored(f\"system: {message['content']}\\n\", role_to_color[message[\"role\"]]))\n",
        "        elif message[\"role\"] == \"user\":\n",
        "            print(colored(f\"user: {message['content']}\\n\", role_to_color[message[\"role\"]]))\n",
        "        elif message[\"role\"] == \"assistant\" and message.get(\"function_call\"):\n",
        "            print(colored(f\"assistant: {message['function_call']}\\n\", role_to_color[message[\"role\"]]))\n",
        "        elif message[\"role\"] == \"assistant\" and not message.get(\"function_call\"):\n",
        "            print(colored(f\"assistant: {message['content']}\\n\", role_to_color[message[\"role\"]]))\n",
        "        elif message[\"role\"] == \"function\":\n",
        "            print(colored(f\"function ({message['name']}): {message['content']}\\n\", role_to_color[message[\"role\"]]))\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "29d4e02b",
      "metadata": {
        "id": "29d4e02b"
      },
      "source": [
        "### Basic concepts\n",
        "\n",
        "Let's create some function specifications to interface with a hypothetical weather API. We'll pass these function specification to the Chat Completions API in order to generate function arguments that adhere to the specification."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 41,
      "id": "d2e25069",
      "metadata": {
        "id": "d2e25069"
      },
      "outputs": [],
      "source": [
        "tools = [\n",
        "    {\n",
        "        \"type\": \"function\",\n",
        "        \"function\": {\n",
        "            \"name\": \"get_current_weather\",\n",
        "            \"description\": \"Get the current weather\",\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",
        "                    \"format\": {\n",
        "                        \"type\": \"string\",\n",
        "                        \"enum\": [\"celsius\", \"fahrenheit\"],\n",
        "                        \"description\": \"The temperature unit to use. Infer this from the users location.\",\n",
        "                    },\n",
        "                },\n",
        "                \"required\": [\"location\", \"format\"],\n",
        "            },\n",
        "        }\n",
        "    },\n",
        "    {\n",
        "        \"type\": \"function\",\n",
        "        \"function\": {\n",
        "            \"name\": \"get_n_day_weather_forecast\",\n",
        "            \"description\": \"Get an N-day weather forecast\",\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",
        "                    \"format\": {\n",
        "                        \"type\": \"string\",\n",
        "                        \"enum\": [\"celsius\", \"fahrenheit\"],\n",
        "                        \"description\": \"The temperature unit to use. Infer this from the users location.\",\n",
        "                    },\n",
        "                    \"num_days\": {\n",
        "                        \"type\": \"integer\",\n",
        "                        \"description\": \"The number of days to forecast\",\n",
        "                    }\n",
        "                },\n",
        "                \"required\": [\"location\", \"format\", \"num_days\"]\n",
        "            },\n",
        "        }\n",
        "    },\n",
        "]"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "bfc39899",
      "metadata": {
        "id": "bfc39899"
      },
      "source": [
        "If we prompt the model about the current weather, it will respond with some clarifying questions."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "518d6827",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "518d6827",
        "outputId": "7353f87a-aa71-4e17-9c91-c8b0d3e2de01"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "ChatCompletionMessage(content='Sure, I can help you with that. Could you please provide me with your location?', role='assistant', function_call=None, tool_calls=None)"
            ]
          },
          "execution_count": 7,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "messages = []\n",
        "messages.append({\"role\": \"system\", \"content\": \"Don't make assumptions about what values to plug into functions. Ask for clarification if a user request is ambiguous.\"})\n",
        "messages.append({\"role\": \"user\", \"content\": \"What's the weather like today\"})\n",
        "chat_response = chat_completion_request(\n",
        "    messages, tools=tools\n",
        ")\n",
        "assistant_message = chat_response.choices[0].message\n",
        "messages.append(assistant_message)\n",
        "assistant_message\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "4c999375",
      "metadata": {
        "id": "4c999375"
      },
      "source": [
        "Once we provide the missing information, it will generate the appropriate function arguments for us."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "23c42a6e",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "23c42a6e",
        "outputId": "525b0cb6-0454-412f-9b05-7fb54894b501"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "ChatCompletionMessage(content=None, role='assistant', function_call=None, tool_calls=[ChatCompletionMessageToolCall(id='call_1b2ywBM6Pa7VuPjUbgYZ3WEq', function=Function(arguments='{\\n  \"location\": \"Glasgow, Scotland\",\\n  \"format\": \"celsius\"\\n}', name='get_current_weather'), type='function')])"
            ]
          },
          "execution_count": 8,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "messages.append({\"role\": \"user\", \"content\": \"I'm in Glasgow, Scotland.\"})\n",
        "chat_response = chat_completion_request(\n",
        "    messages, tools=tools\n",
        ")\n",
        "assistant_message = chat_response.choices[0].message\n",
        "messages.append(assistant_message)\n",
        "assistant_message\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c14d4762",
      "metadata": {
        "id": "c14d4762"
      },
      "source": [
        "By prompting it differently, we can get it to target the other function we've told it about."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "fa232e54",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fa232e54",
        "outputId": "70de157a-7ef1-4f5c-8883-43f860ec994a"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "ChatCompletionMessage(content='Sure, I can help you with that. Could you please let me know how many days you would like to check the weather for?', role='assistant', function_call=None, tool_calls=None)"
            ]
          },
          "execution_count": 9,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "messages = []\n",
        "messages.append({\"role\": \"system\", \"content\": \"Don't make assumptions about what values to plug into functions. Ask for clarification if a user request is ambiguous.\"})\n",
        "messages.append({\"role\": \"user\", \"content\": \"what is the weather going to be like in Glasgow, Scotland over the next x days\"})\n",
        "chat_response = chat_completion_request(\n",
        "    messages, tools=tools\n",
        ")\n",
        "assistant_message = chat_response.choices[0].message\n",
        "messages.append(assistant_message)\n",
        "assistant_message\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6172ddac",
      "metadata": {
        "id": "6172ddac"
      },
      "source": [
        "Once again, the model is asking us for clarification because it doesn't have enough information yet. In this case it already knows the location for the forecast, but it needs to know how many days are required in the forecast."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "c7d8a543",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c7d8a543",
        "outputId": "416f0b13-de0f-4d31-c57b-a3239546d3f4"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "Choice(finish_reason='tool_calls', index=0, logprobs=None, message=ChatCompletionMessage(content=None, role='assistant', function_call=None, tool_calls=[ChatCompletionMessageToolCall(id='call_YRQAKvelX1ya8oUu5oL0lH8Y', function=Function(arguments='{\\n  \"location\": \"Glasgow, Scotland\",\\n  \"format\": \"celsius\",\\n  \"num_days\": 5\\n}', name='get_n_day_weather_forecast'), type='function')]))"
            ]
          },
          "execution_count": 10,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "messages.append({\"role\": \"user\", \"content\": \"5 days\"})\n",
        "chat_response = chat_completion_request(\n",
        "    messages, tools=tools\n",
        ")\n",
        "chat_response.choices[0]\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "4b758a0a",
      "metadata": {
        "id": "4b758a0a"
      },
      "source": [
        "#### Forcing the use of specific functions or no function"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "412f79ba",
      "metadata": {
        "id": "412f79ba"
      },
      "source": [
        "We can force the model to use a specific function, for example get_n_day_weather_forecast by using the function_call argument. By doing so, we force the model to make assumptions about how to use it."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "559371b7",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "559371b7",
        "outputId": "ad01e43e-aa74-4275-ee6e-3c3f10f6ce95"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "ChatCompletionMessage(content=None, role='assistant', function_call=None, tool_calls=[ChatCompletionMessageToolCall(id='call_dLC1hv40vDxNelW0EawdKTmO', function=Function(arguments='{\\n  \"location\": \"Toronto, Canada\",\\n  \"format\": \"celsius\",\\n  \"num_days\": 1\\n}', name='get_n_day_weather_forecast'), type='function')])"
            ]
          },
          "execution_count": 11,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# in this cell we force the model to use get_n_day_weather_forecast\n",
        "messages = []\n",
        "messages.append({\"role\": \"system\", \"content\": \"Don't make assumptions about what values to plug into functions. Ask for clarification if a user request is ambiguous.\"})\n",
        "messages.append({\"role\": \"user\", \"content\": \"Give me a weather report for Toronto, Canada.\"})\n",
        "chat_response = chat_completion_request(\n",
        "    messages, tools=tools, tool_choice={\"type\": \"function\", \"function\": {\"name\": \"get_n_day_weather_forecast\"}}\n",
        ")\n",
        "chat_response.choices[0].message"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "a7ab0f58",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a7ab0f58",
        "outputId": "fefd4ae7-3993-434f-c2c0-eb6a7adf0343"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "ChatCompletionMessage(content=\"I'm sorry, I don't have the capability to provide weather reports. However, you can easily find a weather report for Toronto, Canada by using a search engine or a weather app on your phone.\", role='assistant', function_call=None, tool_calls=None)"
            ]
          },
          "execution_count": 25,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# if we don't force the model to use get_n_day_weather_forecast it may not\n",
        "messages = []\n",
        "messages.append({\"role\": \"system\", \"content\": \"Don't make assumptions about what values to plug into functions. Ask for clarification if a user request is ambiguous.\"})\n",
        "messages.append({\"role\": \"user\", \"content\": \"Give me a weather report for Toronto, Canada.\"})\n",
        "chat_response = chat_completion_request(\n",
        "    messages, tools=tools\n",
        ")\n",
        "chat_response.choices[0].message"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3bd70e48",
      "metadata": {
        "id": "3bd70e48"
      },
      "source": [
        "We can also force the model to not use a function at all. By doing so we prevent it from producing a proper function call."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "acfe54e6",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "acfe54e6",
        "outputId": "1e279d20-b3ad-41b6-e6b8-99d072d7ae10"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "ChatCompletionMessage(content='Okay, I will get the current weather for Toronto, Canada in Celsius.', role='assistant', function_call=None, tool_calls=None)"
            ]
          },
          "execution_count": 13,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "messages = []\n",
        "messages.append({\"role\": \"system\", \"content\": \"Don't make assumptions about what values to plug into functions. Ask for clarification if a user request is ambiguous.\"})\n",
        "messages.append({\"role\": \"user\", \"content\": \"Give me the current weather (use Celcius) for Toronto, Canada.\"})\n",
        "chat_response = chat_completion_request(\n",
        "    messages, tools=tools, tool_choice=\"none\"\n",
        ")\n",
        "chat_response.choices[0].message\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b616353b",
      "metadata": {
        "id": "b616353b"
      },
      "source": [
        "### Parallel Function Calling\n",
        "\n",
        "Newer models like gpt-4-1106-preview or gpt-3.5-turbo-1106 can call multiple functions in one turn."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "380eeb68",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "380eeb68",
        "outputId": "d1c169cc-0ede-4047-8267-2e451b876430"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[ChatCompletionMessageToolCall(id='call_5bJ2zj3H4zu3ABqGVRlAGcjS', function=Function(arguments='{\"location\": \"San Francisco, CA\", \"format\": \"celsius\", \"num_days\": 4}', name='get_n_day_weather_forecast'), type='function'),\n",
              " ChatCompletionMessageToolCall(id='call_aZ73g3bdGsWGs4bruWHvjV2W', function=Function(arguments='{\"location\": \"Glasgow\", \"format\": \"celsius\", \"num_days\": 4}', name='get_n_day_weather_forecast'), type='function')]"
            ]
          },
          "execution_count": 14,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "messages = []\n",
        "messages.append({\"role\": \"system\", \"content\": \"Don't make assumptions about what values to plug into functions. Ask for clarification if a user request is ambiguous.\"})\n",
        "messages.append({\"role\": \"user\", \"content\": \"what is the weather going to be like in San Francisco and Glasgow over the next 4 days\"})\n",
        "chat_response = chat_completion_request(\n",
        "    messages, tools=tools, model='gpt-3.5-turbo-1106'\n",
        ")\n",
        "\n",
        "assistant_message = chat_response.choices[0].message.tool_calls\n",
        "assistant_message"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b4482aee",
      "metadata": {
        "id": "b4482aee"
      },
      "source": [
        "## How to call functions with model generated arguments\n",
        "\n",
        "In our next example, we'll demonstrate how to execute functions whose inputs are model-generated, and use this to implement an agent that can answer questions for us about a database. For simplicity we'll use the [Chinook sample database](https://www.sqlitetutorial.net/sqlite-sample-database/).\n",
        "\n",
        "*Note:* SQL generation can be high-risk in a production environment since models are not perfectly reliable at generating correct SQL."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f7654fef",
      "metadata": {
        "id": "f7654fef"
      },
      "source": [
        "### Specifying a function to execute SQL queries\n",
        "\n",
        "First let's define some helpful utility functions to extract data from a SQLite database."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 59,
      "id": "30f6b60e",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "30f6b60e",
        "outputId": "2e14257f-9166-4066-b87f-4d2d701ec838"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Opened database successfully\n"
          ]
        }
      ],
      "source": [
        "import sqlite3\n",
        "\n",
        "conn = sqlite3.connect(\"chinook.db\")\n",
        "print(\"Opened database successfully\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 60,
      "id": "abec0214",
      "metadata": {
        "id": "abec0214"
      },
      "outputs": [],
      "source": [
        "def get_table_names(conn):\n",
        "    \"\"\"Return a list of table names.\"\"\"\n",
        "    table_names = []\n",
        "    tables = conn.execute(\"SELECT name FROM sqlite_master WHERE type='table';\")\n",
        "    for table in tables.fetchall():\n",
        "        table_names.append(table[0])\n",
        "    return table_names\n",
        "\n",
        "\n",
        "def get_column_names(conn, table_name):\n",
        "    \"\"\"Return a list of column names.\"\"\"\n",
        "    column_names = []\n",
        "    columns = conn.execute(f\"PRAGMA table_info('{table_name}');\").fetchall()\n",
        "    for col in columns:\n",
        "        column_names.append(col[1])\n",
        "    return column_names\n",
        "\n",
        "\n",
        "def get_database_info(conn):\n",
        "    \"\"\"Return a list of dicts containing the table name and columns for each table in the database.\"\"\"\n",
        "    table_dicts = []\n",
        "    for table_name in get_table_names(conn):\n",
        "        columns_names = get_column_names(conn, table_name)\n",
        "        table_dicts.append({\"table_name\": table_name, \"column_names\": columns_names})\n",
        "    return table_dicts\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "77e6e5ea",
      "metadata": {
        "id": "77e6e5ea"
      },
      "source": [
        "Now can use these utility functions to extract a representation of the database schema."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 61,
      "id": "0c0104cd",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 174
        },
        "id": "0c0104cd",
        "outputId": "5b0f0b54-babe-40f7-ba39-92caf74ccb08"
      },
      "outputs": [
        {
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Table: albums\\nColumns: AlbumId, Title, ArtistId\\nTable: sqlite_sequence\\nColumns: name, seq\\nTable: artists\\nColumns: ArtistId, Name\\nTable: customers\\nColumns: CustomerId, FirstName, LastName, Company, Address, City, State, Country, PostalCode, Phone, Fax, Email, SupportRepId\\nTable: employees\\nColumns: EmployeeId, LastName, FirstName, Title, ReportsTo, BirthDate, HireDate, Address, City, State, Country, PostalCode, Phone, Fax, Email\\nTable: genres\\nColumns: GenreId, Name\\nTable: invoices\\nColumns: InvoiceId, CustomerId, InvoiceDate, BillingAddress, BillingCity, BillingState, BillingCountry, BillingPostalCode, Total\\nTable: invoice_items\\nColumns: InvoiceLineId, InvoiceId, TrackId, UnitPrice, Quantity\\nTable: media_types\\nColumns: MediaTypeId, Name\\nTable: playlists\\nColumns: PlaylistId, Name\\nTable: playlist_track\\nColumns: PlaylistId, TrackId\\nTable: tracks\\nColumns: TrackId, Name, AlbumId, MediaTypeId, GenreId, Composer, Milliseconds, Bytes, UnitPrice\\nTable: sqlite_stat1\\nColumns: tbl, idx, stat'"
            ]
          },
          "execution_count": 61,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "database_schema_dict = get_database_info(conn)\n",
        "database_schema_string = \"\\n\".join(\n",
        "    [\n",
        "        f\"Table: {table['table_name']}\\nColumns: {', '.join(table['column_names'])}\"\n",
        "        for table in database_schema_dict\n",
        "    ]\n",
        ")\n",
        "database_schema_string"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "ae73c9ee",
      "metadata": {
        "id": "ae73c9ee"
      },
      "source": [
        "As before, we'll define a function specification for the function we'd like the API to generate arguments for. Notice that we are inserting the database schema into the function specification. This will be important for the model to know about."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 62,
      "id": "0258813a",
      "metadata": {
        "id": "0258813a"
      },
      "outputs": [],
      "source": [
        "tools = [\n",
        "    {\n",
        "        \"type\": \"function\",\n",
        "        \"function\": {\n",
        "            \"name\": \"ask_database\",\n",
        "            \"description\": \"Use this function to answer user questions about music. Input should be a fully formed SQL query.\",\n",
        "            \"parameters\": {\n",
        "                \"type\": \"object\",\n",
        "                \"properties\": {\n",
        "                    \"query\": {\n",
        "                        \"type\": \"string\",\n",
        "                        \"description\": f\"\"\"\n",
        "                                SQL query extracting info to answer the user's question.\n",
        "                                SQL should be written using this database schema:\n",
        "                                {database_schema_string}\n",
        "                                The query should be returned in plain text, not in JSON.\n",
        "                                \"\"\",\n",
        "                    }\n",
        "                },\n",
        "                \"required\": [\"query\"],\n",
        "            },\n",
        "        }\n",
        "    }\n",
        "]"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "da08c121",
      "metadata": {
        "id": "da08c121"
      },
      "source": [
        "### Executing SQL queries\n",
        "\n",
        "Now let's implement the function that will actually excute queries against the database."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 63,
      "id": "65585e74",
      "metadata": {
        "id": "65585e74"
      },
      "outputs": [],
      "source": [
        "def ask_database(conn, query):\n",
        "    \"\"\"Function to query SQLite database with a provided SQL query.\"\"\"\n",
        "    try:\n",
        "        results = str(conn.execute(query).fetchall())\n",
        "    except Exception as e:\n",
        "        results = f\"query failed with error: {e}\"\n",
        "    return results\n",
        "\n",
        "def execute_function_call(message):\n",
        "    if message.tool_calls[0].function.name == \"ask_database\":\n",
        "        query = json.loads(message.tool_calls[0].function.arguments)[\"query\"]\n",
        "        results = ask_database(conn, query)\n",
        "    else:\n",
        "        results = f\"Error: function {message.tool_calls[0].function.name} does not exist\"\n",
        "    return results"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 64,
      "id": "38c55083",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "38c55083",
        "outputId": "83da5471-cda6-400e-a296-563b743718d9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "system: Answer user questions by generating SQL queries against the Chinook Music Database.\n",
            "\n",
            "user: Hi, who are the top 5 artists by number of tracks?\n",
            "\n",
            "assistant: Function(arguments='{\\n  \"query\": \"SELECT artists.Name, COUNT(tracks.TrackId) AS TrackCount FROM artists JOIN albums ON artists.ArtistId = albums.ArtistId JOIN tracks ON albums.AlbumId = tracks.AlbumId GROUP BY artists.Name ORDER BY TrackCount DESC LIMIT 5;\"\\n}', name='ask_database')\n",
            "\n",
            "function (ask_database): [('Iron Maiden', 213), ('U2', 135), ('Led Zeppelin', 114), ('Metallica', 112), ('Lost', 92)]\n",
            "\n"
          ]
        }
      ],
      "source": [
        "messages = []\n",
        "messages.append({\"role\": \"system\", \"content\": \"Answer user questions by generating SQL queries against the Chinook Music Database.\"})\n",
        "messages.append({\"role\": \"user\", \"content\": \"Hi, who are the top 5 artists by number of tracks?\"})\n",
        "chat_response = chat_completion_request(messages, tools)\n",
        "assistant_message = chat_response.choices[0].message\n",
        "assistant_message.content = str(assistant_message.tool_calls[0].function)\n",
        "messages.append({\"role\": assistant_message.role, \"content\": assistant_message.content})\n",
        "if assistant_message.tool_calls:\n",
        "    results = execute_function_call(assistant_message)\n",
        "    messages.append({\"role\": \"function\", \"tool_call_id\": assistant_message.tool_calls[0].id, \"name\": assistant_message.tool_calls[0].function.name, \"content\": results})\n",
        "pretty_print_conversation(messages)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 54,
      "id": "710481dc",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "710481dc",
        "outputId": "d1c304b2-2b3e-45f3-890c-c58e3f6237ae",
        "scrolled": true
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "system: Answer user questions by generating SQL queries against the Chinook Music Database.\n",
            "\n",
            "user: Hi, who are the top 5 artists by number of tracks?\n",
            "\n",
            "assistant: Function(arguments='{\\n  \"query\": \"SELECT artists.Name, COUNT(tracks.TrackId) as NumTracks FROM artists JOIN albums ON artists.ArtistId = albums.ArtistId JOIN tracks ON albums.AlbumId = tracks.AlbumId GROUP BY artists.ArtistId ORDER BY NumTracks DESC LIMIT 5\"\\n}', name='ask_database')\n",
            "\n",
            "function (ask_database): query failed with error: no such table: artists\n",
            "\n",
            "user: What is the name of the album with the most tracks?\n",
            "\n",
            "assistant: Function(arguments='{\\n  \"query\": \"SELECT albums.Title, COUNT(tracks.TrackId) as NumTracks FROM albums JOIN tracks ON albums.AlbumId = tracks.AlbumId GROUP BY albums.AlbumId ORDER BY NumTracks DESC LIMIT 1\"\\n}', name='ask_database')\n",
            "\n",
            "function (ask_database): query failed with error: no such table: albums\n",
            "\n"
          ]
        }
      ],
      "source": [
        "messages.append({\"role\": \"user\", \"content\": \"What is the name of the album with the most tracks?\"})\n",
        "chat_response = chat_completion_request(messages, tools)\n",
        "assistant_message = chat_response.choices[0].message\n",
        "assistant_message.content = str(assistant_message.tool_calls[0].function)\n",
        "messages.append({\"role\": assistant_message.role, \"content\": assistant_message.content})\n",
        "if assistant_message.tool_calls:\n",
        "    results = execute_function_call(assistant_message)\n",
        "    messages.append({\"role\": \"function\", \"tool_call_id\": assistant_message.tool_calls[0].id, \"name\": assistant_message.tool_calls[0].function.name, \"content\": results})\n",
        "pretty_print_conversation(messages)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "Nc17cckta6B4",
      "metadata": {
        "id": "Nc17cckta6B4"
      },
      "source": [
        "# External API with function calling"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "BOj4cVJ5kNzP",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BOj4cVJ5kNzP",
        "outputId": "aaa20e25-add1-4a55-b73c-3d77d42f1b1b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (2.31.0)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests) (3.3.2)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests) (3.6)\n",
            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests) (2.0.7)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests) (2024.2.2)\n"
          ]
        }
      ],
      "source": [
        "!pip install requests"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "kpPlxBcda60J",
      "metadata": {
        "id": "kpPlxBcda60J"
      },
      "outputs": [],
      "source": [
        "import requests\n",
        "from google.colab import userdata\n",
        "nasakey = userdata.get('nasakey')\n",
        "NASA_API_KEY = nasakey\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "8315bdfa",
      "metadata": {},
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": 69,
      "id": "jtDBx55CbEjS",
      "metadata": {
        "id": "jtDBx55CbEjS"
      },
      "outputs": [],
      "source": [
        "def get_celestial_events(query=None):\n",
        "    \"\"\"Get today's celestial events from the NASA API\"\"\"\n",
        "    response = requests.get(f\"https://api.nasa.gov/planetary/apod?api_key={NASA_API_KEY}\")\n",
        "    data = response.json()\n",
        "    return data\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 88,
      "id": "qKdV_7fWbN5e",
      "metadata": {
        "id": "qKdV_7fWbN5e"
      },
      "outputs": [],
      "source": [
        "def execute_function_call_celestial(message):\n",
        "    if message.tool_calls[0].function.name == \"get_celestial_events\":\n",
        "        # query = json.loads(message.tool_calls[0].function.arguments)[\"query\"]\n",
        "        results = get_celestial_events()\n",
        "    else:\n",
        "        results = f\"Error: function {message.tool_calls[0].function.name} does not exist\"\n",
        "    return results\n",
        "\n",
        "messages = []\n",
        "def run_conversation():\n",
        "    messages.append({\"role\": \"user\", \"content\": \"What are today's celestial events?\"})\n",
        "    response = chat_completion_request(\n",
        "        messages=messages,\n",
        "        tools=[ {\n",
        "        \"type\": \"function\",\n",
        "        \"function\":\n",
        "                {\n",
        "                \"name\": \"get_celestial_events\",\n",
        "                \"description\": \"Get today's celestial events from the NASA API\",\n",
        "                \"parameters\": {\n",
        "                    \"type\": \"object\",\n",
        "                    \"properties\": {}\n",
        "                }\n",
        "            }\n",
        "        }\n",
        "        ]\n",
        "    )\n",
        "\n",
        "\n",
        "    message = response.choices[0].message\n",
        "\n",
        "    print('res ', response)\n",
        "    print('choice message', message)\n",
        "\n",
        "    if message and message.tool_calls:\n",
        "\n",
        "      assistant_message = response.choices[0].message\n",
        "      assistant_message.content = str(assistant_message.tool_calls[0].function)\n",
        "      messages.append({\"role\": assistant_message.role, \"content\": assistant_message.content})\n",
        "\n",
        "\n",
        "      results = execute_function_call_celestial(assistant_message)\n",
        "      print('cel result', results)\n",
        "      messages.append({\"role\": \"function\", \"tool_call_id\": assistant_message.tool_calls[0].id, \"name\": assistant_message.tool_calls[0].function.name, \"content\": json.dumps(results)})\n",
        "\n",
        "      messages.append({\"role\": \"user\", \"content\": \"Explain the interesting scientific aspects of celestial events concisely: \" + results[\"explanation\"]})\n",
        "      second_response = chat_completion_request(\n",
        "            messages=messages,\n",
        "      )\n",
        "\n",
        "      message = second_response.choices[0].message\n",
        "\n",
        "      print('secres ', second_response)\n",
        "      print('secchoice message', message)\n",
        "      messages.append({\"role\": message.role,\"content\": message.content})\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 89,
      "id": "1ne57NpSb8IA",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1ne57NpSb8IA",
        "outputId": "f654f5e5-c1e7-428a-8827-6aa77afceb68"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "res  ChatCompletion(id='chatcmpl-94ImnVKGGO0YGggAPpkyK4D0KftGn', choices=[Choice(finish_reason='tool_calls', index=0, logprobs=None, message=ChatCompletionMessage(content=None, role='assistant', function_call=None, tool_calls=[ChatCompletionMessageToolCall(id='call_bVmHs3Z1NOtvNz1mssxYemzP', function=Function(arguments='{}', name='get_celestial_events'), type='function')]))], created=1710812553, model='gpt-3.5-turbo-0613', object='chat.completion', system_fingerprint=None, usage=CompletionUsage(completion_tokens=10, prompt_tokens=52, total_tokens=62))\n",
            "choice message ChatCompletionMessage(content=None, role='assistant', function_call=None, tool_calls=[ChatCompletionMessageToolCall(id='call_bVmHs3Z1NOtvNz1mssxYemzP', function=Function(arguments='{}', name='get_celestial_events'), type='function')])\n",
            "cel result {'copyright': '\\nJan Erik Vallestad\\n', 'date': '2024-03-18', 'explanation': \"A bright comet will be visible during next month's total solar eclipse.  This very unusual coincidence occurs because Comet 12P/Pons-Brooks's return to the inner Solar System places it by chance only 25 degrees away from the Sun during Earth's April 8 total solar eclipse.  Currently the comet is just on the edge of visibility to the unaided eye, best visible with binoculars in the early evening sky toward the constellation of the Fish (Pisces). Comet Pons-Brooks, though, is putting on quite a show for deep camera images even now.  The featured image is a composite of three very specific colors, showing the comet's ever-changing ion tail in light blue, its outer coma in green, and highlights some red-glowing gas around the coma in a spiral. The spiral is thought to be caused by gas being expelled by the slowly rotating nucleus of the giant iceberg comet. Although it is always difficult to predict the future brightness of comets, Comet Pons-Brook has been particularly prone to outbursts, making it even more difficult to predict how bright it will actually be as the Moon moves in front of the Sun on April 8.   Total Eclipse Info: 2024 Total Solar Eclipse from NASA\", 'hdurl': 'https://apod.nasa.gov/apod/image/2403/CometPonsBrook_Vallestad_2564.jpg', 'media_type': 'image', 'service_version': 'v1', 'title': \"Comet Pons-Brooks' Swirling Coma\", 'url': 'https://apod.nasa.gov/apod/image/2403/CometPonsBrook_Vallestad_960.jpg'}\n",
            "secres  ChatCompletion(id='chatcmpl-94ImodFQA8dXnG08QlUo4ph0Q1eCv', choices=[Choice(finish_reason='stop', index=0, logprobs=None, message=ChatCompletionMessage(content=\"One interesting scientific aspect of today's celestial event is the presence of a bright comet, Comet 12P/Pons-Brooks, during next month's total solar eclipse. It is a rare coincidence because the comet's return to the inner Solar System positions it only 25 degrees away from the Sun during the eclipse. Currently, the comet is on the edge of visibility to the naked eye but can be best observed with binoculars in the early evening sky towards the constellation Pisces. Deep camera images show the comet's ion tail in light blue, its outer coma in green, and highlights of red-glowing gas in a spiral around the coma. This spiral is believed to be caused by gas expelled by the rotating nucleus of the giant iceberg comet. Predicting the comet's brightness during the eclipse is challenging due to its tendency for outbursts. The interaction with the Moon on April 8 further complicates the brightness predictions.\", role='assistant', function_call=None, tool_calls=None))], created=1710812554, model='gpt-3.5-turbo-0613', object='chat.completion', system_fingerprint=None, usage=CompletionUsage(completion_tokens=188, prompt_tokens=694, total_tokens=882))\n",
            "secchoice message ChatCompletionMessage(content=\"One interesting scientific aspect of today's celestial event is the presence of a bright comet, Comet 12P/Pons-Brooks, during next month's total solar eclipse. It is a rare coincidence because the comet's return to the inner Solar System positions it only 25 degrees away from the Sun during the eclipse. Currently, the comet is on the edge of visibility to the naked eye but can be best observed with binoculars in the early evening sky towards the constellation Pisces. Deep camera images show the comet's ion tail in light blue, its outer coma in green, and highlights of red-glowing gas in a spiral around the coma. This spiral is believed to be caused by gas expelled by the rotating nucleus of the giant iceberg comet. Predicting the comet's brightness during the eclipse is challenging due to its tendency for outbursts. The interaction with the Moon on April 8 further complicates the brightness predictions.\", role='assistant', function_call=None, tool_calls=None)\n",
            "None\n"
          ]
        }
      ],
      "source": [
        "print(run_conversation())\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 90,
      "id": "9EILuTF8RIwv",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9EILuTF8RIwv",
        "outputId": "0bcdf9c1-3332-418e-ba4d-41ddb964ccba"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "user: What are today's celestial events?\n",
            "\n",
            "assistant: Function(arguments='{}', name='get_celestial_events')\n",
            "\n",
            "function (get_celestial_events): {\"copyright\": \"\\nJan Erik Vallestad\\n\", \"date\": \"2024-03-18\", \"explanation\": \"A bright comet will be visible during next month's total solar eclipse.  This very unusual coincidence occurs because Comet 12P/Pons-Brooks's return to the inner Solar System places it by chance only 25 degrees away from the Sun during Earth's April 8 total solar eclipse.  Currently the comet is just on the edge of visibility to the unaided eye, best visible with binoculars in the early evening sky toward the constellation of the Fish (Pisces). Comet Pons-Brooks, though, is putting on quite a show for deep camera images even now.  The featured image is a composite of three very specific colors, showing the comet's ever-changing ion tail in light blue, its outer coma in green, and highlights some red-glowing gas around the coma in a spiral. The spiral is thought to be caused by gas being expelled by the slowly rotating nucleus of the giant iceberg comet. Although it is always difficult to predict the future brightness of comets, Comet Pons-Brook has been particularly prone to outbursts, making it even more difficult to predict how bright it will actually be as the Moon moves in front of the Sun on April 8.   Total Eclipse Info: 2024 Total Solar Eclipse from NASA\", \"hdurl\": \"https://apod.nasa.gov/apod/image/2403/CometPonsBrook_Vallestad_2564.jpg\", \"media_type\": \"image\", \"service_version\": \"v1\", \"title\": \"Comet Pons-Brooks' Swirling Coma\", \"url\": \"https://apod.nasa.gov/apod/image/2403/CometPonsBrook_Vallestad_960.jpg\"}\n",
            "\n",
            "user: Explain the interesting scientific aspects of celestial events concisely: A bright comet will be visible during next month's total solar eclipse.  This very unusual coincidence occurs because Comet 12P/Pons-Brooks's return to the inner Solar System places it by chance only 25 degrees away from the Sun during Earth's April 8 total solar eclipse.  Currently the comet is just on the edge of visibility to the unaided eye, best visible with binoculars in the early evening sky toward the constellation of the Fish (Pisces). Comet Pons-Brooks, though, is putting on quite a show for deep camera images even now.  The featured image is a composite of three very specific colors, showing the comet's ever-changing ion tail in light blue, its outer coma in green, and highlights some red-glowing gas around the coma in a spiral. The spiral is thought to be caused by gas being expelled by the slowly rotating nucleus of the giant iceberg comet. Although it is always difficult to predict the future brightness of comets, Comet Pons-Brook has been particularly prone to outbursts, making it even more difficult to predict how bright it will actually be as the Moon moves in front of the Sun on April 8.   Total Eclipse Info: 2024 Total Solar Eclipse from NASA\n",
            "\n",
            "assistant: One interesting scientific aspect of today's celestial event is the presence of a bright comet, Comet 12P/Pons-Brooks, during next month's total solar eclipse. It is a rare coincidence because the comet's return to the inner Solar System positions it only 25 degrees away from the Sun during the eclipse. Currently, the comet is on the edge of visibility to the naked eye but can be best observed with binoculars in the early evening sky towards the constellation Pisces. Deep camera images show the comet's ion tail in light blue, its outer coma in green, and highlights of red-glowing gas in a spiral around the coma. This spiral is believed to be caused by gas expelled by the rotating nucleus of the giant iceberg comet. Predicting the comet's brightness during the eclipse is challenging due to its tendency for outbursts. The interaction with the Moon on April 8 further complicates the brightness predictions.\n",
            "\n"
          ]
        }
      ],
      "source": [
        "pretty_print_conversation(messages)"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "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.1"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}