azure-ai-search-text-embedding-3-large.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Azure AI Search with OpenAI's New Text-Embedding-3 Large Model\n",
    "\n",
    "In this notebook, I'll show you how to use Azure OpenAI Service to generate embeddings using the latest and highest performing model from OpenAI, `text-embedding-3-large` and how to store these in Azure AI Search."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Install libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "! pip install azure-search-documents openai python-dotenv azure-identity langchain tiktoken --quiet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configure Azure OpenAI Settings\n",
    "\n",
    "This section guides you through setting up authentication for Azure OpenAI, allowing you to securely interact with the service using either Azure Active Directory (AAD) or an API key. Before proceeding, ensure you have your Azure OpenAI endpoint and credentials ready. For detailed instructions on setting up AAD with Azure OpenAI, refer to the [official documentation](https://learn.microsoft.com/azure/ai-services/openai/how-to/managed-identity)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from azure.identity import DefaultAzureCredential, get_bearer_token_provider\n",
    "from azure.core.credentials import AzureKeyCredential\n",
    "from dotenv import load_dotenv\n",
    "from openai import AzureOpenAI\n",
    "\n",
    "# Set up OpenAI client based on environment variables\n",
    "load_dotenv()\n",
    "AZURE_OPENAI_ENDPOINT: str = os.getenv(\"AZURE_OPENAI_ENDPOINT\")\n",
    "AZURE_OPENAI_API_KEY: str = os.getenv(\"AZURE_OPENAI_API_KEY\")\n",
    "AZURE_OPENAI_API_VERSION: str = \"2023-05-15\"\n",
    "AZURE_OPENAI_EMBEDDING_DEPLOYED_MODEL_NAME: str = os.getenv(\n",
    "    \"AZURE_OPENAI_EMBEDDING_DEPLOYED_MODEL_NAME\"\n",
    ")\n",
    "\n",
    "\n",
    "credential = DefaultAzureCredential()\n",
    "token_provider = get_bearer_token_provider(\n",
    "    credential, \"https://cognitiveservices.azure.com/.default\"\n",
    ")\n",
    "\n",
    "# Set this flag to True if you are using Azure Active Directory\n",
    "use_aad_for_aoai = False\n",
    "\n",
    "if use_aad_for_aoai:\n",
    "    # Use Azure Active Directory (AAD) authentication\n",
    "    client = AzureOpenAI(\n",
    "        azure_endpoint=AZURE_OPENAI_ENDPOINT,\n",
    "        api_version=AZURE_OPENAI_API_VERSION,\n",
    "        azure_ad_token_provider=token_provider,\n",
    "    )\n",
    "else:\n",
    "    # Use API key authentication\n",
    "    client = AzureOpenAI(\n",
    "        api_key=AZURE_OPENAI_API_KEY,\n",
    "        api_version=AZURE_OPENAI_API_VERSION,\n",
    "        azure_endpoint=AZURE_OPENAI_ENDPOINT,\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load environment variables\n",
    "search_service_endpoint = os.getenv(\"AZURE_SEARCH_SERVICE_ENDPOINT\")\n",
    "search_service_api_key = os.getenv(\"AZURE_SEARCH_ADMIN_KEY\")\n",
    "\n",
    "# Authentication method flag\n",
    "use_aad_for_search = True  # Set based on your authentication method\n",
    "\n",
    "# Choose the correct credential based on your authentication method\n",
    "credential = (\n",
    "    DefaultAzureCredential()\n",
    "    if use_aad_for_search\n",
    "    else AzureKeyCredential(search_service_api_key)\n",
    ")\n",
    "\n",
    "# Initialize the SearchIndexClient for creating indexes\n",
    "index_client = SearchIndexClient(\n",
    "    endpoint=search_service_endpoint, credential=credential\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generate Embedding Functions for different sizes\n",
    "\n",
    "The `text-embedding-3-large` supports variable dimensions with a range of 1:3072 using a technique called Matryoshka Representation Learning(https://arxiv.org/abs/2205.13147), - let's t-shirt size to easily compare them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_small_embedding(text: str):\n",
    "    # Generate 256d embeddings for the provided text\n",
    "    embeddings_response = client.embeddings.create(\n",
    "        model=AZURE_OPENAI_EMBEDDING_DEPLOYED_MODEL_NAME, input=text, dimensions=256\n",
    "    )\n",
    "    return embeddings_response.data[0].embedding\n",
    "\n",
    "def generate_medium_embedding(text: str):\n",
    "    # Generate 1536d embeddings for the provided text\n",
    "    embeddings_response = client.embeddings.create(\n",
    "        model=AZURE_OPENAI_EMBEDDING_DEPLOYED_MODEL_NAME, input=text, dimensions=1536\n",
    "    )\n",
    "    return embeddings_response.data[0].embedding\n",
    "\n",
    "def generate_large_embedding(text: str):\n",
    "    # Generate 3072d embeddings for the provided text\n",
    "    embeddings_response = client.embeddings.create(\n",
    "        model=AZURE_OPENAI_EMBEDDING_DEPLOYED_MODEL_NAME, input=text, dimensions=3072\n",
    "    )\n",
    "    return embeddings_response.data[0].embedding\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Verify the dimension length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "256\n",
      "1536\n",
      "3072\n"
     ]
    }
   ],
   "source": [
    "print(len(generate_small_embedding(\"Hello, world!\")))\n",
    "print(len(generate_medium_embedding(\"Hello, world!\")))\n",
    "print(len(generate_large_embedding(\"Hello, world!\")))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculate the raw vector size in Bytes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Size of the small vector embedding in bytes: 2104\n",
      "Size of the medium vector embedding in bytes: 12344\n",
      "Size of the large vector embedding in bytes: 24632\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "\n",
    "def print_vector_size(text: str, generator_function, description: str):\n",
    "    # Generate an embedding for the text using the specified generator function\n",
    "    embedding_vector = generator_function(text)\n",
    "    \n",
    "    # Measure the size of the vector embedding in bytes\n",
    "    vector_size_bytes = sys.getsizeof(embedding_vector)\n",
    "    \n",
    "    # Print the size\n",
    "    print(f\"Size of the {description} vector embedding in bytes: {vector_size_bytes}\")\n",
    "\n",
    "# Example text\n",
    "text = \"Hello, world!\"\n",
    "\n",
    "# Print the size for each type of embedding\n",
    "print_vector_size(text, generate_small_embedding, \"small\")\n",
    "print_vector_size(text, generate_medium_embedding, \"medium\")\n",
    "print_vector_size(text, generate_large_embedding, \"large\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Embedding Size Comparison\n",
    "\n",
    "We have generated embeddings for a given text using three different dimensionalities: small (256d), medium (1536d), and large (3072d). The sizes of these embeddings in memory, as measured in bytes, are as follows:\n",
    "\n",
    "- Small (256d) Embedding Size: 2104 bytes\n",
    "- Medium (1536d) Embedding Size: 12344 bytes\n",
    "- Large (3072d) Embedding Size: 24632 bytes\n",
    "\n",
    "### Relative Differences\n",
    "\n",
    "When comparing the embedding sizes relative to the medium (1536d) embedding:\n",
    "\n",
    "- The **small (256d) embedding** is significantly smaller than the medium embedding. Specifically, it is approximately `((12344 - 2104) / 12344) * 100 ≈ 82.96%` smaller. This highlights the efficiency of using smaller embeddings for applications where memory usage is a critical constraint, though it may come at the cost of losing some detail or expressive power.\n",
    "\n",
    "- The **large (3072d) embedding** is larger than the medium embedding. It is approximately `((24632 - 12344) / 12344) * 100 ≈ 99.41%` larger. The increased size of the large embeddings suggests a higher level of detail or expressive power, which can be beneficial for tasks requiring high accuracy\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Embedding names\n",
    "embeddings = ['Small (256d)', 'Medium (1536d)', 'Large (3072d)']\n",
    "\n",
    "# Sizes in bytes (from your previous output)\n",
    "sizes_bytes = [2104, 12344, 24632]\n",
    "\n",
    "# Convert sizes to kilobytes for easier interpretation\n",
    "sizes_kb = [size / 1024 for size in sizes_bytes]\n",
    "\n",
    "# Create a bar chart\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.bar(embeddings, sizes_kb, color=['blue', 'orange', 'green'])\n",
    "\n",
    "# Add title and labels\n",
    "plt.title('Comparison of Embedding Sizes')\n",
    "plt.ylabel('Size in Kilobytes (KB)')\n",
    "plt.xlabel('Embedding Type')\n",
    "\n",
    "# Display the values on top of the bars\n",
    "for i, size in enumerate(sizes_kb):\n",
    "    plt.text(i, size + 0.5, f'{size:.2f} KB', ha='center')\n",
    "\n",
    "# Show the plot\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see how using these embeddings affect our storage size and vector index size in Azure AI Search."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configure an Azure AI Search vector index\n",
    "\n",
    "This section explains how to set up the Azure AI Search client for integrating with the Vector Store feature. You can locate your Azure AI Search service details in the Azure Portal or programmatically via the [Search Management SDK](https://learn.microsoft.com/rest/api/searchmanagement/).\n",
    "\n",
    "Additionally, this demonstrates how to define and create a search index using the SearchIndexClient from the Azure AI Search Python SDK. For more details, visit our documentation on how to [Create a Vector Index](https://learn.microsoft.com/azure/search/vector-search-how-to-create-index?.tabs=config-2023-11-01%2Crest-2023-11-01%2Cpush%2Cportal-check-index)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "index-256d created with 256 dimensions\n",
      "index-1536d created with 1536 dimensions\n",
      "index-3072d created with 3072 dimensions\n"
     ]
    }
   ],
   "source": [
    "from azure.core.credentials import AzureKeyCredential\n",
    "from azure.search.documents.indexes import SearchIndexClient\n",
    "from azure.search.documents import SearchClient\n",
    "from azure.search.documents.indexes.models import (\n",
    "    SearchIndex,\n",
    "    SimpleField,\n",
    "    SearchableField,\n",
    "    SearchField,\n",
    "    SearchFieldDataType,\n",
    "    VectorSearch,\n",
    "    HnswAlgorithmConfiguration,\n",
    "    VectorSearchProfile,\n",
    "    VectorSearchAlgorithmKind,\n",
    ")\n",
    "from azure.identity import DefaultAzureCredential\n",
    "import os\n",
    "\n",
    "# Load environment variables\n",
    "search_service_endpoint = os.getenv(\"AZURE_SEARCH_SERVICE_ENDPOINT\")\n",
    "search_service_api_key = os.getenv(\"AZURE_SEARCH_ADMIN_KEY\")\n",
    "\n",
    "# Index names and their corresponding vector dimensions\n",
    "index_info = {\n",
    "    \"small\": {\"name\": \"index-256d\", \"dimension\": 256},\n",
    "    \"medium\": {\"name\": \"index-1536d\", \"dimension\": 1536},\n",
    "    \"large\": {\"name\": \"index-3072d\", \"dimension\": 3072},\n",
    "}\n",
    "\n",
    "# Authentication method flag\n",
    "use_aad_for_search = True  # Set based on your authentication method\n",
    "\n",
    "# Choose the correct credential based on your authentication method\n",
    "credential = (\n",
    "    DefaultAzureCredential()\n",
    "    if use_aad_for_search\n",
    "    else AzureKeyCredential(search_service_api_key)\n",
    ")\n",
    "\n",
    "# Initialize the SearchIndexClient for creating indexes\n",
    "index_client = SearchIndexClient(\n",
    "    endpoint=search_service_endpoint, credential=credential\n",
    ")\n",
    "\n",
    "\n",
    "# Function to create or update indexes\n",
    "def create_or_update_index(index_name, dimensions):\n",
    "    fields = [\n",
    "        SimpleField(name=\"id\", type=SearchFieldDataType.String, key=True),\n",
    "        SearchableField(name=\"text\", type=SearchFieldDataType.String),\n",
    "        SearchField(\n",
    "            name=\"vector\",\n",
    "            type=SearchFieldDataType.Collection(SearchFieldDataType.Single),\n",
    "            vector_search_dimensions=dimensions,\n",
    "            vector_search_profile_name=\"my-vector-profile\",\n",
    "        ),\n",
    "    ]\n",
    "\n",
    "    vector_search = VectorSearch(\n",
    "        algorithms=[\n",
    "            HnswAlgorithmConfiguration(\n",
    "                name=\"my-hnsw\", kind=VectorSearchAlgorithmKind.HNSW\n",
    "            )\n",
    "        ],\n",
    "        profiles=[\n",
    "            VectorSearchProfile(\n",
    "                name=\"my-vector-profile\", algorithm_configuration_name=\"my-hnsw\"\n",
    "            )\n",
    "        ],\n",
    "    )\n",
    "\n",
    "    index = SearchIndex(name=index_name, fields=fields, vector_search=vector_search)\n",
    "    result = index_client.create_or_update_index(index=index)\n",
    "    print(f\"{result.name} created with {dimensions} dimensions\")\n",
    "\n",
    "\n",
    "# Create or update each index and initialize SearchClient instances\n",
    "search_clients = {}\n",
    "for size, info in index_info.items():\n",
    "    create_or_update_index(info[\"name\"], info[\"dimension\"])\n",
    "    search_clients[size] = SearchClient(\n",
    "        endpoint=search_service_endpoint, index_name=info[\"name\"], credential=credential\n",
    "    )\n",
    "\n",
    "# Now search_clients dictionary contains SearchClient instances for each index size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Data\n",
    "\n",
    "Let's leverage the state of the union text file in the data folder in the repos root directory. We will leverage langchain for loading and chunking this document."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Correcting the file open syntax\n",
    "with open('./data/state_of_the_union.txt', 'r', encoding='utf-8') as file:\n",
    "    text_content = file.read()\n",
    "    \n",
    "# Now text_content contains the content of the state of the union address"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's use the LangChain CharacterTextSplitter and split by every 100 tokens (just to keep thigns simple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of chunks: 106\n"
     ]
    }
   ],
   "source": [
    "from langchain.text_splitter import CharacterTextSplitter\n",
    "\n",
    "# Initialize the text splitter with a specific chunk size\n",
    "text_splitter = CharacterTextSplitter.from_tiktoken_encoder(\n",
    "    chunk_size=100, chunk_overlap=0\n",
    ")\n",
    "texts = text_splitter.split_text(text_content)\n",
    "# Print the total number of chunks\n",
    "print(f\"Total number of chunks: {len(texts)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First chunk: Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans.  \n",
      "\n",
      "Last year COVID-19 kept us apart. This year we are finally together again. \n",
      "\n",
      "Tonight, we meet as Democrats Republicans and Independents. But most importantly as Americans. \n",
      "\n",
      "With a duty to one another to the American people to the Constitution.\n"
     ]
    }
   ],
   "source": [
    "# Print the first chunk\n",
    "print(\"First chunk:\", texts[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generating Text Embeddings with Azure OpenAI Service\n",
    "\n",
    "This script processes text chunks using Azure OpenAI's embedding functions to generate embeddings, organizing the results into Pandas DataFrames for analysis or storage. A helper function, create_embedding_df, iterates over text inputs to create embeddings of varying dimensions (small, medium, large), resulting in three distinct DataFrames that facilitate comparative analysis or further application.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Helper function to process texts and create a DataFrame\n",
    "def create_embedding_df(texts, embedding_function):\n",
    "    data = []\n",
    "    for i, text in enumerate(texts):\n",
    "        # Generate embedding\n",
    "        vector = embedding_function(text)\n",
    "        # Append the data with an ID, the original text, and the generated vector\n",
    "        data.append({\"id\": str(i), \"text\": text, \"vector\": vector})\n",
    "    # Create a DataFrame\n",
    "    df = pd.DataFrame(data, columns=[\"id\", \"text\", \"vector\"])\n",
    "    return df\n",
    "\n",
    "# Process the texts with each embedding function and create the DataFrames\n",
    "df_small = create_embedding_df(texts, generate_small_embedding)\n",
    "df_medium = create_embedding_df(texts, generate_medium_embedding)\n",
    "df_large = create_embedding_df(texts, generate_large_embedding)\n",
    "\n",
    "# Now, df_small, df_medium, and df_large DataFrames contain the vector embeddings for each chunk of text.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to upload these to Azure AI Search, we must convert the data frames to a list of dictionaries. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert DataFrames to lists of dictionaries\n",
    "documents_small = df_small.to_dict('records')\n",
    "documents_medium = df_medium.to_dict('records')\n",
    "documents_large = df_large.to_dict('records')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have are data in a readyily avaialble format ready to import to Azure AI Search, let's create a vector index."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Upload Data to Azure AI Search Index\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Uploaded successfully to small index\n",
      "Uploaded successfully to medium index\n",
      "Uploaded successfully to large index\n"
     ]
    }
   ],
   "source": [
    "# Define a dictionary mapping index sizes to their corresponding documents\n",
    "documents_dict = {\n",
    "    \"small\": documents_small,\n",
    "    \"medium\": documents_medium,\n",
    "    \"large\": documents_large,\n",
    "}\n",
    "\n",
    "# Loop through each index size and upload the documents\n",
    "for size, documents in documents_dict.items():\n",
    "    upload_result = search_clients[size].upload_documents(documents=documents)\n",
    "    print(f\"Uploaded successfully to {size} index\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GET Index Statistics\n",
    "\n",
    "Let's view the `StorageSize` and `VectorIndexSize` of each indexes to see how the vector dimensionality plays a role. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Index Name  Storage Size (bytes)  Vector Index Size (bytes)  \\\n",
      "0   index-256d                607036                     116032   \n",
      "1  index-1536d               2808491                     658752   \n",
      "2  index-3072d               5532616                    1310016   \n",
      "\n",
      "   Document Count  \n",
      "0             106  \n",
      "1             106  \n",
      "2             106  \n"
     ]
    }
   ],
   "source": [
    "def fetch_index_statistics(index_info):\n",
    "    # Prepare a list to hold the index statistics\n",
    "    stats_data = []\n",
    "\n",
    "    # Iterate over each index in index_info\n",
    "    for key, value in index_info.items():\n",
    "        index_name = value[\"name\"]\n",
    "        # Fetch the statistics for the current index\n",
    "        stats = index_client.get_index_statistics(index_name=index_name)\n",
    "\n",
    "        # Append the statistics to our list\n",
    "        stats_data.append(\n",
    "            {\n",
    "                \"Index Name\": index_name,\n",
    "                \"Storage Size (bytes)\": stats[\"storage_size\"],\n",
    "                \"Vector Index Size (bytes)\": stats[\"vector_index_size\"],\n",
    "                \"Document Count\": stats[\"document_count\"],\n",
    "            }\n",
    "        )\n",
    "\n",
    "    # Convert the list of statistics into a DataFrame for nicer display\n",
    "    return pd.DataFrame(stats_data)\n",
    "\n",
    "\n",
    "# Fetch the statistics for each index and store in a DataFrame\n",
    "df_stats = fetch_index_statistics(index_info)\n",
    "\n",
    "# Display the DataFrame\n",
    "print(df_stats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "# Index names\n",
    "index_names = ['index-256d', 'index-1536d', 'index-3072d']\n",
    "\n",
    "# Storage sizes in MB (for demonstration, replace these with your actual values)\n",
    "storage_sizes = [0.58, 2.68, 5.28]\n",
    "\n",
    "# Vector index sizes in MB (for demonstration, replace these with your actual values)\n",
    "vector_index_sizes = [0.11, 0.63, 1.25]\n",
    "\n",
    "# Setting the positions and width for the bars\n",
    "pos = np.arange(len(index_names))\n",
    "width = 0.35\n",
    "\n",
    "# Plotting both the storage size and vector index size in the same chart\n",
    "fig, ax = plt.subplots()\n",
    "bar1 = ax.bar(pos - width/2, storage_sizes, width, label='Storage Size (MB)')\n",
    "bar2 = ax.bar(pos + width/2, vector_index_sizes, width, label='Vector Index Size (MB)')\n",
    "\n",
    "# Adding some text for labels, title, and custom x-axis tick labels, etc.\n",
    "ax.set_ylabel('Size in MB')\n",
    "ax.set_title('Storage and Vector Index Sizes by Index')\n",
    "ax.set_xticks(pos)\n",
    "ax.set_xticklabels(index_names)\n",
    "ax.legend()\n",
    "\n",
    "# Adding a legend\n",
    "ax.legend()\n",
    "\n",
    "# Function to add labels on top of the bars\n",
    "def autolabel(bars):\n",
    "    \"\"\"Attach a text label above each bar in *bars*, displaying its height.\"\"\"\n",
    "    for bar in bars:\n",
    "        height = bar.get_height()\n",
    "        ax.annotate('{}'.format(height),\n",
    "                    xy=(bar.get_x() + bar.get_width() / 2, height),\n",
    "                    xytext=(0, 3),  # 3 points vertical offset\n",
    "                    textcoords=\"offset points\",\n",
    "                    ha='center', va='bottom')\n",
    "\n",
    "# Call the function for each bar\n",
    "autolabel(bar1)\n",
    "autolabel(bar2)\n",
    "\n",
    "# Show the plot\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Azure AI Search Index Statistics\n",
    "\n",
    "Below is a summary table of the Azure AI Search indexes, showing the storage size and vector index size in megabytes (MB), along with the document count for each index:\n",
    "\n",
    "| Index Name  | Storage Size (MB) | Vector Index Size (MB) | Document Count |\n",
    "|-------------|-------------------|------------------------|----------------|\n",
    "| index-256d  | 0.58              | 0.11                   | 106            |\n",
    "| index-1536d | 2.68              | 0.63                   | 106            |\n",
    "| index-3072d | 5.28              | 1.25                   | 106            |\n",
    "\n",
    "### Insights:\n",
    "- **Storage Size (MB)** and **Vector Index Size (MB)** are approximations, calculated from bytes to MB (1 MB = 1,048,576 bytes). View our [Vector index size documentation](https://learn.microsoft.com/en-us/azure/search/vector-search-index-size?tabs=portal-vector-quota) to learn more. \n",
    "- The **Document Count** indicates the total number of chunks/documents stored in each index.\n",
    "- These statistics highlight the relationship between the dimensionality of the embeddings and the storage requirements. As the dimensionality increases, so does the storage and vector index size, reflecting the trade-off between detail (or accuracy) and resource utilization.\n",
    "- **Relative Differences**:\n",
    "    - The **index-1536d** is approximately **4.6x larger** in storage size and **5.7x larger** in vector index size than the **index-256d**.\n",
    "    - The **index-3072d** is approximately **2x larger** in storage size and **2x larger** in vector index size than the **index-1536d**, showcasing the significant impact of increasing the embedding dimensionality on storage and indexing resource requirements.\n",
    "\n",
    "These comparative insights demonstrate how embedding dimensionality influences not just the accuracy and detail of stored embeddings but also the practical aspects of storage and indexing within Azure AI Search, emphasizing the need to balance between embedding detail and resource efficiency.\n"
   ]
  }
 ],
 "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.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}