Update screenshots, first cosmos db lab, indexing section

Author: codingbandit

01_Azure_Overview/media/azure-marketplace-search-results.png

@@ -16,8 +16,10 @@ The focus for this developer guide is [Azure Cosmos DB for NoSQL](https://learn.
 
 Azure Cosmos DB offers three capacity modes: provisioned throughput, serverless and autoscale modes. creating an Azure Cosmos DB account, it's essential to evaluate the workload's characteristics in order to choose the appropriate mode to optimize both performance and cost efficiency.
 
+[**Serverless mode**](https://learn.microsoft.com/en-us/azure/cosmos-db/serverless) offers a more flexible and pay-as-you-go approach, where only the Request Units consumed are billed. This is particularly advantageous for applications with sporadic or unpredictable usage patterns, as it eliminates the need to provision resources upfront.
+
 [**Provisioned throughput mode**](https://learn.microsoft.com/azure/cosmos-db/set-throughput) allocates a fixed amount of resources, measured in [Request Units per second (RUs/s)](https://learn.microsoft.com/azure/cosmos-db/request-units), which is ideal for applications with predictable and steady workloads. This ensures consistent performance and can be more cost-effective when there is a constant or high demand for database operations. RU/s can be set at both the database and container levels, allowing for fine-grained control over resource allocation.
 
-[**Serverless mode**](https://learn.microsoft.com/en-us/azure/cosmos-db/serverless) offers a more flexible and pay-as-you-go approach, where only the Request Units consumed are billed. This is particularly advantageous for applications with sporadic or unpredictable usage patterns, as it eliminates the need to provision resources upfront.
+[**Autoscale mode**](https://learn.microsoft.com/azure/cosmos-db/provision-throughput-autoscale) builds upon the provisioned throughput mode but allows for the database or container automatically and instantly scale up or down resources based on demand, ensuring that the application can handle varying workloads efficiently. When configuring autoscale, a maximum (Tmax) value threshold is set for a predictable maximum cost. This mode is suitable for applications with fluctuating usage patterns or infrequently used applications.
 
-[**Autoscale mode**](https://learn.microsoft.com/azure/cosmos-db/provision-throughput-autoscale) builds upon the provisioned throughput mode but allows for the database or container automatically and instantly scales up or down resources based on demand, ensuring that the application can handle varying workloads efficiently. When configuring autoscale, a maximum (Tmax) value threshold is set for a predictable maximum cost. This mode is suitable for applications with fluctuating usage patterns or infrequently used applications.
+[**Dynamic scaling**](https://learn.microsoft.com/en-us/azure/cosmos-db/autoscale-per-partition-region) allows for the automatic and independent scaling of non-uniform workloads across regions and partitions according to usage patterns. For instance, in a disaster recovery configuration with two regions, the primary region may experience high traffic while the secondary region can scale down to idle, thereby saving costs. This approach is also highly effective for multi-regional applications, where traffic patterns fluctuate based on the time of day in each region.

01_Azure_Overview/media/azure-template-json-example.png

@@ -45,37 +45,66 @@ The following concepts are covered in detail in this lab:
 The `azure-cosmos` library is used to create a Cosmos DB API for NoSQL database client. The client enables both DDL (data definition language) and DML (data manipulation language) operations.
 
 ```python
-client = cosmos_client.CosmosClient(HOST, {'masterKey': MASTER_KEY} )
+# Initialize the Cosmos DB client
+client = CosmosClient.from_connection_string(CONNECTION_STRING)
 ```
 
 ### Creating a database
 
 The `create_database` method is used to create a database. If the database already exists, an exception is thrown, therefore verify the database already exists before creating it.
 
 ```python
-client.create_database(id=id)
+db: DatabaseProxy = client.create_database(database_name)
 ```
 
 ### Creating a container
 
-In progress
+The `create_container_if_not_exists` method is used to create a container. If the container already exists, the method will retrieve the existing container.
 
-### Creating a document
+```python
+container: ContainerProxy = db.create_container_if_not_exists(
+           id="product",
+           partition_key={"paths": ["/categoryId"], "kind": "Hash"}                                    
+       )
+```
 
-In progress
+### Creating or Updating a document (Upsert)
 
-### Reading a document
+One method of creating a document is using the `create_item` method. This method takes a single document and inserts it into the database, if the item already exists in the container, and exception is thrown. Alternatively, the `upsert_item` method can also be used to insert a document into the database and in this case, if the document already exists, it will be updated.
+
+```python
+# Create a document
+container.upsert_item(product_dict)
+```
 
-In progress
+### Reading documents
 
-### Updating a document
+The `read_item` method can be used to retrieve a single document if both the `id` value and `partition_key` value are known. Otherwise, the `query_items` method can be used to retrieve a list of documents using a [SQL-like query](https://learn.microsoft.com/azure/cosmos-db/nosql/tutorial-query).
 
-In progress
+```python
+items = container.query_items(query="SELECT * FROM prod", enable_cross_partition_query=True)
+```
 
 ### Deleting a document
 
-In progress
+The `delete_item` method is used to delete a document from the container.
+
+```python
+container.delete_item(item=product.id, partition_key=product.category_id)
+```
+
+## Cosmos DB indexing
+
+Azure Cosmos DB automatically indexes all properties for all items in a container. However, the creation of additional indexes can improve performance and add functionality such as spatial querying and vector search.
+
+The following indexes are supported by Azure Cosmos DB:
+
+The **Range Index** supports efficient execution of queries involving numerical and string data types. It is optimized for inequality comparisons (<, <=, >, >=) and sorting operations. Range indexes are particularly useful for time-series data, financial applications, and any scenario that requires filtering or sorting over a numeric range or alphabetically ordered strings.
+
+The **Spatial Index** excels with geospatial data types such as points, lines, and polygons. Spatial queries include operations such as finding intersections, conducting proximity searches, and handling bounding-box queries. Spatial indexes are crucial for applications that require geographic information system (GIS) capabilities, location-based services, and asset tracking.
+
+The **Composite Index** combines multiple properties into a single entry, optimizing complex queries that use multiple properties for filtering and sorting. They significantly improve the performance of multidimensional queries by reducing the number of request units (RUs) consumed during these operations.
 
-### Querying documents
+The **Vector Index** is specialized for high-dimensional vector data. Use cases include similarity searches, recommendation systems, and any other application requiring efficient handling of high-dimensional vectors. This index type optimizes the storage and retrieval of vectors typically utilized in AI application patterns such as RAG (Retrieval Augmented Generation).
 
-In progress
+Learn more about indexing in the [Azure documentation](https://learn.microsoft.com/azure/cosmos-db/index-overview)

01_Azure_Overview/media/bicep_code.png

@@ -1,3 +1,3 @@
-DB_CONNECTION_STRING="AccountEndpoint=https://<cosmos-account-name>.documents.azure.com:443/;AccountKey=<cosmos-account-key>;"
+COSMOS_DB_CONNECTION_STRING="AccountEndpoint=https://<cosmos-account-name>.documents.azure.com:443/;AccountKey=<cosmos-account-key>;"
 AOAI_ENDPOINT = "https://<resource>.openai.azure.com/"
 AOAI_KEY = "<key>"

01_Azure_Overview/media/terraform_code.png

@@ -15,22 +15,6 @@
     "\n",
     "When integrating Azure OpenAI service in a solution written in Python, the OpenAI Python client library is used. This library is maintained by OpenAI, and is compatible with the Azure OpenAI service.\n",
     "\n",
-    "Install the latest `openai` client library:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "! pip install openai"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
     "When using the OpenAI client library, the Azure OpenAI `key` and `endpoint` for the service are needed. In this case, ensure the Azure OpenAI `key` and `endpoint` is located in a `.env` file in the root of this project, you will need to create this file. The `.env` file should contain the following values (replace the value with your own `key` and `endpoint`):\n",
     "\n",
     "```\n",
@@ -71,14 +55,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
     "chatClient = AzureOpenAI(\n",
     "  azure_endpoint=os.getenv(\"AOAI_ENDPOINT\"), \n",
     "  api_key=os.getenv(\"AOAI_KEY\"),  \n",
-    "  api_version=\"2023-05-15\"\n",
+    "  api_version=\"2024-06-01\"\n",
     ")"
    ]
   },
@@ -139,7 +123,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.3"
+   "version": "3.11.5"
   }
  },
  "nbformat": 4,