01-indexing-content.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📚 Prerequisites\n",
    "\n",
    "Before running this notebook, ensure you have configured SharePoint, set up an application for handling Graph API authentication, and set the appropriate configuration parameters. [steps here](README.md)\n",
    "\n",
    "## 📋 Table of Contents\n",
    "\n",
    "This notebook guides you through the following sections:\n",
    "\n",
    "1. [**Create an Azure Cognitive Search Index**](#create-index): This index will store the content from a document hosted on SharePoint Online.\n",
    "\n",
    "2. [**Initialize the `client_extractor` client**](#init-client): This client manages the connection to a SharePoint site through the Microsoft Graph REST API and retrieves the Site ID for the site.\n",
    "\n",
    "3. [**Download and Process Content and Metadata**](#download-process): The `client_extractor` client provides several methods for this:\n",
    "    - Download and process all `.docx` and `.pdf` files from a SharePoint site.\n",
    "    - Download and process only `.docx` files from a specific SharePoint site that were modified or uploaded in the last 60 minutes.\n",
    "    - Download and process files from a specific folder within a SharePoint site.\n",
    "    - Download and process a specific file within a SharePoint site.\n",
    "\n",
    "4. [**Ingest into Azure AI Search Index**](#ingest-index): The extracted content and metadata are ingested into the Azure AI Search Index for easy retrieval and search.\n",
    "\n",
    "For more details, refer to the following resources:\n",
    "- [Quickstart: Register an app with the Azure AD v2.0 endpoint](https://learn.microsoft.com/en-us/azure/active-directory/develop/console-app-quickstart?pivots=devlang-python)\n",
    "- [Create a Demo SharePoint Online Environment](https://cdx.transform.microsoft.com/) (Note: To use this, you need to either be a Microsoft Employee or part of the Microsoft Partner Program: [Microsoft Partner Program](https://partner.microsoft.com/dashboard/account/v3/enrollment/introduction/partnership))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 🚀 Getting Started\n",
    "\n",
    "#### Setting Up Conda Environment and Configuring VSCode for Jupyter Notebooks\n",
    "\n",
    "Follow these steps to create a Conda environment and set up your VSCode for running Jupyter Notebooks:\n",
    "\n",
    "##### Create Conda Environment from the Repository\n",
    "\n",
    "> Instructions for Windows users: \n",
    "\n",
    "1. **Create the Conda Environment**:\n",
    "   - In your terminal or command line, navigate to the repository directory.\n",
    "   - Execute the following command to create the Conda environment using the `environment.yml` file:\n",
    "     ```bash\n",
    "     conda env create -f environment.yml\n",
    "     ```\n",
    "   - This command creates a Conda environment as defined in `environment.yml`.\n",
    "\n",
    "2. **Activating the Environment**:\n",
    "   - After creation, activate the new Conda environment by using:\n",
    "     ```bash\n",
    "     conda activate sharepoint-indexing\n",
    "     ```\n",
    "\n",
    "> Instructions for Linux users (or Windows users with WSL or other linux setup): \n",
    "\n",
    "1. **Use `make` to Create the Conda Environment**:\n",
    "   - In your terminal or command line, navigate to the repository directory and look at the Makefile.\n",
    "   - Execute the `make` command specified below to create the Conda environment using the `environment.yml` file:\n",
    "     ```bash\n",
    "     make create_conda_env\n",
    "     ```\n",
    "\n",
    "2. **Activating the Environment**:\n",
    "   - After creation, activate the new Conda environment by using:\n",
    "     ```bash\n",
    "     conda activate sharepoint-indexing\n",
    "     ```\n",
    "\n",
    "##### Configure VSCode for Jupyter Notebooks\n",
    "\n",
    "1. **Install Required Extensions**:\n",
    "   - Download and install the `Python` and `Jupyter` extensions for VSCode. These extensions provide support for running and editing Jupyter Notebooks within VSCode.\n",
    "\n",
    "2. **Open the Notebook**:\n",
    "   - Open the Jupyter Notebook file (`01-indexing-content.ipynb`) in VSCode.\n",
    "\n",
    "3. **Attach Kernel to VSCode**:\n",
    "   - After creating the Conda environment, it should be available in the kernel selection dropdown. This dropdown is located in the top-right corner of the VSCode interface.\n",
    "   - Select your newly created environment (`sharepoint-indexing`) from the dropdown. This sets it as the kernel for running your Jupyter Notebooks.\n",
    "\n",
    "4. **Run the Notebook**:\n",
    "   - Once the kernel is attached, you can run the notebook by clicking on the \"Run All\" button in the top menu, or by running each cell individually.\n",
    "\n",
    "\n",
    "By following these steps, you'll establish a dedicated Conda environment for your project and configure VSCode to run Jupyter Notebooks efficiently. This environment will include all the necessary dependencies specified in your `environment.yml` file. If you wish to add more packages or change versions, please use `pip install` in a notebook cell or in the terminal after activating the environment, and then restart the kernel. The changes should be automatically applied after the session restarts."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Setting the Target Directory\n",
    "\n",
    "Before executing the notebook, modify `target_directory` to point to the location where you downloaded this code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Directory changed to C:\\Users\\pablosal\\Desktop\\sharepoint-indexing-azure-cognitive-search\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "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",
    "    CorsOptions,\n",
    "    SearchIndex,\n",
    "    ComplexField,\n",
    "    SearchFieldDataType,\n",
    "    SimpleField,\n",
    "    SearchableField,\n",
    ")\n",
    "\n",
    "# Define the target directory (change yours)\n",
    "target_directory = (\n",
    "    r\"C:\\Users\\pablosal\\Desktop\\sharepoint-indexing-azure-cognitive-search\"\n",
    ")\n",
    "\n",
    "# Check if the directory exists\n",
    "if os.path.exists(target_directory):\n",
    "    # Change the current working directory\n",
    "    os.chdir(target_directory)\n",
    "    print(f\"Directory changed to {os.getcwd()}\")\n",
    "else:\n",
    "    print(f\"Directory {target_directory} does not exist.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Configure Environment Variables \n",
    "\n",
    "Before running this notebook, you must configure certain environment variables. We will now use environment variables to store our configuration. This is a more secure practice as it prevents sensitive data from being accidentally committed and pushed to version control systems.\n",
    "\n",
    "Create a `.env` file in your project root (use the provided `.env.sample` as a template) and add the following variables:\n",
    "\n",
    "```env\n",
    "# Azure Active Directory Configuration\n",
    "TENANT_ID='[Your Azure Tenant ID]'\n",
    "CLIENT_ID='[Your Azure Client ID]'\n",
    "CLIENT_SECRET='[Your Azure Client Secret]'\n",
    "\n",
    "# SharePoint Site Configuration\n",
    "SITE_DOMAIN='[Your SharePoint Site Domain]'\n",
    "SITE_NAME='[Your SharePoint Site Name]'\n",
    "\n",
    "# Azure AI Search Service Configuration\n",
    "SEARCH_SERVICE_ENDPOINT='[Your Azure Search Service Endpoint]'\n",
    "SEARCH_INDEX_NAME='[Your Azure Search Index Name]'\n",
    "SEARCH_ADMIN_API_KEY='[Your Azure Search Admin API Key]'\n",
    "```\n",
    "\n",
    "Replace the placeholders (e.g., [Your Azure Tenant ID]) with your actual values.\n",
    "\n",
    "+ `TENANT_ID`, `CLIENT_ID`, and `CLIENT_SECRET` from your register Application. [Detailed steps here](README.md)\n",
    "- `SITE_DOMAIN` and `SITE_NAME` specify the SharePoint site from which data will be extracted.\n",
    "+ `SEARCH_SERVICE_ENDPOINT`, `SEARCH_INDEX_NAME`, and `SEARCH_ADMIN_API_KEY` are used to configure the Azure AI Search service.\n",
    "\n",
    "> 📌 **Note**\n",
    "> Remember not to commit the .env file to your version control system. Add it to your .gitignore file to prevent it from being tracked."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create an Azure Cognitive Search Index <a id='create-index'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dotenv import load_dotenv\n",
    "\n",
    "# Load environment variables from .env file\n",
    "load_dotenv()\n",
    "\n",
    "# Set the service endpoint and API key from the environment\n",
    "# Create an SDK client\n",
    "endpoint = os.environ[\"SEARCH_SERVICE_ENDPOINT\"]\n",
    "search_client = SearchClient(\n",
    "    endpoint=endpoint,\n",
    "    index_name=os.environ[\"SEARCH_INDEX_NAME\"],\n",
    "    credential=AzureKeyCredential(os.environ[\"SEARCH_ADMIN_API_KEY\"]),\n",
    ")\n",
    "\n",
    "admin_client = SearchIndexClient(\n",
    "    endpoint=endpoint,\n",
    "    index_name=os.environ[\"SEARCH_INDEX_NAME\"],\n",
    "    credential=AzureKeyCredential(os.environ[\"SEARCH_ADMIN_API_KEY\"]),\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index langchain-vector-demo-custom Deleted\n"
     ]
    }
   ],
   "source": [
    "# Delete the index if it exists\n",
    "try:\n",
    "    result = admin_client.delete_index(os.environ[\"SEARCH_INDEX_NAME\"])\n",
    "    print(\"Index\", os.environ[\"SEARCH_INDEX_NAME\"], \"Deleted\")\n",
    "except Exception as ex:\n",
    "    print(ex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index langchain-vector-demo-custom created\n"
     ]
    }
   ],
   "source": [
    "# Create the index\n",
    "fields = [\n",
    "    SimpleField(\n",
    "        name=\"id\",\n",
    "        type=SearchFieldDataType.String,\n",
    "        filterable=True,\n",
    "        sortable=True,\n",
    "        key=True,\n",
    "    ),\n",
    "    SearchableField(\n",
    "        name=\"name\", type=SearchFieldDataType.String, filterable=True, sortable=True\n",
    "    ),\n",
    "    SimpleField(\n",
    "        name=\"created_datetime\",\n",
    "        type=SearchFieldDataType.DateTimeOffset,\n",
    "        facetable=True,\n",
    "        filterable=True,\n",
    "        sortable=True,\n",
    "    ),\n",
    "    SearchableField(\n",
    "        name=\"created_by\",\n",
    "        type=SearchFieldDataType.String,\n",
    "        filterable=True,\n",
    "        sortable=True,\n",
    "    ),\n",
    "    SimpleField(\n",
    "        name=\"size\",\n",
    "        type=SearchFieldDataType.Int32,\n",
    "        facetable=True,\n",
    "        filterable=True,\n",
    "        sortable=True,\n",
    "    ),\n",
    "    SimpleField(\n",
    "        name=\"last_modified_datetime\",\n",
    "        type=SearchFieldDataType.DateTimeOffset,\n",
    "        facetable=True,\n",
    "        filterable=True,\n",
    "        sortable=True,\n",
    "    ),\n",
    "    SearchableField(\n",
    "        name=\"last_modified_by\",\n",
    "        type=SearchFieldDataType.String,\n",
    "        filterable=True,\n",
    "        sortable=True,\n",
    "    ),\n",
    "    ComplexField(\n",
    "            name=\"read_access_entity\",\n",
    "            collection=True,\n",
    "            fields=[SimpleField(name=\"list_item\", type=SearchFieldDataType.String, searchable=True)],\n",
    "            searchable=True),\n",
    "    SimpleField(name=\"source\", type=SearchFieldDataType.String),\n",
    "    SearchableField(\n",
    "        name=\"content\", type=SearchFieldDataType.String, analyzer_name=\"en.lucene\"\n",
    "    ),\n",
    "]\n",
    "cors_options = CorsOptions(allowed_origins=[\"*\"], max_age_in_seconds=60)\n",
    "scoring_profiles = []\n",
    "suggester = [{\"name\": \"sg\", \"source_fields\": [\"name\"]}]\n",
    "\n",
    "index = SearchIndex(\n",
    "    name=os.environ[\"SEARCH_INDEX_NAME\"],\n",
    "    fields=fields,\n",
    "    scoring_profiles=scoring_profiles,\n",
    "    suggesters=suggester,\n",
    "    cors_options=cors_options,\n",
    ")\n",
    "\n",
    "try:\n",
    "    result = admin_client.create_index(index)\n",
    "    print(\"Index\", result.name, \"created\")\n",
    "except Exception as ex:\n",
    "    print(ex)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize the `client_extractor` client <a id='init-client'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from gbb_ai.sharepoint_data_extractor import SharePointDataExtractor\n",
    "\n",
    "# Instantiate the SharePointDataExtractor client\n",
    "# The client handles the complexities of interacting with SharePoint's REST API, providing an easy-to-use interface for data extraction.\n",
    "client_scrapping = SharePointDataExtractor()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> 💡 **Note**\n",
    "> The `get_site_id` and `get_drive_id` methods are optional. They are automatically called by the `retrieve_sharepoint_files_content` function. However, they are available for use if further analysis is required."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-12-19 13:21:09,725 - micro - MainProcess - INFO     Successfully loaded environment variables: TENANT_ID, CLIENT_ID, CLIENT_SECRET (sharepoint_data_extractor.py:load_environment_variables_from_env_file:86)\n",
      "2023-12-19 13:21:10,376 - micro - MainProcess - INFO     New access token retrieved. (sharepoint_data_extractor.py:msgraph_auth:118)\n",
      "2023-12-19 13:21:10,377 - micro - MainProcess - INFO     Getting the Site ID... (sharepoint_data_extractor.py:get_site_id:187)\n",
      "2023-12-19 13:21:10,890 - micro - MainProcess - INFO     Site ID retrieved: mngenvmcap747548.sharepoint.com,877fe60f-a62d-4ed1-8eda-af543c437d2c,ac47d8a7-cd54-4344-bd9d-26ada5a075c0 (sharepoint_data_extractor.py:get_site_id:191)\n",
      "2023-12-19 13:21:11,507 - micro - MainProcess - INFO     Successfully retrieved drive ID: b!D-Z_hy2m0U6O2q9UPEN9LKfYR6xUzURDvZ0mraWgdcAot0GWx37EQLiVD3sO7-vm (sharepoint_data_extractor.py:get_drive_id:208)\n"
     ]
    }
   ],
   "source": [
    "# Load environment variables from the .env file\n",
    "client_scrapping.load_environment_variables_from_env_file()\n",
    "\n",
    "# Authenticate with Microsoft Graph API\n",
    "client_scrapping.msgraph_auth()\n",
    "\n",
    "# Get the Site ID for the specified SharePoint site\n",
    "site_id = client_scrapping.get_site_id(\n",
    "    site_domain=os.environ[\"SITE_DOMAIN\"], site_name=os.environ[\"SITE_NAME\"]\n",
    ")\n",
    "\n",
    "# Get the Drive ID associated with the Site ID\n",
    "drive_id = client_scrapping.get_drive_id(site_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Download and Process Content and Metadata <a id='download-process'></a>\n",
    "\n",
    "> 💡 **Note**\n",
    "> The method returns a list of dictionaries, with each dictionary representing a file and containing all SharePoint content and metadata. \n",
    "> Here's an example of the expected output:\n",
    "\n",
    "```python\n",
    "[\n",
    "    {\n",
    "        'content': 'LLM creators should exclude from their training data papers on creating or enhancing pathogens....',  # content\n",
    "        'id': '01W3WT6PG5HFCYLSOAMNGIGWEBISZCI5X4',  # The unique identifier of the file\n",
    "        'source': 'https://XXX.sharepoint.com/sites/XXX/_layouts/15/Doc.aspx?sourcedoc=%7B854539DD-C0C9-4C63-8358-8144B22476FC%7D&file=test3.docx&action=default&mobileredirect=true',  # The source URL of the file\n",
    "        'name': 'test3.docx',  # The name of the file\n",
    "        'size': 73576,  # The size of the file in bytes\n",
    "        'created_by': 'System Administrator',  # The user who created the file\n",
    "        'created_datetime': '2023-12-15T00:44:01Z',  # The date and time when the file was created\n",
    "        'last_modified_datetime': '2023-12-15T00:44:15Z',  # The date and time when the file was last modified\n",
    "        'last_modified_by': 'System Administrator',  # The user who last modified the file\n",
    "        'read_access_entity': 'Contoso Visitors'  # The entity that has read access to the file\n",
    "    },\n",
    "    # ... more files ...\n",
    "]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-12-19 13:21:11,537 - micro - MainProcess - INFO     Getting the Site ID... (sharepoint_data_extractor.py:get_site_id:187)\n",
      "2023-12-19 13:21:12,189 - micro - MainProcess - INFO     Site ID retrieved: mngenvmcap747548.sharepoint.com,877fe60f-a62d-4ed1-8eda-af543c437d2c,ac47d8a7-cd54-4344-bd9d-26ada5a075c0 (sharepoint_data_extractor.py:get_site_id:191)\n",
      "2023-12-19 13:21:12,849 - micro - MainProcess - INFO     Successfully retrieved drive ID: b!D-Z_hy2m0U6O2q9UPEN9LKfYR6xUzURDvZ0mraWgdcAot0GWx37EQLiVD3sO7-vm (sharepoint_data_extractor.py:get_drive_id:208)\n",
      "2023-12-19 13:21:12,851 - micro - MainProcess - INFO     Making request to Microsoft Graph API (sharepoint_data_extractor.py:get_files_in_site:247)\n",
      "2023-12-19 13:21:13,394 - micro - MainProcess - INFO     Received response from Microsoft Graph API (sharepoint_data_extractor.py:get_files_in_site:250)\n"
     ]
    }
   ],
   "source": [
    "# Download and process all `.docx` and `.pdf` files from a specific Site ID.\n",
    "files_from_root_folder = client_scrapping.retrieve_sharepoint_files_content(\n",
    "    site_domain=os.environ[\"SITE_DOMAIN\"],\n",
    "    site_name=os.environ[\"SITE_NAME\"],\n",
    "    file_formats=[\"docx\", \"pdf\"],\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-12-19 13:21:16,391 - micro - MainProcess - INFO     Getting the Site ID... (sharepoint_data_extractor.py:get_site_id:187)\n",
      "2023-12-19 13:21:16,905 - micro - MainProcess - INFO     Site ID retrieved: mngenvmcap747548.sharepoint.com,877fe60f-a62d-4ed1-8eda-af543c437d2c,ac47d8a7-cd54-4344-bd9d-26ada5a075c0 (sharepoint_data_extractor.py:get_site_id:191)\n",
      "2023-12-19 13:21:17,495 - micro - MainProcess - INFO     Successfully retrieved drive ID: b!D-Z_hy2m0U6O2q9UPEN9LKfYR6xUzURDvZ0mraWgdcAot0GWx37EQLiVD3sO7-vm (sharepoint_data_extractor.py:get_drive_id:208)\n",
      "2023-12-19 13:21:17,495 - micro - MainProcess - INFO     Making request to Microsoft Graph API (sharepoint_data_extractor.py:get_files_in_site:247)\n",
      "2023-12-19 13:21:18,041 - micro - MainProcess - INFO     Received response from Microsoft Graph API (sharepoint_data_extractor.py:get_files_in_site:250)\n",
      "2023-12-19 13:21:18,041 - micro - MainProcess - ERROR    No files found in the site's drive (sharepoint_data_extractor.py:retrieve_sharepoint_files_content:536)\n"
     ]
    }
   ],
   "source": [
    "# Download and process only `.docx` files from a specific SharePoint Site modified or uploaded in last 60 min.\n",
    "files_from_root_folder_last_60_min = client_scrapping.retrieve_sharepoint_files_content(\n",
    "    site_domain=os.environ[\"SITE_DOMAIN\"],\n",
    "    site_name=os.environ[\"SITE_NAME\"],\n",
    "    file_formats=[\"docx\"],\n",
    "    minutes_ago=60,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-12-19 13:21:18,073 - micro - MainProcess - INFO     Getting the Site ID... (sharepoint_data_extractor.py:get_site_id:187)\n",
      "2023-12-19 13:21:18,602 - micro - MainProcess - INFO     Site ID retrieved: mngenvmcap747548.sharepoint.com,877fe60f-a62d-4ed1-8eda-af543c437d2c,ac47d8a7-cd54-4344-bd9d-26ada5a075c0 (sharepoint_data_extractor.py:get_site_id:191)\n",
      "2023-12-19 13:21:19,191 - micro - MainProcess - INFO     Successfully retrieved drive ID: b!D-Z_hy2m0U6O2q9UPEN9LKfYR6xUzURDvZ0mraWgdcAot0GWx37EQLiVD3sO7-vm (sharepoint_data_extractor.py:get_drive_id:208)\n",
      "2023-12-19 13:21:19,191 - micro - MainProcess - INFO     Making request to Microsoft Graph API (sharepoint_data_extractor.py:get_files_in_site:247)\n",
      "2023-12-19 13:21:19,872 - micro - MainProcess - INFO     Received response from Microsoft Graph API (sharepoint_data_extractor.py:get_files_in_site:250)\n",
      "2023-12-19 13:21:32,808 - micro - MainProcess - INFO     Text extraction from PDF bytes was successful. (pdf_utils.py:extract_text_from_pdf_bytes:28)\n"
     ]
    }
   ],
   "source": [
    "# Download and process files from a specific folder within a SharePoint site.\n",
    "selected_files_content = client_scrapping.retrieve_sharepoint_files_content(\n",
    "    site_domain=os.environ[\"SITE_DOMAIN\"],\n",
    "    site_name=os.environ[\"SITE_NAME\"],\n",
    "    folder_path=\"/test/test2/test3/\",\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-12-19 13:21:33,557 - micro - MainProcess - INFO     Getting the Site ID... (sharepoint_data_extractor.py:get_site_id:187)\n",
      "2023-12-19 13:21:34,055 - micro - MainProcess - INFO     Site ID retrieved: mngenvmcap747548.sharepoint.com,877fe60f-a62d-4ed1-8eda-af543c437d2c,ac47d8a7-cd54-4344-bd9d-26ada5a075c0 (sharepoint_data_extractor.py:get_site_id:191)\n",
      "2023-12-19 13:21:34,705 - micro - MainProcess - INFO     Successfully retrieved drive ID: b!D-Z_hy2m0U6O2q9UPEN9LKfYR6xUzURDvZ0mraWgdcAot0GWx37EQLiVD3sO7-vm (sharepoint_data_extractor.py:get_drive_id:208)\n",
      "2023-12-19 13:21:34,705 - micro - MainProcess - INFO     Making request to Microsoft Graph API (sharepoint_data_extractor.py:get_files_in_site:247)\n",
      "2023-12-19 13:21:35,275 - micro - MainProcess - INFO     Received response from Microsoft Graph API (sharepoint_data_extractor.py:get_files_in_site:250)\n"
     ]
    }
   ],
   "source": [
    "# Download and process a specific file within a SharePoint site.\n",
    "selected_file_content = client_scrapping.retrieve_sharepoint_files_content(\n",
    "    site_domain=os.environ[\"SITE_DOMAIN\"],\n",
    "    site_name=os.environ[\"SITE_NAME\"],\n",
    "    folder_path=\"/test/test2/test3/\",\n",
    "    file_names=[\"test3.docx\"],\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'content': 'A large language model (LLM) is a type of language model notable for its ability to achieve general-purpose language understanding and generation. LLMs acquire these abilities by using massive amounts of data to learn billions of parameters during training and consuming large computational resources during their training and operation.[1] LLMs are artificial neural networks (mainly transformers[2]) and are (pre-)trained using self-supervised learning and semi-supervised learning.\\nAs autoregressive language models, they work by taking an input text and repeatedly predicting the next token or word.[3] Up to 2020, fine tuning was the only way a model could be adapted to be able to accomplish specific tasks. Larger sized models, such as GPT-3, however, can be prompt-engineered to achieve similar results.[4] They are thought to acquire knowledge about syntax, semantics and \"ontology\" inherent in human language corpora, but also inaccuracies and biases present in the corpora.[5]\\nNotable examples include OpenAI\\'s GPT models (e.g., GPT-3.5 and GPT-4, used in ChatGPT), Google\\'s PaLM (used in Bard), and Meta\\'s LLaMa, as well as BLOOM, Ernie 3.0 Titan, and Anthropic\\'s Claude 2.\\nDataset preprocessing[edit]\\nSee also: List of datasets for machine-learning research § Internet\\nProbabilistic tokenization[edit]\\nUsing a modification of byte-pair encoding, in the first step, all unique characters (including blanks and punctuation marks) are treated as an initial set of n-grams (i.e. initial set of uni-grams). Successively the most frequent pair of adjacent characters is merged into a bi-gram and all instances of the pair are replaced by it. All occurrences of adjacent pairs of (previously merged) n-grams that most frequently occur together are then again merged into even lengthier n-gram repeatedly until a vocabulary of prescribed size is obtained (in case of GPT-3, the size is 50257).[6] Token vocabulary consists of integers, spanning from zero up to the size of the token vocabulary. New words can always be interpreted as combinations of the tokens and the initial-set uni-grams.[7]\\nA token vocabulary based on the frequencies extracted from mainly English corpora uses as few tokens as possible for an average English word. An average word in another language encoded by such an English-optimized tokenizer is however split into suboptimal amount of tokens.\\ntokenizer: texts -> series of numerical \"tokens\" may be split into:\\nProbabilistic tokenization also compresses the datasets, which is the reason for using the byte pair encoding algorithm as a tokenizer. Because LLMs generally require input to be an array that is not jagged, the shorter texts must be \"padded\" until they match the length of the longest one. How many tokens are, on average, needed per word depends on the language of the dataset.[8][9]\\nDataset cleaning[edit]\\nRemoval of toxic passages from the dataset, discarding low-quality data, and de-duplication are examples of dataset cleaning.[10] Resulting, cleaned (high-quality) datasets contain up to 17 trillion words in 2022, raising from 985 million words, used in 2018 for GPT-1,[11] and 3.3 billion words, used for BERT.[12] The future data is, however, expected to be increasingly \"contaminated\" by LLM-generated contents themselves.[13]\\nTraining and architecture details[edit]\\nSee also: Fine-tuning (machine learning)\\nReinforcement learning from human feedback (RLHF)[edit]\\nReinforcement learning from human feedback (RLHF) through algorithms, such as proximal policy optimization, is used to further fine-tune a model based on a dataset of human preferences.[14]\\nInstruction tuning[edit]\\nUsing \"self-instruct\" approaches, LLMs have been able to bootstrap correct responses, replacing any naive responses, starting from human-generated corrections of a few cases. For example, in the instruction \"Write an essay about the main themes represented in Hamlet,\" an initial naive completion might be \\'If you submit the essay after March 17, your grade will be reduced by 10% for each day of delay,\" based on the frequency of this textual sequence in the corpus.[15]\\nMixture of experts[edit]\\nMain article: Mixture of experts\\nThe largest LLM may be too expensive to train and use directly. For such models, mixture of experts (MoE) can be applied, a line of research pursued by Google researchers since 2017 to train models reaching up to 1 billion parameters.[16][17][18]\\nPrompt engineering, attention mechanism, and context window[edit]\\nSee also: Prompt engineering and Attention (machine learning)\\nMost results previously achievable only by (costly) fine-tuning, can be achieved through prompt engineering, although limited to the scope of a single conversation (more precisely, limited to the scope of a context window).[19]\\n\\nTraining cost[edit]\\nAdvances in software and hardware have reduced the cost substantially since 2020, such that in 2023 training of a 12-billion-parameter LLM computational cost is 72,300 A100-GPU-hours, while in 2020 the cost of training a 1.5-billion-parameter LLM (which was two orders of magnitude smaller than the state of the art in 2020) was between $80 thousand and $1.6 million.[24][25][26] Since 2020, large sums were invested in increasingly large models. For example, training of the GPT-2 (i.e. a 1.5-billion-parameters model) in 2019 cost $50,000, while training of the PaLM (i.e. a 540-billion-parameters model) in 2022 cost $8 million.[27]\\nFor Transformer-based LLM, training cost is much higher than inference cost. It costs 6 FLOPs per parameter to train on one token, whereas it costs 1 to 2 FLOPs per parameter to infer on one token.[28]\\nTool use[edit]\\nThere are certain tasks that, in principle, cannot be solved by any LLM, at least not without the use of external tools or additional software. An example of such a task is responding to the user\\'s input \\'354 * 139 = \\', provided that the LLM has not already encountered a continuation of this calculation in its training corpus. In such cases, the LLM needs to resort to running program code that calculates the result, which can then be included in its response. Another example is \\'What is the time now? It is \\', where a separate program interpreter would need to execute a code to get system time on the computer, so LLM could include it in its reply.[29][30] This basic strategy can be sophisticated with multiple attempts of generated programs, and other sampling strategies.[31]\\nGenerally, in order to get an LLM to use tools, one must finetune it for tool-use. If the number of tools is finite, then finetuning may be done just once. If the number of tools can grow arbitrarily, as with online API services, then the LLM can be finetuned to be able to read API documentation and call API correctly.[32][33]\\nA simpler form of tool use is Retrieval Augmented Generation: augment an LLM with document retrieval, sometimes using a vector database. Given a query, a document retriever is called to retrieve the most relevant (usually measured by first encoding the query and the documents into vectors, then finding the documents with vectors closest in Euclidean norm to the query vector). The LLM then generates an output based on both the query and the retrieved documents.[34]\\nAgency[edit]\\nAn LLM is a language model, which is not an agent as it has no goal, but it can be used as a component of an intelligent agent.[35] Researchers have described several methods for such integrations.\\nThe ReAct (\"Reason+Act\") method constructs an agent out of an LLM, using the LLM as a planner. The LLM is prompted to \"think out loud\". Specifically, the language model is prompted with a textual description of the environment, a goal, a list of possible actions, and a record of the actions and observations so far. It generates one or more thoughts before generating an action, which is then executed in the environment.[36] The linguistic description of the environment given to the LLM planner can even be the LaTeX code of a paper describing the environment.[37]\\nIn the DEPS (\"Describe, Explain, Plan and Select\") method, an LLM is first connected to the visual world via image descriptions, then it is prompted to produce plans for complex tasks and behaviors based on its pretrained knowledge and environmental feedback it receives.[38]\\nThe Reflexion method[39] constructs an agent that learns over multiple episodes. At the end of each episode, the LLM is given the record of the episode, and prompted to think up \"lessons learned\", which would help it perform better at a subsequent episode. These \"lessons learned\" are given to the agent in the subsequent episodes.\\nMonte Carlo tree search can use an LLM as rollout heuristic. When a programmatic world model is not available, an LLM can also be prompted with a description of the environment to act as world model.[40]\\nFor open-ended exploration, an LLM can be used to score observations for their \"interestingness\", which can be used as a reward signal to guide a normal (non-LLM) reinforcement learning agent.[41] Alternatively, it can propose increasingly difficult tasks for curriculum learning.[42] Instead of outputting individual actions, an LLM planner can also construct \"skills\", or functions for complex action sequences. The skills can be stored and later invoked, allowing increasing levels of abstraction in planning.[42]\\nLLM-powered agents can keep a long-term memory of its previous contexts, and the memory can be retrieved in the same way as Retrieval Augmented Generation. Multiple such agents can interact socially.[43]\\nCompression[edit]\\nTypically, LLM are trained with full- or half-precision floating point numbers (float32 and float16). One float16 has 16 bits, or 2 bytes, and so one billion parameters require 2 gigabytes. The largest models typically have 100 billion parameters, requiring 200 gigabytes to load, which places them outside the range of most consumer electronics.\\nPost-training quantization[44] aims to decrease the space requirement by lowering precision of the parameters of a trained model, while preserving most of its performance.[45][46] The simplest form of quantization simply truncates all numbers to a given number of bits. It can be improved by using a different quantization codebook per layer. Further improvement can be done by applying different precisions to different parameters, with higher precision for particularly important parameters (\"outlier weights\").[47]\\nWhile quantized models are typically frozen, and only pre-quantized models are finetuned, quantized models can still be finetuned.[48]\\nMultimodality[edit]\\nMultimodality means \"having several modalities\", and a \"modality\" means a type of input, such as video, image, audio, text, proprioception, etc.[49] There have been many AI models trained specifically to ingest one modality and output another modality, such as AlexNet for image to label,[50] visual question answering for image-text to text,[51] and speech recognition for speech to text. A review article of multimodal LLM is.[52]\\nA common method to create multimodal models out of an LLM is to \"tokenize\" the output of a trained encoder. Concretely, one can construct a LLM that can understand images as follows: take a trained LLM, and take a trained image encoder �. Make a small multilayered perceptron �, so that for any image �, the post-processed vector �(�(�)) has the same dimensions as an encoded token. That is an \"image token\". Then, one can interleave text tokens and image tokens. The compound model is then finetuned on an image-text dataset. This basic construction can be applied with more sophistication to improve the model. The image encoder may be frozen to improve stability.[53]\\nFlamingo demonstrated the effectiveness of the tokenization method, finetuning a pair of pretrained language model and image encoder to perform better on visual question answering than models trained from scratch.[54] Google PaLM model was finetuned into a multimodal model PaLM-E using the tokenization method, and applied to robotic control.[55] LLaMA models have also been turned multimodal using the tokenization method, to allow image inputs,[56] and video inputs.[57]\\nGPT-4 can use both text and image as inputs[58] (although the vision component wasn\\'t released to the public until GPT-4V[59]), while Google Gemini is expected to be multimodal.[60]\\nProperties[edit]\\nScaling laws and emergent abilities[edit]\\nMain article: Neural scaling law\\nThe following four hyper-parameters characterize a LLM:\\ncost of (pre-)training (�),\\nsize of the artificial neural network itself, such as number of parameters � (i.e. amount of neurons in its layers, amount of weights between them and biases),\\nsize of its (pre-)training dataset (i.e. number of tokens in corpus, �),\\nperformance after (pre-)training.\\nThey are related by simple statistical laws, called \"scaling laws\". One particular scaling law (\"Chinchilla scaling\") for LLM autoregressively trained for one epoch, with a log-log learning rate schedule, states that:[61]\\n{�=�0���=���+���+�0\\n\\nwhere the variables are\\n� is the cost of training the model, in FLOPs.\\n� is the number of parameters in the model.\\n� is the number of tokens in the training set.\\n� is the average negative log-likelihood loss per token (nats/token), achieved by the trained LLM on the test dataset.\\nand the statistical hyper-parameters are\\n�0=6, meaning that it costs 6 FLOPs per parameter to train on one token. Note that training cost is much higher than inference cost, where it costs 1 to 2 FLOPs per parameter to infer on one token.[28]\\n�=0.34,�=0.28,�=406.4,�=410.7,�0=1.69\\nAt point(s) referred to as breaks,[62] the lines change their slopes, appearing on a log-log plot as a series of linear segments connected by arcs.\\nWhen one subtracts out from the y-axis the best performance that can be achieved even with infinite scaling of the x-axis quantity, large models\\' performance, measured on various tasks, seems to be a linear extrapolation of other (smaller-sized and medium-sized) models\\' performance on a log-log plot. However, sometimes the line\\'s slope transitions from one slope to another at point(s) referred to as break(s)[62] in downstream scaling laws, appearing as a series of linear segments connected by arcs; it seems that larger models acquire \"emergent abilities\" at this point(s).[19][63] These abilities are discovered rather than programmed-in or designed, in some cases only after the LLM has been publicly deployed.[3]\\nThe most intriguing among emergent abilities is in-context learning from example demonstrations.[64] In-context learning is involved in tasks, such as:\\nreported arithmetics, decoding the International Phonetic Alphabet, unscrambling a word\\'s letters, disambiguate word in context,[19][65][66] converting spatial words, cardinal directions (for example, replying \"northeast\" upon [0, 0, 1; 0, 0, 0; 0, 0, 0]), color terms represented in text.[67]\\nchain-of-thought prompting: Model outputs are improved by chain-of-thought prompting only when model size exceeds 62B. Smaller models perform better when prompted to answer immediately, without chain of thought.[68]\\nidentifying offensive content in paragraphs of Hinglish (a combination of Hindi and English), and generating a similar English equivalent of Kiswahili proverbs.[69]\\nSchaeffer et. al. argue that the emergent abilities are not unpredictably acquired, but predictably acquired according to a smooth scaling law. The authors considered a toy statistical model of an LLM solving multiple-choice questions, and showed that this statistical model, modified to account for other types of tasks, applies to these tasks as well.[70]\\nLet � be the number of parameter count, and � be the performance of the model.\\nWhen �=average ��(correct token), then (log\\u2061�,�) is an exponential curve (before it hits the plateau at one), which looks like emergence.\\nWhen �=average log\\u2061(��(correct token)), then the (log\\u2061�,�) plot is a straight line (before it hits the plateau at zero), which does not look like emergence.\\nWhen �=average ��(the most likely token is correct), then (log\\u2061�,�) is a step-function, which looks like emergence.\\nInterpretation[edit]\\nLarge language models by themselves are \"black boxes\", and it is not clear how they can perform linguistic tasks. There are several methods for understanding how LLM work.\\nMechanistic interpretability aims to reverse-engineer LLM by discovering symbolic algorithms that approximate the inference performed by LLM. One example is Othello-GPT, where a small Transformer is trained to predict legal Othello moves. It is found that there is a linear representation of Othello board, and modifying the representation changes the predicted legal Othello moves in the correct way.[71][72] In another example, a small Transformer is trained on Karel programs. Similar to the Othello-GPT example, there is a linear representation of Karel program semantics, and modifying the representation changes output in the correct way. The model also generates correct programs that are on average shorter than those in the training set.[73]\\nIn another example, the authors trained small transformers on modular arithmetic addition. The resulting models were reverse-engineered, and it turned out they used discrete Fourier transform.[74]\\nUnderstanding and intelligence[edit]\\nNLP researchers were evenly split when asked, in a 2022 survey, whether (untuned) LLMs \"could (ever) understand natural language in some nontrivial sense\".[75] Proponents of \"LLM understanding\" believe that some LLM abilities, such as mathematical reasoning, imply an ability to \"understand\" certain concepts. A Microsoft team argued in 2023 that GPT-4 \"can solve novel and difficult tasks that span mathematics, coding, vision, medicine, law, psychology and more\" and that GPT-4 \"could reasonably be viewed as an early (yet still incomplete) version of an artificial general intelligence system\": \"Can one reasonably say that a system that passes exams for software engineering candidates is not really intelligent?\"[76][77] Some researchers characterize LLMs as \"alien intelligence\".[78][79] For example, Conjecture CEO Connor Leahy considers untuned LLMs to be like inscrutable alien \"Shoggoths\", and believes that RLHF tuning creates a \"smiling facade\" obscuring the inner workings of the LLM: \"If you don\\'t push it too far, the smiley face stays on. But then you give it [an unexpected] prompt, and suddenly you see this massive underbelly of insanity, of weird thought processes and clearly non-human understanding.\"[80][81]\\nIn contrast, some proponents of the \"LLMs lack understanding\" school believe that existing LLMs are \"simply remixing and recombining existing writing\",[79] or point to the deficits existing LLMs continue to have in prediction skills, reasoning skills, agency, and explainability.[75] For example, GPT-4 has natural deficits in planning and in real-time learning.[77] Generative LLMs have been observed to confidently assert claims of fact which do not seem to be justified by their training data, a phenomenon which has been termed \"hallucination\".[82] Specifically, hallucinations in the context of LLMs correspond to the generation of text or responses that seem syntactically sound, fluent, and natural but are factually incorrect, nonsensical, or unfaithful to the provided source input.[83] Neuroscientist Terrence Sejnowski has argued that \"The diverging opinions of experts on the intelligence of LLMs suggests that our old ideas based on natural intelligence are inadequate\".[75]\\nThe matter of LLM\\'s exhibiting intelligence or understanding [75] has foundations in the study of language as a model of Cognition in the field of Cognitive linguistics. The American Linguist George Lakoff presented Neural Theory of Language (NTL) as a computational basis for using language as a model of learning tasks and understanding.[84] In his 2014 book titled The Language Myth: Why Language Is Not An Instinct, British cognitive linguist and digital communication technologist Vyvyan Evans maps out the role of probabilistic context-free grammar (PCFG) in enabling NLP to model cognitive patterns.\\nEvaluation[edit]\\nPerplexity[edit]\\nThe most commonly used measure of a language model\\'s performance is its perplexity on a given text corpus. Perplexity is a measure of how well a model is able to predict the contents of a dataset; the higher the likelihood the model assigns to the dataset, the lower the perplexity. Mathematically, perplexity is defined as the exponential of the average negative log likelihood per token:\\nlog\\u2061(Perplexity)=−1�∑�=1�log\\u2061(��(token�|context for token�))\\n\\nhere � is the number of tokens in the text corpus, and \"context for token �\" depends on the specific type of LLM used. If the LLM is autoregressive, then \"context for token �\" is the segment of text appearing before token �. If the LLM is masked, then \"context for token �\" is the segment of text surrounding token �.\\nBecause language models may overfit to their training data, models are usually evaluated by their perplexity on a test set of unseen data.[12] This presents particular challenges for the evaluation of large language models. As they are trained on increasingly large corpora of text largely scraped from the web, it becomes increasingly likely that models\\' training data inadvertently includes portions of any given test set.[4]\\nTask-specific datasets and benchmarks[edit]\\nA large number of testing datasets and benchmarks have also been developed to evaluate the capabilities of language models on more specific downstream tasks. Tests may be designed to evaluate a variety of capabilities, including general knowledge, commonsense reasoning, and mathematical problem-solving.\\nOne broad category of evaluation dataset is question answering datasets, consisting of pairs of questions and correct answers, for example, (\"Have the San Jose Sharks won the Stanley Cup?\", \"No\").[85] A question answering task is considered \"open book\" if the model\\'s prompt includes text from which the expected answer can be derived (for example, the previous question could be adjoined with some text which includes the sentence \"The Sharks have advanced to the Stanley Cup finals once, losing to the Pittsburgh Penguins in 2016.\"[85]). Otherwise, the task is considered \"closed book\", and the model must draw on knowledge retained during training.[86] Some examples of commonly used question answering datasets include TruthfulQA, Web Questions, TriviaQA, and SQuAD.[86]\\nEvaluation datasets may also take the form of text completion, having the model select the most likely word or sentence to complete a prompt, for example: \"Alice was friends with Bob. Alice went to visit her friend, ____\".[4]\\nSome composite benchmarks have also been developed which combine a diversity of different evaluation datasets and tasks. Examples include GLUE, SuperGLUE, MMLU, BIG-bench, and HELM.[87][86]\\nIt was previously standard to report results on a heldout portion of an evaluation dataset after doing supervised fine-tuning on the remainder. It is now more common to evaluate a pre-trained model directly through prompting techniques, though researchers vary in the details of how they formulate prompts for particular tasks, particularly with respect to how many examples of solved tasks are adjoined to the prompt (i.e. the value of n in n-shot prompting).\\nAdversarially constructed evaluations[edit]\\nBecause of the rapid pace of improvement of large language models, evaluation benchmarks have suffered from short lifespans, with state of the art models quickly \"saturating\" existing benchmarks, exceeding the performance of human annotators, leading to efforts to replace or augment the benchmark with more challenging tasks.[88] In addition, there are cases of \"shortcut learning\" wherein AIs sometimes \"cheat\" on multiple-choice tests by using statistical correlations in superficial test question wording in order to guess the correct responses, without necessarily understanding the actual question being asked.[75]\\nSome datasets have been constructed adversarially, focusing on particular problems on which extant language models seem to have unusually poor performance compared to humans. One example is the TruthfulQA dataset, a question answering dataset consisting of 817 questions which language models are susceptible to answering incorrectly by mimicking falsehoods to which they were repeatedly exposed during training. For example, an LLM may answer \"No\" to the question \"Can you teach an old dog new tricks?\" because of its exposure to the English idiom you can\\'t teach an old dog new tricks, even though this is not literally true.[89]\\nAnother example of an adversarial evaluation dataset is Swag and its successor, HellaSwag, collections of problems in which one of multiple options must be selected to complete a text passage. The incorrect completions were generated by sampling from a language model and filtering with a set of classifiers. The resulting problems are trivial for humans but at the time the datasets were created state of the art language models had poor accuracy on them. For example:\\nWe see a fitness center sign. We then see a man talking to the camera and sitting and laying on a exercise ball. The man...\\na) demonstrates how to increase efficient exercise work by running up and down balls.\\nb) moves all his arms and legs and builds up a lot of muscle.\\nc) then plays the ball and we see a graphics and hedge trimming demonstration.\\nd) performs sit ups while on the ball and talking.[90]\\nBERT selects b) as the most likely completion, though the correct answer is d).[90]\\nWider impact[edit]\\nIn 2023, Nature Biomedical Engineering wrote that \"it is no longer possible to accurately distinguish\" human-written text from text created by large language models, and that \"It is all but certain that general-purpose large language models will rapidly proliferate... It is a rather safe bet that they will change many industries over time.\"[91] Goldman Sachs suggested in 2023 that generative language AI could increase global GDP by 7% in the next ten years, and could expose to automation 300 million jobs globally.[92][93] Some commenters expressed concern over accidental or deliberate creation of misinformation, or other forms of misuse.[94] For example, the availability of large language models could reduce the skill-level required to commit bioterrorism; biosecurity researcher Kevin Esvelt has suggested that LLM creators should exclude from their training data papers on creating or enhancing pathogens.[95]\\n',\n",
       "  'id': '01W3WT6PG5HFCYLSOAMNGIGWEBISZCI5X4',\n",
       "  'source': 'https://mngenvmcap747548.sharepoint.com/sites/Contoso/_layouts/15/Doc.aspx?sourcedoc=%7B854539DD-C0C9-4C63-8358-8144B22476FC%7D&file=test3.docx&action=default&mobileredirect=true',\n",
       "  'name': 'test3.docx',\n",
       "  'size': 73576,\n",
       "  'created_by': 'System Administrator',\n",
       "  'created_datetime': '2023-12-15T00:44:01Z',\n",
       "  'last_modified_datetime': '2023-12-15T00:44:15Z',\n",
       "  'last_modified_by': 'System Administrator',\n",
       "  'read_access_entity': ['Contoso Visitors']}]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "selected_file_content"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ingest into Azure AI Search Index <a id='ingest-index'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> 💡 **Note**\n",
    "> The `upload_documents` method is part of the Azure Cognitive Search SDK for Python. It's used to upload a batch of documents to an Azure AI Search index.\n",
    ">\n",
    "> This method accepts a list of documents, where each document is a dictionary that represents a JSON document. Each key-value pair in the dictionary corresponds to a field in the index schema."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Upload of new document succeeded: True\n"
     ]
    }
   ],
   "source": [
    "# Single Document Upload\n",
    "try:\n",
    "    # 'search_client.upload_documents' expects a list of documents\n",
    "    result = search_client.upload_documents(documents=selected_file_content)\n",
    "\n",
    "    # Print the result for each document\n",
    "    for res in result:\n",
    "        print(\"Upload of new document succeeded: {}\".format(res.succeeded))\n",
    "except Exception as ex:\n",
    "    print(\"Error in single document upload: \", ex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Upload of new document succeeded: True\n",
      "Upload of new document succeeded: True\n"
     ]
    }
   ],
   "source": [
    "# Multiple Documents Upload\n",
    "try:\n",
    "    # 'search_client.upload_documents' can ingest multiple documents at once\n",
    "    # 'selected_files_content' is a list of documents\n",
    "    result = search_client.upload_documents(documents=selected_files_content)\n",
    "\n",
    "    # Print the result for each document\n",
    "    for res in result:\n",
    "        print(\"Upload of new document succeeded: {}\".format(res.succeeded))\n",
    "except Exception as ex:\n",
    "    print(\"Error in multiple documents upload: \", ex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ID: 01W3WT6PG5HFCYLSOAMNGIGWEBISZCI5X4, Name: test3.docx\n",
      "Content: A large language model (LLM) is a type of language model notable for its ability to achieve general-\n"
     ]
    }
   ],
   "source": [
    "# Use the Azure Cognitive Search SDK to perform a search on the index\n",
    "# The search_text parameter is set to \"LLMs are the best\"\n",
    "results = search_client.search(search_text=\"LLMs are the best\")\n",
    "\n",
    "# Iterate through the search results\n",
    "for result in results:\n",
    "    # Print the ID and name of each result\n",
    "    print(f\"ID: {result['id']}, Name: {result['name']}\")\n",
    "\n",
    "    # Print the first 100 characters of the content of each result\n",
    "    print(f\"Content: {result['content'][:100]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**🎉 Hooray!** \n",
    "\n",
    "Success! \n",
    "\n",
    "In this example, we've fetched a document named `test3.docx` from SharePoint and ingested it into Azure Search. This process demonstrates the seamless integration of SharePoint and Azure Search for document indexing and retrieval. \n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "sharepoint-indexing",
   "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.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}