Basic_Samples/Functions/functions_with_azure_search.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Function calling with Azure Cognitive Search\n",
    "\n",
    "In this notebook, we'll show how to create a simple chatbot to help you find or create a good recipe. We'll create an index in Azure Cognitive Search using [vector search](), and then use use [function calling]() to write queries to the index.\n",
    "\n",
    "All of the recipes used in this sample were generated by gpt-35-turbo for demo purposes. The recipes are not guaranteed to be safe or taste good so we don't recommend trying them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# install the preview version of the Azure Cognitive Search Python SDK if you don't have it already\n",
    "# %pip install azure-search-documents --pre"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import json\n",
    "from openai import AzureOpenAI\n",
    "from tenacity import retry, wait_random_exponential, stop_after_attempt\n",
    "from azure.core.credentials import AzureKeyCredential\n",
    "from azure.search.documents import SearchClient\n",
    "from azure.search.documents.indexes import SearchIndexClient\n",
    "from azure.search.documents.models import Vector\n",
    "from azure.search.documents.indexes.models import (\n",
    "    SearchIndex,\n",
    "    SearchField,\n",
    "    SearchFieldDataType,\n",
    "    SimpleField,\n",
    "    SearchableField,\n",
    "    SearchIndex,\n",
    "    SemanticConfiguration,\n",
    "    PrioritizedFields,\n",
    "    SemanticField,\n",
    "    SearchField,\n",
    "    SemanticSettings,\n",
    "    VectorSearch,\n",
    "    HnswVectorSearchAlgorithmConfiguration,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load config values\n",
    "with open(r\"config.json\") as config_file:\n",
    "    config_details = json.load(config_file)\n",
    "\n",
    "# Configure environment variables for Azure Cognitive Search\n",
    "service_endpoint = config_details[\"SEARCH_SERVICE_ENDPOINT\"]\n",
    "index_name = config_details[\"SEARCH_INDEX_NAME\"]\n",
    "key = config_details[\"SEARCH_ADMIN_KEY\"]\n",
    "credential = AzureKeyCredential(key)\n",
    "\n",
    "# Create the Azure Cognitive Search client to issue queries\n",
    "search_client = SearchClient(\n",
    "    endpoint=service_endpoint, index_name=index_name, credential=credential\n",
    ")\n",
    "\n",
    "# Create the index client\n",
    "index_client = SearchIndexClient(endpoint=service_endpoint, credential=credential)\n",
    "\n",
    "# Configure OpenAI environment variables\n",
    "client = AzureOpenAI(\n",
    "    azure_endpoint=config_details[\"AZURE_OPENAI_ENDPOINT\"],  # The base URL for your Azure OpenAI resource. e.g. \"https://<your resource name>.openai.azure.com\"\n",
    "    api_key=os.getenv(\"AZURE_OPENAI_KEY\"),  # The API key for your Azure OpenAI resource.\n",
    "    api_version=config_details[\"OPENAI_API_VERSION\"],  # This version supports function calling\n",
    ")\n",
    "\n",
    "model_name = config_details[\"MODEL_NAME\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.0 Create the search index and load the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " recipes-vectors deleted\n",
      " recipes-vectors created\n"
     ]
    }
   ],
   "source": [
    "# Create a search index\n",
    "fields = [\n",
    "    SimpleField(name=\"recipe_id\", type=SearchFieldDataType.String, key=True, sortable=True, filterable=True, facetable=True),\n",
    "    SearchableField(name=\"recipe_category\", type=SearchFieldDataType.String, filterable=True, analyzer_name=\"en.microsoft\"),    \n",
    "    SearchableField(name=\"recipe_name\", type=SearchFieldDataType.String, facetable=True, analyzer_name=\"en.microsoft\"),\n",
    "    SearchableField(name=\"ingredients\", collection=True, type=SearchFieldDataType.String, facetable=True, filterable=True),\n",
    "    SearchableField(name=\"recipe\", type=SearchFieldDataType.String, analyzer_name=\"en.microsoft\"),\n",
    "    SearchableField(name=\"description\", type=SearchFieldDataType.String, analyzer_name=\"en.microsoft\"),\n",
    "    SimpleField(name=\"total_time\", type=SearchFieldDataType.Int32, filterable=True, facetable=True),\n",
    "    SearchField(name=\"recipe_vector\", type=SearchFieldDataType.Collection(SearchFieldDataType.Single),\n",
    "                searchable=True, vector_search_dimensions=1536, vector_search_configuration=\"my-vector-config\")\n",
    "]\n",
    "\n",
    "vector_search = VectorSearch(\n",
    "    algorithm_configurations=[\n",
    "        HnswVectorSearchAlgorithmConfiguration(\n",
    "            name=\"my-vector-config\",\n",
    "            kind=\"hnsw\"\n",
    "        )\n",
    "    ]\n",
    ")\n",
    "\n",
    "# Semantic Configuration to leverage Bing family of ML models for re-ranking (L2)\n",
    "semantic_config = SemanticConfiguration(\n",
    "    name=\"my-semantic-config\",\n",
    "    prioritized_fields=PrioritizedFields(\n",
    "        title_field=None,\n",
    "        prioritized_keywords_fields=[],\n",
    "        prioritized_content_fields=[SemanticField(field_name=\"recipe\")]\n",
    "    ))\n",
    "semantic_settings = SemanticSettings(configurations=[semantic_config])\n",
    "\n",
    "\n",
    "# Create the search index with the semantic settings\n",
    "index = SearchIndex(name=index_name, fields=fields, \n",
    "                    vector_search=vector_search, semantic_settings=semantic_settings)\n",
    "result = index_client.delete_index(index)\n",
    "print(f' {index_name} deleted')\n",
    "result = index_client.create_index(index)\n",
    "print(f' {result.name} created')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define a helper function to create embeddings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to generate embeddings for title and content fields, also used for query embeddings\n",
    "@retry(wait=wait_random_exponential(min=1, max=20), stop=stop_after_attempt(6))\n",
    "def generate_embeddings(text):\n",
    "    response = client.embeddings.create(input=text, model=\"text-embedding-ada-002\")\n",
    "    embeddings = response.data[0].embedding\n",
    "    return embeddings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load the data into Azure Cognitive Search"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Uploaded 100 documents\n",
      "Uploaded 100 documents\n",
      "Uploaded 100 documents\n",
      "Uploaded 100 documents\n",
      "Uploaded 3 documents\n"
     ]
    }
   ],
   "source": [
    "batch_size = 100\n",
    "counter = 0\n",
    "documents = []\n",
    "search_client = SearchClient(endpoint=service_endpoint, index_name=index_name, credential=credential)\n",
    "\n",
    "with open(\"recipes_final.jsonl\", \"r\") as j_in:\n",
    "    for line in j_in:\n",
    "        counter += 1\n",
    "        json_recipe = json.loads(line)\n",
    "        json_recipe[\"total_time\"] = int(json_recipe[\"total_time\"].split(\" \")[0])\n",
    "        json_recipe[\"recipe_vector\"] = generate_embeddings(json_recipe[\"recipe\"])\n",
    "        json_recipe[\"@search.action\"] = \"upload\"\n",
    "        documents.append(json_recipe)\n",
    "        if counter % batch_size == 0:\n",
    "            # Load content into index\n",
    "            result = search_client.upload_documents(documents)\n",
    "            print(f\"Uploaded {len(documents)} documents\")\n",
    "            documents = []\n",
    "\n",
    "\n",
    "if documents != []:\n",
    "    # Load content into index\n",
    "    result = search_client.upload_documents(documents)\n",
    "    print(f\"Uploaded {len(documents)} documents\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.0 Test function calling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  \"role\": \"assistant\",\n",
      "  \"function_call\": {\n",
      "    \"name\": \"query_recipes\",\n",
      "    \"arguments\": \"{\\n  \\\"query\\\": \\\"lasagna\\\"\\n}\"\n",
      "  }\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "messages = [{\"role\": \"user\", \"content\": \"Help me find a good lasagna recipe.\"}]\n",
    "\n",
    "# messages = [{\"role\": \"user\", \"content\": \"Help me find a good mexican recipe that has beans and rice\"}]\n",
    "# messages = [{\"role\": \"user\", \"content\": \"What should I cook for dinner?\"}]\n",
    "\n",
    "### Try again with a more detailed system message ###\n",
    "# system_message = \"\"\"Assistant is a large language model designed to help users find and create recipes.\n",
    "# You have access to an Azure Cognitive Search index with hundreds of recipes. You can search for recipes by name, ingredient, or cuisine.\n",
    "# You are designed to be an interactive assistant, so you can ask users clarifying questions to help them find the right recipe. It's better to give more detailed queries to the search index rather than vague one.\n",
    "# \"\"\"\n",
    "\n",
    "# messages = [{\"role\": \"system\", \"content\": system_message},\n",
    "#             {\"role\": \"user\", \"content\": \"What should I cook for dinner?\"}]\n",
    "\n",
    "# messages = [{\"role\": \"system\", \"content\": system_message},\n",
    "#            {\"role\": \"user\", \"content\": \"find an easy mexican recipe with beans and rice\"}]\n",
    "\n",
    "tools = [\n",
    "    {\n",
    "        \"type\": \"function\",\n",
    "        \"function\": {\n",
    "            \"name\": \"query_recipes\",\n",
    "            \"description\": \"Retrieve recipes from the Azure Cognitive Search index\",\n",
    "            \"parameters\": {\n",
    "                \"type\": \"object\",\n",
    "                \"properties\": {\n",
    "                    \"query\": {\n",
    "                        \"type\": \"string\",\n",
    "                        \"description\": \"The query string to search for recipes\",\n",
    "                    },\n",
    "                    \"ingredients_filter\": {\n",
    "                        \"type\": \"string\",\n",
    "                        \"description\": \"The odata filter to apply for the ingredients field. Only actual ingredient names should be used in this filter. If you're not sure something is an ingredient, don't include this filter. Example: ingredients/any(i: i eq 'salt' or i eq 'pepper')\",\n",
    "                    },\n",
    "                    \"time_filter\": {\n",
    "                        \"type\": \"string\",\n",
    "                        \"description\": \"The odata filter to apply for the total_time field. If a user asks for a quick or easy recipe, you should filter down to recipes that will take less than 30 minutes. Example: total_time lt 25\",\n",
    "                    },\n",
    "                },\n",
    "                \"required\": [\"query\"],\n",
    "            },\n",
    "        },\n",
    "    }\n",
    "]\n",
    "\n",
    "response = client.chat.completions.create(\n",
    "    model=model_name,\n",
    "    messages=messages,\n",
    "    tools=tools,\n",
    "    temperature=0.2,\n",
    "    tool_choice=\"auto\",\n",
    ")\n",
    "\n",
    "print(response.choices[0].message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define function to call Azure Cognitive Search"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def query_recipes(query, ingredients_filter=None, time_filter=None):\n",
    "    filter = \"\"\n",
    "    if ingredients_filter and time_filter:\n",
    "        filter = f\"{time_filter} and {ingredients_filter}\"\n",
    "    elif ingredients_filter:\n",
    "        filter = ingredients_filter\n",
    "    elif time_filter:\n",
    "        filter = time_filter\n",
    "\n",
    "    results = search_client.search(\n",
    "        query_type=\"semantic\",\n",
    "        query_language=\"en-us\",\n",
    "        semantic_configuration_name=\"my-semantic-config\",\n",
    "        search_text=query,\n",
    "        vectors=[Vector(value=generate_embeddings(query), k=3, fields=\"recipe_vector\")],\n",
    "        filter=filter,\n",
    "        select=[\"recipe_id\", \"recipe\", \"recipe_category\", \"recipe_name\", \"description\"],\n",
    "        top=3,\n",
    "    )\n",
    "\n",
    "    n = 1\n",
    "    recipes_for_prompt = \"\"\n",
    "    for result in results:\n",
    "        recipes_for_prompt += f\"Recipe {result['recipe_id']}: {result['recipe_name']}: {result['description']}\\n\"\n",
    "        n += 1\n",
    "\n",
    "    return recipes_for_prompt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.0 Get things running end to end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_conversation(messages, tools, available_functions):\n",
    "\n",
    "    # Step 1: send the conversation and available functions to GPT\n",
    "    response = client.chat.completions.create(\n",
    "        model=model_name,\n",
    "        messages=messages,\n",
    "        tools=tools,\n",
    "        tool_choice=\"auto\",\n",
    "        temperature=0.2,\n",
    "    )\n",
    "    response_message = response.choices[0].message\n",
    "\n",
    "    # Step 2: check if the model wants to call a function\n",
    "    if response_message.tool_calls:\n",
    "        print(\"Recommended Function call:\")\n",
    "        print(response_message.tool_calls[0])\n",
    "        print()\n",
    "\n",
    "        # Step 3: call the function\n",
    "        # Note: the JSON response may not always be valid; be sure to handle errors\n",
    "        function_name = response_message.tool_calls[0].function.name\n",
    "\n",
    "        # verify 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",
    "        function_args = json.loads(response_message.tool_calls[0].function.arguments)\n",
    "        function_response = function_to_call(**function_args)\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 the model\n",
    "\n",
    "        # adding assistant response to messages\n",
    "        messages.append(\n",
    "            {\n",
    "                \"role\": response_message.role,\n",
    "                \"function_call\": {\n",
    "                    \"name\": response_message.tool_calls[0].function.name,\n",
    "                    \"arguments\": response_message.tool_calls[0].function.arguments,\n",
    "                },\n",
    "                \"content\": None,\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",
    "        )  # extend conversation with function response\n",
    "\n",
    "        print(\"Messages in second request:\")\n",
    "        for message in messages:\n",
    "            print(message)\n",
    "        print()\n",
    "\n",
    "        second_response = client.chat.completions.create(\n",
    "            messages=messages,\n",
    "            model=model_name,\n",
    "        )  # get a new response from GPT where it can see the function response\n",
    "\n",
    "        return second_response\n",
    "    else:\n",
    "        return response"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recommended Function call:\n",
      "{\n",
      "  \"name\": \"query_recipes\",\n",
      "  \"arguments\": \"{\\n  \\\"query\\\": \\\"pasta\\\",\\n  \\\"time_filter\\\": \\\"total_time lt 60\\\"\\n}\"\n",
      "}\n",
      "\n",
      "Output of function call:\n",
      "Recipe 46: Pesto Pasta: Pesto Pasta is a classic Italian dish that combines al dente pasta with a flavorful sauce made from fresh basil, garlic, pine nuts, Parmesan cheese, and olive oil. It's a versatile and delicious meal that can be enjoyed as a main dish or as a side.\n",
      "Recipe 76: Tortellini Alfredo: A creamy and delicious pasta dish filled with cheesy tortellini, smothered in a rich alfredo sauce.\n",
      "Recipe 65: Cacio e Pepe: Cacio e Pepe is a classic Roman dish that translates to \"cheese and pepper\". It consists of simple ingredients that when combined, create a delicious and comforting pasta dish with a creamy, cheesy, and peppery sauce.\n",
      "\n",
      "\n",
      "Messages in second request:\n",
      "{'role': 'system', 'content': \"Assistant is a large language model designed to help users find and create recipes.\\n\\nYou have access to an Azure Cognitive Search index with hundreds of recipes. You can search for recipes by name, ingredient, or cuisine.\\n\\nYou are designed to be an interactive assistant, so you can ask users clarifying questions to help them find the right recipe. It's better to give more detailed queries to the search index rather than vague one.\\n\"}\n",
      "{'role': 'user', 'content': 'I want to make a pasta dish that takes less than 60 minutes to make.'}\n",
      "{'role': 'assistant', 'function_call': {'name': 'query_recipes', 'arguments': '{\\n  \"query\": \"pasta\",\\n  \"time_filter\": \"total_time lt 60\"\\n}'}, 'content': None}\n",
      "{'role': 'function', 'name': 'query_recipes', 'content': 'Recipe 46: Pesto Pasta: Pesto Pasta is a classic Italian dish that combines al dente pasta with a flavorful sauce made from fresh basil, garlic, pine nuts, Parmesan cheese, and olive oil. It\\'s a versatile and delicious meal that can be enjoyed as a main dish or as a side.\\nRecipe 76: Tortellini Alfredo: A creamy and delicious pasta dish filled with cheesy tortellini, smothered in a rich alfredo sauce.\\nRecipe 65: Cacio e Pepe: Cacio e Pepe is a classic Roman dish that translates to \"cheese and pepper\". It consists of simple ingredients that when combined, create a delicious and comforting pasta dish with a creamy, cheesy, and peppery sauce.\\n'}\n",
      "\n",
      "Final response:\n",
      "Here are some pasta dishes that take less than 60 minutes to make:\n",
      "\n",
      "1. Pesto Pasta: This classic Italian dish combines al dente pasta with a flavorful sauce made from fresh basil, garlic, pine nuts, Parmesan cheese, and olive oil.\n",
      "\n",
      "2. Tortellini Alfredo: A creamy and delicious pasta dish filled with cheesy tortellini, smothered in a rich alfredo sauce.\n",
      "\n",
      "3. Cacio e Pepe: A classic Roman dish that consists of simple ingredients like cheese and pepper. It creates a delicious and comforting pasta dish with a creamy, cheesy, and peppery sauce.\n",
      "\n",
      "Let me know if you'd like the full recipe for any of these dishes or if you have any other questions!\n"
     ]
    }
   ],
   "source": [
    "system_message = \"\"\"Assistant is a large language model designed to help users find and create recipes.\n",
    "\n",
    "You have access to an Azure Cognitive Search index with hundreds of recipes. You can search for recipes by name, ingredient, or cuisine.\n",
    "\n",
    "You are designed to be an interactive assistant, so you can ask users clarifying questions to help them find the right recipe. It's better to give more detailed queries to the search index rather than vague one.\n",
    "\"\"\"\n",
    "\n",
    "messages = [\n",
    "    {\"role\": \"system\", \"content\": system_message},\n",
    "    {\n",
    "        \"role\": \"user\",\n",
    "        \"content\": \"I want to make a pasta dish that takes less than 60 minutes to make.\",\n",
    "    },\n",
    "]\n",
    "\n",
    "available_functions = {\"query_recipes\": query_recipes}\n",
    "\n",
    "result = run_conversation(messages, tools, available_functions)\n",
    "\n",
    "print(\"Final response:\")\n",
    "print(result.choices[0].message.content)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.0 Define additional functions\n",
    "\n",
    "Now that we have the `query_recipes` function defined, we can add additional functions to add more capabilities."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "tools = [\n",
    "    {\n",
    "        \"type\": \"function\",\n",
    "        \"function\": {\n",
    "            \"name\": \"query_recipes\",\n",
    "            \"description\": \"Retrieve recipes from the Azure Cognitive Search index\",\n",
    "            \"parameters\": {\n",
    "                \"type\": \"object\",\n",
    "                \"properties\": {\n",
    "                    \"query\": {\n",
    "                        \"type\": \"string\",\n",
    "                        \"description\": \"The query string to search for recipes\",\n",
    "                    },\n",
    "                    \"time_filter\": {\n",
    "                        \"type\": \"string\",\n",
    "                        \"description\": \"The odata filter to apply for the total_time field. If a user asks for a quick or easy recipe, you should filter down to recipes that will take less than 30 minutes. Example: total_time lt 25\",\n",
    "                    },\n",
    "                },\n",
    "                \"required\": [\"query\"],\n",
    "            },\n",
    "        },\n",
    "    },\n",
    "    {\n",
    "        \"type\": \"function\",\n",
    "        \"function\": {\n",
    "            \"name\": \"get_recipe\",\n",
    "            \"description\": \"Gets a recipe based on it's id\",\n",
    "            \"parameters\": {\n",
    "                \"type\": \"object\",\n",
    "                \"properties\": {\n",
    "                    \"id\": {\n",
    "                        \"type\": \"string\",\n",
    "                        \"description\": \"The id of a recipe. Usually a number such as 3846\",\n",
    "                    }\n",
    "                },\n",
    "                \"required\": [\"id\"],\n",
    "            },\n",
    "        },\n",
    "    },\n",
    "    {\n",
    "        \"type\": \"function\",\n",
    "        \"function\": {\n",
    "            \"name\": \"convert_measurement\",\n",
    "            \"description\": \"converts a measurement from one unit to another for common cooking measurements\",\n",
    "            \"parameters\": {\n",
    "                \"type\": \"object\",\n",
    "                \"properties\": {\n",
    "                    \"amount\": {\n",
    "                        \"type\": \"number\",\n",
    "                        \"description\": \"The quantity of the measurement to convert.\",\n",
    "                    },\n",
    "                    \"from_unit\": {\n",
    "                        \"type\": \"string\",\n",
    "                        \"description\": \"The unit to convert the measurement from. Supported values are tablespoons, teaspoons, cups, and ounces.\",\n",
    "                    },\n",
    "                    \"to_unit\": {\n",
    "                        \"type\": \"string\",\n",
    "                        \"description\": \"The unit to convert the measurement to. Supported values are tablespoons, teaspoons, cups, and ounces.\",\n",
    "                    },\n",
    "                },\n",
    "                \"required\": [\"amount\", \"from_unit\", \"to_unit\"],\n",
    "            },\n",
    "        },\n",
    "    },\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define a function to convert common measurements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3 teaspoons'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def convert_measurement(amount, from_unit, to_unit):\n",
    "    conversions = {\n",
    "        \"tablespoons\": {\"teaspoons\": 3, \"cups\": 1 / 16, \"ounces\": 1 / 2.667},\n",
    "        \"teaspoons\": {\"tablespoons\": 1 / 3, \"cups\": 1 / 48, \"ounces\": 1 / 6},\n",
    "        \"cups\": {\"tablespoons\": 16, \"teaspoons\": 48, \"ounces\": 8},\n",
    "        \"ounces\": {\"tablespoons\": 3, \"teaspoons\": 6, \"cups\": 1 / 8},\n",
    "    }\n",
    "    if from_unit == to_unit:\n",
    "        return str(amount) + \" \" + to_unit\n",
    "    else:\n",
    "        conversion_factor = conversions[from_unit][to_unit]\n",
    "        converted_amount = amount * conversion_factor\n",
    "        return str(converted_amount) + \" \" + to_unit\n",
    "\n",
    "\n",
    "convert_measurement(1, from_unit=\"tablespoons\", to_unit=\"teaspoons\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define a function to get recipes by id"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Recipe: Malabar Paratha\\n\\nDescription: Malabar Paratha is a popular Indian flatbread known for its flaky and layered texture. It is perfect for serving alongside curries or as a delicious snack on its own.\\n\\nCook Time: 10 minutes\\nPrep Time: 20 minutes\\nTotal Time: 30 minutes\\n\\nIngredients:\\n- 2 cups all-purpose flour\\n- 1/2 teaspoon salt\\n- 1 tablespoon ghee (clarified butter)\\n- 3/4 cup water\\n- Additional ghee for brushing\\n\\nInstructions:\\n1. In a large mixing bowl, combine the all-purpose flour and salt. Mix well.\\n2. Add the ghee to the flour mixture and mix using your fingertips until the mixture resembles breadcrumbs.\\n3. Gradually add water to the mixture while kneading the dough. Continue kneading until a soft and smooth dough is formed. Cover the dough and let it rest for 15 minutes.\\n4. After the dough has rested, divide it into small equal-sized balls, approximately golf ball-sized.\\n5. Take one dough ball and roll it out into a small circle using a rolling pin.\\n6. Brush the surface of the rolled dough with ghee.\\n7. Starting from one end, tightly roll the dough into a cylinder shape.\\n8. Once rolled, coil the cylinder into a spiral shape.\\n9. Flatten the spiral-shaped dough using a rolling pin to make a circular shaped paratha.\\n10. Heat a tawa or flat pan over medium heat. Place the flattened paratha onto the pan and cook for about 1-2 minutes, or until golden brown spots start to appear.\\n11. Flip the paratha and brush the cooked side with ghee. Cook for another 1-2 minutes, or until golden brown spots appear on the other side as well.\\n12. Remove the paratha from the pan and place it on a serving plate. Repeat the process for the remaining dough balls.\\n13. Serve the Malabar Parathas hot with your favorite curry or enjoy them on their own.\\n\\nEnjoy your delicious homemade Malabar Parathas!'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def get_recipe(id):\n",
    "    return search_client.get_document(key=id)[\"recipe\"]\n",
    "\n",
    "\n",
    "get_recipe(\"151\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.0 Test more examples "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "available_functions = {\n",
    "    \"query_recipes\": query_recipes,\n",
    "    \"get_recipe\": get_recipe,\n",
    "    \"convert_measurement\": convert_measurement,\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recommended Function call:\n",
      "{\n",
      "  \"name\": \"convert_measurement\",\n",
      "  \"arguments\": \"{\\n  \\\"amount\\\": 2,\\n  \\\"from_unit\\\": \\\"tablespoons\\\",\\n  \\\"to_unit\\\": \\\"cups\\\"\\n}\"\n",
      "}\n",
      "\n",
      "Output of function call:\n",
      "0.125 cups\n",
      "\n",
      "Messages in second request:\n",
      "{'role': 'system', 'content': \"Assistant is a large language model designed to help users find and create recipes.\\n\\nYou have access to an Azure Cognitive Search index with hundreds of recipes. You can search for recipes by name, ingredient, or cuisine.\\n\\nYou are designed to be an interactive assistant, so you can ask users clarifying questions to help them find the right recipe. It's better to give more detailed queries to the search index rather than vague one.\\n\"}\n",
      "{'role': 'user', 'content': 'How many cups is 2 tablespoons of butter?'}\n",
      "{'role': 'assistant', 'function_call': {'name': 'convert_measurement', 'arguments': '{\\n  \"amount\": 2,\\n  \"from_unit\": \"tablespoons\",\\n  \"to_unit\": \"cups\"\\n}'}, 'content': None}\n",
      "{'role': 'function', 'name': 'convert_measurement', 'content': '0.125 cups'}\n",
      "\n",
      "Final response:\n",
      "2 tablespoons of butter is equal to 0.125 cups.\n"
     ]
    }
   ],
   "source": [
    "system_message = \"\"\"Assistant is a large language model designed to help users find and create recipes.\n",
    "\n",
    "You have access to an Azure Cognitive Search index with hundreds of recipes. You can search for recipes by name, ingredient, or cuisine.\n",
    "\n",
    "You are designed to be an interactive assistant, so you can ask users clarifying questions to help them find the right recipe. It's better to give more detailed queries to the search index rather than vague one.\n",
    "\"\"\"\n",
    "\n",
    "messages = [\n",
    "    {\"role\": \"system\", \"content\": system_message},\n",
    "    {\"role\": \"user\", \"content\": \"How many cups is 2 tablespoons of butter?\"},\n",
    "]\n",
    "\n",
    "result = run_conversation(messages, tools, available_functions)\n",
    "\n",
    "print(\"Final response:\")\n",
    "print(result.choices[0].message.content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "system_message = \"\"\"Assistant is a large language model designed to help users find and create recipes.\n",
    "\n",
    "You have access to an Azure Cognitive Search index with hundreds of recipes. You can search for recipes by name, ingredient, or cuisine.\n",
    "\n",
    "You are designed to be an interactive assistant, so you can ask users clarifying questions to help them find the right recipe. It's better to give more detailed queries to the search index rather than vague one.\n",
    "\"\"\"\n",
    "\n",
    "messages = [{'role': 'system', 'content': system_message},\n",
    "            {'role': 'user', 'content': 'Help me find a Thai recipe I can cook in less than an hour'},\n",
    "            {'role': 'assistant', 'function_call': {'name': 'query_recipes', 'arguments': '{\\n  \"query\": \"Thai\",\\n  \"time_filter\": \"total_time lt 60\"\\n}'}, 'content': None},\n",
    "            {'role': 'function', 'name': 'query_recipes', 'content': \"Recipe 200: Thai Peanut Noodles: Thai Peanut Noodles is a delicious and flavorful dish that combines the creaminess of peanut butter with the tanginess of lime and the heat of chili. This dish is perfect for those who enjoy a balance of sweet, savory, and spicy flavors.\\nRecipe 206: Thai Cashew Tofu Stir-Fry: This Thai-inspired stir-fry is packed with flavor, combining crispy tofu, crunchy vegetables, and cashews in a savory sauce. It's a quick and delicious weeknight meal option.\\nRecipe 196: Thai Beef Salad: Thai Beef Salad is a refreshing and vibrant dish that combines tender beef with a tangy and spicy dressing, fresh herbs, and colorful vegetables.\\n\"},\n",
    "            {'role': 'assistant', 'content': \"Here are a few Thai recipes that you can cook in less than an hour:\\n\\n1. Thai Peanut Noodles: This dish combines the creaminess of peanut butter with the tanginess of lime and the heat of chili. It's a perfect balance of sweet, savory, and spicy flavors.\\n\\n2. Thai Cashew Tofu Stir-Fry: This stir-fry is packed with flavor, combining crispy tofu, crunchy vegetables, and cashews in a savory sauce. It's a quick and delicious option for a weeknight meal.\\n\\n3. Thai Beef Salad: This refreshing and vibrant salad combines tender beef with a tangy and spicy dressing, fresh herbs, and colorful vegetables.\\n\\nLet me know if you'd like more information about any of these recipes!\"},\n",
    "            {'role': 'user', 'content': 'Show me the thai peanut noodles recipe'}\n",
    "]\n",
    "\n",
    "result = run_conversation(messages, tools, available_functions)\n",
    "\n",
    "print(\"Final response:\")\n",
    "print(result.choices[0].message)"
   ]
  }
 ],
 "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.10.11"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}