ElevateChat&AIApplications/Part2 -- Embedding Generator for Cognitive Search: Revolutionizing Conversational Context.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 2 -- Embedding Generator for Cognitive Search: Revolutionizing Conversational Context\n",
    "\n",
    "In today's data-driven landscape, efficient information retrieval and intelligent interactions are pivotal in extracting the maximum value from the vast repository of digital content. This quest for enhancing data utilization has led to the convergence of cutting-edge technologies that transcend traditional search paradigms. Enter Azure Cognitive Search – Microsoft's powerful cloud-based search service that transforms raw data into actionable insights.\n",
    "\n",
    "Custom skills, a flagship feature of Azure Cognitive Search, empowers developers and data enthusiasts to reshape the indexing pipeline according to their unique requirements. By inserting tailored code and external services into this pipeline, data processing transcends conventional boundaries, opening the doors to a multitude of custom actions.\n",
    "\n",
    "This personal portfolio project embarks on an enlightening exploration of custom skills within Azure Cognitive Search, delving into the intricate amalgamation of AI and search. We'll do this by dissecting a custom skill developed by Microsoft, the Azure Open AI Embeddings Generator and which is open source here: https://github.com/Azure-Samples/azure-search-power-skills/blob/main/Vector/EmbeddingGenerator/README.md\n",
    "\n",
    "However, our journey doesn't stop at search efficiency. With the advent of OpenAI Embedding Generator, a powerful Azure function, we bridge the gap between indexing and intelligent interactions. Imagine a world where search is not limited to keywords and phrases, but extends to the semantic realm – where documents aren't just indexed, but understood at a deeper level. We unravel the magic behind the OpenAI Embedding Generator, which breathes life into the data, generating rich embeddings that pave the way for novel AI applications.\n",
    "\n",
    "But the story doesn't end there. These embeddings become the cornerstone for the Language Model applications (LLMs) and chatbots of the future. Our project encapsulates the seamless fusion of indexed data, embeddings, and advanced AI models, culminating in a symphony of human-like interactions. LLMs don't just generate text; they craft narratives, answer queries, and dive into the reservoir of knowledge locked within your data.\n",
    "\n",
    "Join us on this enthralling journey as we demystify the amalgamation of Azure Cognitive Search, OpenAI Embedding Generator, and Language Models. Discover how the indexing pipeline evolves into a dynamic narrative generator, and how search transcends into insightful conversations. As we navigate through the technical intricacies and the transformative potential, we invite you to envision the dawn of a new era in data-driven interactions.\n",
    "\n",
    "Are you ready to delve into the heart of enhanced search and AI-driven conversations? Let's embark on this transformative expedition together.\n",
    "Stay tuned for the chapters that unveil the magic of Azure Cognitive Search, the prowess of OpenAI Embeddings, and the marvel of Language Models.\n",
    "\n",
    "\n",
    "### Azure Cognitive Search custom skills\n",
    "\n",
    "Custom skills are a powerful feature that allow you to extend the capabilities of Azure Cognitive Search's indexing pipeline. When you ingest data into Azure Cognitive Search for indexing, it goes through a series of processing steps to tokenize, normalize, and prepare the data for search. Custom skills allow you to insert your own custom code or external services at different points in this processing pipeline, enabling you to perform custom actions on the data before it is indexed.\n",
    "\n",
    "These custom actions can include tasks such as:\n",
    "\n",
    "**Text extraction and analysis:** You can use custom skills to extract specific information from documents, such as named entities, keywords, or sentiment analysis scores. This can enhance the search experience by providing more context to users.\n",
    "\n",
    "**Language translation:** If you have content in multiple languages, you can use custom skills to translate the content into a common language for indexing, making your search system multilingual.\n",
    "\n",
    "**Image analysis:** If your search data includes images, you can use custom skills to analyze the images and extract useful information, such as object recognition, image captions, or other metadata.\n",
    "\n",
    "**Data enrichment:** You can use external data sources or APIs to enrich your indexed data. For example, you could use a custom skill to retrieve additional information about a product from an external database and include that information in the indexed content.\n",
    "\n",
    "**Entity recognition:** You can identify and tag specific entities in your data, such as names of people, locations, organizations, or product names, which can help improve search accuracy and relevance.\n",
    "\n",
    "To implement a custom skill, you generally need to provide a function or a web service endpoint that performs the desired action on the data. Azure Cognitive Search then invokes this function or endpoint as part of the indexing process.\n",
    "\n",
    "### Azure Open AI Embedding Generator\n",
    "\n",
    "This project is about understanding what happens with documents once its passed into the indexing pipeline in Azure Cognitive Search where you configured a Power Skill, (OpenAI Embeddings).  This Power Skill actually generates the embedddings and stores them, which is crutial in order to be able to do similarity search later and use an LLM model for generating text based on internal documents that you have indexed.\n",
    "\n",
    "The code is open sourced from Microsoft and you can find it here: https://github.com/Azure-Samples/azure-search-power-skills/blob/main/Vector/EmbeddingGenerator/README.md\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Document\n",
    "\n",
    "\n",
    "This code defines a Python data model for representing documents. The class is named Document, and it is created using Python's dataclasses module, which helps to simplify the creation of classes by automatically generating special methods like __init__, __repr__, and __eq__ based on the class attributes.\n",
    "\n",
    "##### Class Attributes:\n",
    "The Document class has several attributes:\n",
    "\n",
    "a. **content:** This attribute represents the content of the document and is of type str. It is a required attribute, and every Document object must have a content value.\n",
    "\n",
    "b. **id:** An optional attribute of type str, representing the unique identifier of the document. If provided, it can be used to uniquely identify a document in a collection.\n",
    "\n",
    "c. **title:** An optional attribute of type str, representing the title of the document. If provided, it contains the title or name of the document.\n",
    "\n",
    "d. **filepath:** An optional attribute of type str, representing the file path of the document. If provided, it holds the path to the location of the document in the file system.\n",
    "\n",
    "e. **url:** An optional attribute of type str, representing the URL of the document. If provided, it can store the web address or location of the document on the internet.\n",
    "\n",
    "f. **embedding_metadata:** An optional attribute of type Dict, representing the metadata associated with the document's embedding (a numerical representation of the document's content). If provided, it can store additional information related to the embedding process, such as model version, hyperparameters, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dataclasses import dataclass\n",
    "from typing import Dict, Optional\n",
    "\n",
    "\n",
    "@dataclass\n",
    "class Document():\n",
    "    \"\"\"A data class for storing documents\n",
    "\n",
    "    Attributes:\n",
    "        content (str): The content of the document.\n",
    "        id (Optional[str]): The id of the document.\n",
    "        title (Optional[str]): The title of the document.\n",
    "        filepath (Optional[str]): The filepath of the document.\n",
    "        url (Optional[str]): The url of the document.\n",
    "        metadata (Optional[Dict]): The metadata of the document.    \n",
    "    \"\"\"\n",
    "\n",
    "    content: str\n",
    "    id: Optional[str] = None\n",
    "    title: Optional[str] = None\n",
    "    filepath: Optional[str] = None\n",
    "    url: Optional[str] = None\n",
    "    embedding_metadata: Optional[Dict] = None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ChunkingResult\n",
    "\n",
    "The '@dataclass' decorator is applied to this class, which is a feature provided by Python's dataclasses module. By using this decorator, we can create a class with automatically generated special methods like init, repr, and eq, based on the class attributes. It significantly reduces boilerplate code that would typically be written for these special methods.\n",
    "\n",
    "##### Class Attributes:\n",
    "Inside the 'ChunkingResult' class, we have several attributes:\n",
    "\n",
    "a. **'chunks':** This attribute is a list of 'Document' objects representing the individual chunks obtained from the chunking process.\n",
    "\n",
    "b. **'total_files':** An integer representing the total number of files processed during chunking.\n",
    "\n",
    "c. **'num_unsupported_format_files':** An optional integer (with a default value of 0) indicating the number of files with unsupported formats. This attribute is useful if some files couldn't be processed due to unsupported formats.\n",
    "\n",
    "d. **'num_files_with_errors':** Another optional integer (defaulted to 0) representing the number of files that encountered errors during chunking. This attribute is useful for tracking the number of files that failed to process successfully.\n",
    "\n",
    "e. **'skipped_chunks':** An optional integer (defaulted to 0) indicating the number of chunks that were skipped during chunking. This attribute might be helpful if some chunks are excluded from processing for specific reasons."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Data model for chunking result\n",
    "\n",
    "Classes:\n",
    "    ChunkingResult: Data model for chunking result.\n",
    "\"\"\"\n",
    "from dataclasses import dataclass\n",
    "\n",
    "from typing import List\n",
    "from .document import Document\n",
    "\n",
    "\n",
    "@dataclass\n",
    "class ChunkingResult:\n",
    "    \"\"\"Data model for chunking result\n",
    "\n",
    "    Attributes:\n",
    "        chunks (List[Document]): List of chunks.\n",
    "        total_files (int): Total number of files.\n",
    "        num_unsupported_format_files (int): Number of files with unsupported format.\n",
    "        num_files_with_errors (int): Number of files with errors.\n",
    "        skipped_chunks (int): Number of chunks skipped.\n",
    "    \"\"\"\n",
    "    chunks: List[Document]\n",
    "    total_files: int\n",
    "    num_unsupported_format_files: int = 0\n",
    "    num_files_with_errors: int = 0\n",
    "    skipped_chunks: int = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### TokenEstimator\n",
    "\n",
    "Very self explanatory, it just let us know the Token Length of some text. We can use any encoding here.\n",
    "\n",
    "```python\n",
    "# Example usage:\n",
    "estimator = TokenEstimator()\n",
    "text_to_estimate = \"This is a sample text to estimate tokens.\"\n",
    "num_tokens = estimator.estimate_tokens(text_to_estimate)\n",
    "print(f\"Number of tokens in the text: {num_tokens}\")\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tiktoken\n",
    "\n",
    "class TokenEstimator():\n",
    "    GPT2_TOKENIZER = tiktoken.get_encoding(\"gpt2\")\n",
    "\n",
    "    def estimate_tokens(self, text: str) -> int:\n",
    "        return len(self.GPT2_TOKENIZER.encode(text))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### TextChunker\n",
    "\n",
    "This codes is the main responsible to split the text into chunks. It uses langchain MarkdownTextSplitter, RecursiveCharacterTextSplitter, PythonCodeTextSplitter.\n",
    "\n",
    "The main method: chunk_conten takes a piece of content and breaks it down into smaller chunks. It's used to split large documents into smaller segments for processing or analysis. Some comments were added in the code to improve readability."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from typing import Generator, List, Optional, Tuple\n",
    "from .document import Document\n",
    "from .chunking_result import ChunkingResult\n",
    "from .token_estimator import TokenEstimator\n",
    "from langchain.text_splitter import MarkdownTextSplitter, RecursiveCharacterTextSplitter, PythonCodeTextSplitter\n",
    "\n",
    "class UnsupportedFormatError(Exception):\n",
    "    \"\"\"Exception raised when a format is not supported.\"\"\"\n",
    "    pass\n",
    "\n",
    "\n",
    "class TextChunker():\n",
    "    \"\"\"Text chunker class.\n",
    "\n",
    "    Attributes:\n",
    "        supported_formats (List[str]): List of supported file formats.\n",
    "    \"\"\"\n",
    "    FILE_FORMAT_DICT = {\n",
    "        \"md\": \"markdown\",\n",
    "        \"txt\": \"text\",\n",
    "        \"html\": \"html\",\n",
    "        \"shtml\": \"html\",\n",
    "        \"htm\": \"html\",\n",
    "        \"py\": \"python\",\n",
    "        \"pdf\": \"pdf\",\n",
    "    }\n",
    "    SENTENCE_ENDINGS = [\".\", \"!\", \"?\"]\n",
    "    WORDS_BREAKS = ['\\n', '\\t', '}', '{', ']', '[', ')', '(', ' ', ':', ';', ',']\n",
    "    TOKEN_ESTIMATOR = TokenEstimator()\n",
    "\n",
    "    def _get_file_format(self, file_path: str) -> Optional[str]:\n",
    "        \"\"\"Gets the file format from the file name.\n",
    "        Returns None if the file format is not supported.\n",
    "        Args:\n",
    "            file_path (str): The file path of the file whose format needs to be retrieved.\n",
    "        Returns:\n",
    "            str: The file format.\n",
    "        \"\"\"\n",
    "        # in case the caller gives us a file path\n",
    "        file_path = os.path.basename(file_path)\n",
    "        file_extension = file_path.split(\".\")[-1]\n",
    "        return self.FILE_FORMAT_DICT.get(file_extension, None)\n",
    "\n",
    "    def _chunk_content_helper(self,\n",
    "            content: str, file_format: str, file_path: Optional[str],\n",
    "            token_overlap: int,\n",
    "            num_tokens: int\n",
    "    ) -> Generator[Tuple[str, int, Document], None, None]:\n",
    "\n",
    "        if file_format == \"markdown\":\n",
    "            splitter = MarkdownTextSplitter.from_tiktoken_encoder(chunk_size=num_tokens, chunk_overlap=token_overlap)\n",
    "        elif file_format == \"python\":\n",
    "            splitter = PythonCodeTextSplitter.from_tiktoken_encoder(chunk_size=num_tokens, chunk_overlap=token_overlap)\n",
    "        else:\n",
    "            splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(\n",
    "                separators=self.SENTENCE_ENDINGS + self.WORDS_BREAKS,\n",
    "                chunk_size=num_tokens, chunk_overlap=token_overlap)\n",
    "        chunked_content_list = splitter.split_text(content)\n",
    "        for chunked_content in chunked_content_list:\n",
    "            chunk_size = self.TOKEN_ESTIMATOR.estimate_tokens(chunked_content)\n",
    "            yield chunked_content, chunk_size, content\n",
    "\n",
    "\n",
    "   \n",
    "\n",
    "    def chunk_content(\n",
    "        self,\n",
    "        content: str,\n",
    "        file_path: Optional[str] = None,\n",
    "        url: Optional[str] = None,\n",
    "        ignore_errors: bool = True,\n",
    "        num_tokens: int = 2048,\n",
    "        min_chunk_size: int = 10,\n",
    "        token_overlap: int = 0\n",
    "    ) -> ChunkingResult:\n",
    "        \"\"\"Chunks the given content. If ignore_errors is true, returns None\n",
    "         in case of an error\n",
    "        Args:\n",
    "            content (str): The content to chunk.\n",
    "            file_path (str): The file name. used for title, file format detection.\n",
    "            url (str): The url. used for title.\n",
    "            ignore_errors (bool): If true, ignores errors and returns None.\n",
    "            num_tokens (int): The number of tokens in each chunk.\n",
    "            min_chunk_size (int): The minimum chunk size below which chunks will be filtered.\n",
    "            token_overlap (int): The number of tokens to overlap between chunks.\n",
    "        Returns:\n",
    "            List[Document]: List of chunked documents.\n",
    "        \"\"\"\n",
    "\n",
    "        try:\n",
    "            # Determine the file format based on the file_path (if provided) or default to \"text.\"\n",
    "            if file_path is None:\n",
    "                file_format = \"text\"\n",
    "            else:\n",
    "                file_format = self._get_file_format(file_path)\n",
    "                if file_format is None:\n",
    "                    raise UnsupportedFormatError(\n",
    "                        f\"{file_path} is not supported\")\n",
    "\n",
    "            # Break down the content into chunks using the _chunk_content_helper method.\n",
    "            chunked_context = self._chunk_content_helper(\n",
    "                content=content,\n",
    "                file_path=file_path,\n",
    "                file_format=file_format,\n",
    "                num_tokens=num_tokens,\n",
    "                token_overlap=token_overlap\n",
    "            )\n",
    "            chunks = []\n",
    "            skipped_chunks = 0\n",
    "            for chunk, chunk_size, doc in chunked_context:\n",
    "                # Check if the chunk size meets the minimum requirement.\n",
    "                if chunk_size >= min_chunk_size:\n",
    "                    # Append the chunk as a Document object to the chunks list.\n",
    "                    chunks.append(\n",
    "                        Document(\n",
    "                            content=chunk,\n",
    "                            title=file_path,\n",
    "                            url=url,\n",
    "                            filepath=file_path\n",
    "                        )\n",
    "                    )\n",
    "                else:\n",
    "                    # Increment the skipped_chunks counter if the chunk is too small.\n",
    "                    skipped_chunks += 1\n",
    "\n",
    "        except UnsupportedFormatError as e:\n",
    "            # Handle UnsupportedFormatError if ignore_errors is True, otherwise raise the exception.\n",
    "            if ignore_errors:\n",
    "                return ChunkingResult(\n",
    "                    chunks=[], total_files=1, num_unsupported_format_files=1\n",
    "                )\n",
    "            else:\n",
    "                raise e\n",
    "        except Exception as e:\n",
    "            # Handle any other exception if ignore_errors is True, otherwise raise the exception.\n",
    "            if ignore_errors:\n",
    "                return ChunkingResult(chunks=[], total_files=1, num_files_with_errors=1)\n",
    "            else:\n",
    "                raise e\n",
    "\n",
    "        # Return the result of the chunking process as a ChunkingResult object.\n",
    "        return ChunkingResult(\n",
    "            chunks=chunks,\n",
    "            total_files=1,\n",
    "            skipped_chunks=skipped_chunks,\n",
    "        )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ChunkEmbeddingHelper\n",
    "\n",
    "The code defines a `ChunkEmbeddingHelper` class to generate embeddings for content chunks using `TextEmbedder`. The `generate_chunks_with_embedding` method processes large documents in smaller parts, embedding each chunk separately. It introduces delays between embedding calls to avoid exceeding the OpenAI API rate limit. The `_generate_content_metadata` method creates metadata for each chunk, including field name, document ID, index, offset, length, and embedding. This approach allows efficient processing of large texts and enables individual analysis of content chunks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "from embedder.text_embedder import TextEmbedder\n",
    "\n",
    "class ChunkEmbeddingHelper():\n",
    "    def __init__(self):\n",
    "        self.text_embedder = TextEmbedder()\n",
    "\n",
    "    def generate_chunks_with_embedding(self, document_id, content_chunks, fieldname, sleep_interval_seconds) ->  dict:\n",
    "        offset = 0\n",
    "        chunk_embeddings = []\n",
    "        for index, (content_chunk) in enumerate(content_chunks):\n",
    "            metadata = self._generate_content_metadata(document_id, fieldname, index, content_chunk, offset)\n",
    "            offset += metadata['length']\n",
    "            chunk_embeddings.append(metadata)\n",
    "            \n",
    "            # A very crude way to introduce some delay between each embedding call\n",
    "            # This is to avoid hitting the rate limit of the OpenAI API\n",
    "            time.sleep(sleep_interval_seconds)\n",
    "        return chunk_embeddings\n",
    "\n",
    "    def _generate_content_metadata(self, document_id, fieldname, index, content, offset):\n",
    "        metadata = {'fieldname':fieldname}\n",
    "        metadata['docid'] = document_id\n",
    "        metadata['index'] = index\n",
    "        metadata['offset'] = offset\n",
    "        metadata['length'] = len(content)\n",
    "        metadata['embedding'] = self.text_embedder.embed_content(content)\n",
    "        return metadata"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### TextEmbedder\n",
    "\n",
    "This code defines a TextEmbedder class responsible for embedding text using the Azure OpenAI API. It sets up the API connection and handles embedding requests. The clean_text method removes unnecessary spaces and truncates the text if it exceeds a specified limit. The embed_content method retries embedding requests using exponential backoff in case of errors. It returns the embedding of the provided text with adjustable precision, using the Azure OpenAI API. The class is designed to facilitate embedding text and handling potential API issues while ensuring a smooth and reliable process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import openai\n",
    "import os\n",
    "import re\n",
    "import logging\n",
    "from tenacity import retry, wait_random_exponential, stop_after_attempt  \n",
    "\n",
    "class TextEmbedder():\n",
    "    openai.api_type = \"azure\"    \n",
    "    openai.api_key = os.getenv(\"AZURE_OPENAI_API_KEY\")\n",
    "    openai.api_base = f\"https://{os.getenv('AZURE_OPENAI_SERVICE_NAME')}.openai.azure.com/\"\n",
    "    openai.api_version = os.getenv(\"AZURE_OPENAI_API_VERSION\")\n",
    "    AZURE_OPENAI_EMBEDDING_DEPLOYMENT = os.getenv(\"AZURE_OPENAI_EMBEDDING_DEPLOYMENT\")\n",
    "\n",
    "    def clean_text(self, text, text_limit=7000):\n",
    "        # Clean up text (e.g. line breaks, )    \n",
    "        text = re.sub(r'\\s+', ' ', text).strip()\n",
    "        text = re.sub(r'[\\n\\r]+', ' ', text).strip()\n",
    "        # Truncate text if necessary (e.g. for, ada-002, 4095 tokens ~ 7000 chracters)    \n",
    "        if len(text) > text_limit:\n",
    "            logging.warning(\"Token limit reached exceeded maximum length, truncating...\")\n",
    "            text = text[:text_limit]\n",
    "        return text\n",
    "\n",
    "    @retry(wait=wait_random_exponential(min=1, max=20), stop=stop_after_attempt(6))\n",
    "    def embed_content(self, text, clean_text=True, use_single_precision=True):\n",
    "        embedding_precision = 9 if use_single_precision else 18\n",
    "        if clean_text:\n",
    "            text = self.clean_text(text)\n",
    "        response = openai.Embedding.create(input=text, engine=self.AZURE_OPENAI_EMBEDDING_DEPLOYMENT)\n",
    "        embedding = [round(x, embedding_precision) for x in response['data'][0]['embedding']]\n",
    "        return embedding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The function\n",
    "\n",
    "Its an HTTP Trigger that implements text chunking and embedding using the Azure OpenAI API. The function expects a JSON request containing a list of documents, each with a unique identifier (recordId) and relevant data fields (text, document_id, filepath, and fieldname). The text from each document is processed using the `TextChunker` and `ChunkEmbeddingHelper` classes.\n",
    "\n",
    "The `text_chunking` function receives HTTP requests and validates the JSON payload against a predefined schema using jsonschema. If the request is invalid, it returns an error response.\n",
    "\n",
    "The function retrieves environment variables related to the Azure OpenAI API and text chunking parameters (e.g., `NUM_TOKENS, MIN_CHUNK_SIZE, TOKEN_OVERLAP, AZURE_OPENAI_EMBEDDING_SLEEP_INTERVAL_SECONDS`).\n",
    "\n",
    "It iterates through each document in the request, chunks the text content into smaller segments using the `TEXT_CHUNKER` object, and generates embeddings for each chunk using the `CHUNK_METADATA_HELPER` object. The sleep_interval_seconds introduces delays between embedding calls to avoid API rate limits.\n",
    "\n",
    "For each chunk, the function stores the embedding metadata in the original chunk object.\n",
    "\n",
    "The resulting chunked data is assembled into a response JSON and returned.\n",
    "\n",
    "The `get_request_schema` function defines the JSON schema for the request payload, ensuring it contains the required fields and proper data types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import azure.functions as func\n",
    "import os\n",
    "import logging\n",
    "import json\n",
    "import jsonschema\n",
    "from chunker.text_chunker import TextChunker\n",
    "from chunker.chunk_metadata_helper import ChunkEmbeddingHelper\n",
    "\n",
    "app = func.FunctionApp()\n",
    "\n",
    "TEXT_CHUNKER = TextChunker()\n",
    "CHUNK_METADATA_HELPER = ChunkEmbeddingHelper()\n",
    "\n",
    "\"\"\"\n",
    "Required environment variables:\n",
    "\"AZURE_OPENAI_API_KEY\"\n",
    "\"AZURE_OPENAI_API_VERSION\"\n",
    "\"AZURE_OPENAI_EMBEDDING_DEPLOYMENT\"\n",
    "\"AZURE_OPENAI_SERVICE_NAME\"\n",
    "\n",
    "Optional environment variables:\n",
    "\"AZURE_OPENAI_EMBEDDING_SLEEP_INTERVAL_SECONDS\" (default: 1)\n",
    "\"\"\"\n",
    "\n",
    "@app.function_name(name=\"TextEmbedder\")\n",
    "@app.route(route=\"chunk-embed\")\n",
    "def text_chunking(req: func.HttpRequest) -> func.HttpResponse:\n",
    "\n",
    "    logging.info('Python HTTP trigger function processed a request.')\n",
    "    \n",
    "    sleep_interval_seconds = int(os.getenv(\"AZURE_OPENAI_EMBEDDING_SLEEP_INTERVAL_SECONDS\", \"1\"))\n",
    "    num_tokens = int(os.getenv(\"NUM_TOKENS\", \"2048\"))\n",
    "    min_chunk_size = int(os.getenv(\"MIN_CHUNK_SIZE\", \"10\"))\n",
    "    token_overlap = int(os.getenv(\"TOKEN_OVERLAP\", \"0\"))\n",
    "\n",
    "    request = req.get_json()\n",
    "\n",
    "    try:\n",
    "        jsonschema.validate(request, schema=get_request_schema())\n",
    "    except jsonschema.exceptions.ValidationError as e:\n",
    "        return func.HttpResponse(\"Invalid request: {0}\".format(e), status_code=400)\n",
    "\n",
    "    values = []\n",
    "    for value in request['values']:\n",
    "        recordId = value['recordId']\n",
    "        document_id = value['data']['document_id']\n",
    "        text = value['data']['text']\n",
    "        filepath = value['data']['filepath']\n",
    "        fieldname = value['data']['fieldname']\n",
    "    \n",
    "        # chunk documents into chunks of (by default) 2048 tokens, and for each chunk, generate the vector embedding\n",
    "        chunking_result = TEXT_CHUNKER.chunk_content(text, file_path=filepath, num_tokens=num_tokens, min_chunk_size=min_chunk_size, token_overlap=token_overlap)\n",
    "        content_chunk_metadata = CHUNK_METADATA_HELPER.generate_chunks_with_embedding(document_id, [c.content for c in chunking_result.chunks], fieldname, sleep_interval_seconds)\n",
    "\n",
    "        for document_chunk, embedding_metadata in zip(chunking_result.chunks, content_chunk_metadata):\n",
    "            document_chunk.embedding_metadata = embedding_metadata\n",
    "\n",
    "        values.append({\n",
    "            \"recordId\": recordId,\n",
    "            \"data\": chunking_result,\n",
    "            \"errors\": None,\n",
    "            \"warnings\": None\n",
    "        })\n",
    "\n",
    "\n",
    "    response_body = { \"values\": values }\n",
    "\n",
    "    logging.info(f'Python HTTP trigger function created {len(chunking_result.chunks)} chunks.')\n",
    "\n",
    "    response = func.HttpResponse(json.dumps(response_body, default=lambda obj: obj.__dict__))\n",
    "    response.headers['Content-Type'] = 'application/json'    \n",
    "    return response\n",
    "\n",
    "def get_request_schema():\n",
    "    return {\n",
    "        \"$schema\": \"http://json-schema.org/draft-04/schema#\",\n",
    "        \"type\": \"object\",\n",
    "        \"properties\": {\n",
    "            \"values\": {\n",
    "                \"type\": \"array\",\n",
    "                \"minItems\": 1,\n",
    "                \"items\": {\n",
    "                    \"type\": \"object\",\n",
    "                    \"properties\": {\n",
    "                        \"recordId\": {\"type\": \"string\"},\n",
    "                        \"data\": {\n",
    "                            \"type\": \"object\",\n",
    "                            \"properties\": {\n",
    "                                \"text\": {\"type\": \"string\", \"minLength\": 1},\n",
    "                                \"document_id\": {\"type\": \"string\", \"minLength\": 1},\n",
    "                                \"filepath\": {\"type\": \"string\", \"minLength\": 1},\n",
    "                                \"fieldname\": {\"type\": \"string\", \"minLength\": 1}\n",
    "                            },\n",
    "                            \"required\": [\"text\", \"document_id\", \"filepath\", \"fieldname\"],\n",
    "                        },\n",
    "                    },\n",
    "                    \"required\": [\"recordId\", \"data\"],\n",
    "                },\n",
    "            }\n",
    "        },\n",
    "        \"required\": [\"values\"],\n",
    "    }"
   ]
  },
  {
   "attachments": {
    "image-2.png": {
     "image/png": "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"
    },
    "image-3.png": {
     "image/png": "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"
    },
    "image-4.png": {
     "image/png": "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"
    },
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Testing it locally\n",
    "\n",
    "In order to test it locally, we use PostMan, first we press F5 in our VS Code project, this will launch the project and will allow us to make HTTP calls locally. When you press F5 you will see in the terminal Window something like this, your REST API is ready for testing\n",
    "\n",
    "![image.png](attachment:image.png)\n",
    "\n",
    "Now in Postman just create a new Request, in the body select raw and paste:\n",
    "\n",
    "![image-2.png](attachment:image-2.png)\n",
    "\n",
    "```json\n",
    "{\n",
    "    \"values\": [\n",
    "        {\n",
    "            \"recordId\": \"1234\",\n",
    "            \"data\": {\n",
    "                \"document_id\": \"12345ABC\",\n",
    "                \"text\": \"This is a test document and it is big enough to ensure that it meets the minimum chunk size. But what about if we want to chung it\",\n",
    "                \"filepath\": \"foo.md\",\n",
    "                \"fieldname\": \"content\"\n",
    "            }\n",
    "        }\n",
    "    ]\n",
    "}```\n",
    "\n",
    "\n",
    "If it works, then you will get the embeddings like this:\n",
    "\n",
    "```json\n",
    "{\n",
    "    \"values\": [\n",
    "        {\n",
    "            \"recordId\": \"1234\",\n",
    "            \"data\": {\n",
    "                \"chunks\": [\n",
    "                    {\n",
    "                        \"content\": \"This is a test document and it is big enough to ensure that it meets the minimum chunk size. But what about if we want to chung it\",\n",
    "                        \"id\": null,\n",
    "                        \"title\": \"foo.md\",\n",
    "                        \"filepath\": \"foo.md\",\n",
    "                        \"url\": null,\n",
    "                        \"embedding_metadata\": {\n",
    "                            \"fieldname\": \"content\",\n",
    "                            \"docid\": \"12345ABC\",\n",
    "                            \"index\": 0,\n",
    "                            \"offset\": 0,\n",
    "                            \"length\": 130,\n",
    "                            \"embedding\": [\n",
    "                                0.011029272,\n",
    "                                0.012983655,\n",
    "                                0.02085585,\n",
    "                                0.01010675,\n",
    "                                -0.014309354,\n",
    "                                0.025529964,\n",
    "                                -0.02235922,\n",
    "                                -0.00876055,\n",
    "                                -0.016605411,\n",
    "                                -0.033484161,\n",
    "                                0.022085879,\n",
    "                                0.03225413,\n",
    "                                0.011801459,\n",
    "                                0.009225228,\n",
    "```\n",
    "\n",
    "#### Deployment\n",
    "\n",
    "So you test it locally, now just deploy it to Azure Functions by just following these guidelines: https://github.com/Azure-Samples/azure-search-power-skills/blob/main/Vector/EmbeddingGenerator/README.md\n",
    "\n",
    "\n",
    "#### Integration of Azure Function as Custom Skill\n",
    "\n",
    "In order to use this skill in a cognitive search pipeline, you'll need to add a skill definition to your skillset. Here's a sample skill definition for this example (inputs and outputs should be updated to reflect your particular scenario and skillset environment.\n",
    "On your Cognitive Search environment click on SkillSets\n",
    "\n",
    "![image-3.png](attachment:image-3.png)\n",
    "\n",
    "Then Add SkillSet\n",
    "\n",
    "![image-4.png](attachment:image-4.png)\n",
    "\n",
    "Then copy the code below inside the `skill[]` array:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "javascript"
    }
   },
   "outputs": [],
   "source": [
    "{\n",
    "    \"@odata.type\": \"#Microsoft.Skills.Custom.WebApiSkill\",\n",
    "    \"description\": \"Azure Open AI Embeddings Generator\",\n",
    "    \"uri\": \"[AzureFunctionEndpointUrl]/api/chunk-embed?code=[AzureFunctionDefaultHostKey]\",\n",
    "    \"batchSize\": 1,\n",
    "    \"context\": \"/document/content\",\n",
    "    \"inputs\": [\n",
    "        {\n",
    "            \"name\": \"document_id\",\n",
    "            \"source\": \"/document/document_id\"\n",
    "        },\n",
    "        {\n",
    "            \"name\": \"text\",\n",
    "            \"source\": \"/document/content\"\n",
    "        },\n",
    "        {\n",
    "            \"name\": \"filepath\",\n",
    "            \"source\": \"/document/file_path\"\n",
    "        },\n",
    "        {\n",
    "            \"name\": \"fieldname\",\n",
    "            \"source\": \"='content'\"\n",
    "        }\n",
    "    ],\n",
    "    \"outputs\": [\n",
    "        {\n",
    "            \"name\": \"chunks\",\n",
    "            \"targetName\": \"chunks\"\n",
    "        }\n",
    "    ]\n",
    "}\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Be sure to replace the Azure Function URL and the Code (API KEY)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For reference the entire json will look like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "javascript"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "{\n",
    "  \"name\": \"skillset1691474262532\",\n",
    "  \"description\": \"\",\n",
    "  \"skills\": [{\n",
    "    \"@odata.type\": \"#Microsoft.Skills.Custom.WebApiSkill\",\n",
    "    \"description\": \"Azure Open AI Embeddings Generator\",\n",
    "    \"uri\": \"[AzureFunctionEndpointUrl]/api/chunk-embed?code=[AzureFunctionDefaultHostKey]\",\n",
    "    \"batchSize\": 1,\n",
    "    \"context\": \"/document/content\",\n",
    "    \"inputs\": [\n",
    "        {\n",
    "            \"name\": \"document_id\",\n",
    "            \"source\": \"/document/document_id\"\n",
    "        },\n",
    "        {\n",
    "            \"name\": \"text\",\n",
    "            \"source\": \"/document/content\"\n",
    "        },\n",
    "        {\n",
    "            \"name\": \"filepath\",\n",
    "            \"source\": \"/document/file_path\"\n",
    "        },\n",
    "        {\n",
    "            \"name\": \"fieldname\",\n",
    "            \"source\": \"='content'\"\n",
    "        }\n",
    "    ],\n",
    "    \"outputs\": [\n",
    "        {\n",
    "            \"name\": \"chunks\",\n",
    "            \"targetName\": \"chunks\"\n",
    "        }\n",
    "    ]\n",
    "}],\n",
    "  \"cognitiveServices\": {\n",
    "    \"@odata.type\": \"#Microsoft.Azure.Search.DefaultCognitiveServices\"\n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conclusion\n",
    "\n",
    "Congratulations, dear reader, for embarking on this illuminating journey into the realm where data insights seamlessly evolve into dynamic interactions. You've delved into the intricacies of Azure Cognitive Search's custom skills, witnessed the transformative power of the OpenAI Embedding Generator, and mastered the art of crafting a tailored ecosystem that transcends conventional search boundaries.\n",
    "\n",
    "As we reach the conclusion of this chapter, it's only the beginning of what promises to be an exciting saga. The path we've traversed, from understanding the intricacies of custom skills to unlocking the potential of embedding generation, is merely a stepping stone. There's a world of possibilities ahead, waiting to be unveiled in the upcoming second part of this series.\n",
    "\n",
    "In the forthcoming installment, we'll venture even deeper, exploring how these enriched indexes and embeddings fuel the capabilities of advanced Language Models. Imagine conversing with an AI that not only comprehends your queries but comprehends them in the context of your data. Envision a future where interactions with information are as fluid and natural as a conversation with a colleague.\n",
    "\n",
    "Stay tuned as we dive into the heart of Language Models and chatbot integrations. We'll reveal how the bridges we've built between search, embeddings, and AI models transform the way we interact with our data. In the world of tomorrow, knowledge isn't just at your fingertips – it's within your conversational grasp.\n",
    "\n",
    "Thank you for joining us on this path of innovation and exploration. Until the second part unveils its wonders, keep dreaming, keep experimenting, and keep pioneering the future where insights and interactions converge in ways yet unimagined.\n",
    "\n",
    "See you in Part 2!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}