more collection to container wording updates

Author: crpietschmann

07_Create_First_Cosmos_DB_Project/README.md

@@ -54,23 +54,23 @@ client = pymongo.MongoClient(CONNECTION_STRING)
 
 When using the `pymongo` client, the creation of a database is automatic when referenced. No specific api calls to create a database are required, if a database already exists, a reference to the database is returned.
 
->**Note:**: That the creation of databases and containers are lazy, meaning they will not be created until a document is inserted into a collection.
+>**Note:**: That the creation of databases and containers are lazy, meaning they will not be created until a document is inserted into a container.
 
 ```python
 db = client.cosmic_works
 ```
 
-### Creating a collection
+### Creating a container
 
-Similar behavior to the creation of a database is experienced when creating a collection. If the collection does not exist, it will be created once a document is inserted into the collection.
+Similar behavior to the creation of a database is experienced when creating a container. If the container does not exist, it will be created once a document is inserted into the container.
 
 ```python
 collection = db.products
 ```
 
 ### Creating a document
 
-The `insert_one` method is used to insert a document into a collection. The document is a dictionary object.
+The `insert_one` method is used to insert a document into a container. The document is a dictionary object.
 
 ```python
 # Insert the JSON into the database, and retrieve the inserted/generated ID
@@ -79,15 +79,15 @@ product_id = collection.insert_one(product_json).inserted_id
 
 ### Reading a document
 
-The `find_one` method is used to retrieve a single document from a collection. The method returns a dictionary object.
+The `find_one` method is used to retrieve a single document from a container. The method returns a dictionary object.
 
 ```python
 retrieved_document = collection.find_one({"_id": product_id})
 ```
 
 ### Updating a document
 
-The `find_one_and_update` method is used to update a single document in a collection. The method returns a dictionary object.
+The `find_one_and_update` method is used to update a single document in a container. The method returns a dictionary object.
 
 ```python
 update_result = collection.find_one_and_update(
@@ -99,15 +99,15 @@ update_result = collection.find_one_and_update(
 
 ### Deleting a document
 
-The `delete_one` method is used to delete a single document from a collection.
+The `delete_one` method is used to delete a single document from a container.
 
 ```python
 delete_result = collection.delete_one({"_id": product_id})
 ```
 
 ### Querying documents
 
-The `find` method is used to query documents from a collection. The method returns a cursor object.
+The `find` method is used to query documents from a container. The method returns a cursor object.
 
 ```python
 # Print all documents that have a category name of "Components, Saddles"

08_Load_Data/README.md

@@ -1,6 +1,6 @@
 # Load data into Azure Cosmos DB API for NoSQL
 
-The previous lab demonstrated how to add data to a collection individually. This lab will demonstrate how to load data using bulk operations into multiple collections. This data will be used in subsequent labs to explain further the capabilities of Azure Cosmos DB API about AI.
+The previous lab demonstrated how to add data to a container individually. This lab will demonstrate how to load data using bulk operations into multiple containers. This data will be used in subsequent labs to explain further the capabilities of Azure Cosmos DB API about AI.
 
 When loading data, bulk operations are preferred over adding each document individually. Bulk operations involve performing multiple database operations as a batch rather than executing them simultaneously. This approach is more efficient and provides several benefits:
 

09_Vector_Search_Cosmos_DB/README.md

@@ -6,7 +6,7 @@
 
 Embedding is a way of serializing the semantic meaning of data into a vector representation. Because the generated vector embedding represents the semantic meaning, it means that when it is searched, it can find similar data based on the semantic meaning of the data rather than exact text. Data can come from many sources, including text, images, audio, and video. Because the data is represented as a vector, vector search can, therefore, find similar data across all different types of data.
 
-Embeddings are created by sending data to an embedding model, where it is transformed into a vector, which then can be stored as a vector field within its source document in Azure Cosmos DB for NoSQL. Azure Cosmos DB for NoSQL supports the creation of vector search indexes on top of these vector fields. A vector search index is a collection of vectors in [latent space](https://idl.cs.washington.edu/papers/latent-space-cartography/) that enables a semantic similarity search across all data (vectors) contained within.
+Embeddings are created by sending data to an embedding model, where it is transformed into a vector, which then can be stored as a vector field within its source document in Azure Cosmos DB for NoSQL. Azure Cosmos DB for NoSQL supports the creation of vector search indexes on top of these vector fields. A vector search index is a container of vectors in [latent space](https://idl.cs.washington.edu/papers/latent-space-cartography/) that enables a semantic similarity search across all data (vectors) contained within.
 
 ![A typical embedding pipeline that demonstrates how source data is transformed into vectors using an embedding model then stored in a document in an Azure Cosmos DB container and exposed via a vector search index.](media/embedding_pipeline.png)
 
@@ -74,12 +74,12 @@ def generate_embeddings(text: str):
 
 ### Adding an embedding field to a document
 
-The lab creates an embedding field named `contentVector` in each collection and populates the value with the vectorized text of the JSON representation of the document.
+The lab creates an embedding field named `contentVector` in each container and populates the value with the vectorized text of the JSON representation of the document.
 
 ```python
 def add_collection_content_vector_field(collection_name: str):
     '''
-    Add a new field to the collection to hold the vectorized content of each document.
+    Add a new field to the container to hold the vectorized content of each document.
     '''
     collection = db[collection_name]
     bulk_operations = []
@@ -131,7 +131,7 @@ db.command({
 ```python
 def vector_search(collection_name, query, num_results=3):
     """
-    Perform a vector search on the specified collection by vectorizing
+    Perform a vector search on the specified container by vectorizing
     the query and searching the vector index for the most similar documents.
 
     returns a list of the top num_results most similar documents

10_LangChain/README.md

@@ -67,7 +67,7 @@ rag_chain = (
 
 ### Creating tools for LangChain agents to use
 
-Tools are selected by the Large Language model at runtime. In this case, depending on the incoming user request the LLM will decide which collection in the database to query. The following code shows how to create a tool for the LLM to use to query the products collection in the database.
+Tools are selected by the Large Language model at runtime. In this case, depending on the incoming user request the LLM will decide which container in the database to query. The following code shows how to create a tool for the LLM to use to query the products collection in the database.
 
 ```python
 # create a chain on the retriever to format the documents as JSON

Labs/lab_1_first_application.ipynb

@@ -53,7 +53,7 @@
    "source": [
     "## Create a container\n",
     "\n",
-    "Creating containers behaves similarly to the database creation. If the collection does not exist, it will be created. It's important to note that databases and containers are lazily created. This means that the database and collection will not be created until the first document is inserted."
+    "Creating containers behaves similarly to the database creation. If the container does not exist, it will be created. It's important to note that databases and containers are lazily created. This means that the database and container will not be created until the first document is inserted."
    ]
   },
   {
@@ -107,7 +107,7 @@
    "source": [
     "## Read a document\n",
     "\n",
-    "The insertion of the Product in the previous cell automatically created the database and collection. The `find_one` method is used to retrieve a single document from the database. The `find_one` method takes a filter as an argument. This filter is used to find the document in the database. In this case, the filter is the unique identifier or `_id` of the document that was just inserted."
+    "The insertion of the Product in the previous cell automatically created the database and container. The `find_one` method is used to retrieve a single document from the database. The `find_one` method takes a filter as an argument. This filter is used to find the document in the database. In this case, the filter is the unique identifier or `_id` of the document that was just inserted."
    ]
   },
   {
@@ -185,7 +185,7 @@
    "source": [
     "## Query for multiple documents\n",
     "\n",
-    "The `find` method is used to query for multiple documents in the database. This method takes a filter as an argument. This filter is used to find the documents to return. In this case, the filter is an empty dictionary. This will return all documents in the collection."
+    "The `find` method is used to query for multiple documents in the database. This method takes a filter as an argument. This filter is used to find the documents to return. In this case, the filter is an empty dictionary. This will return all documents in the container."
    ]
   },
   {
@@ -277,7 +277,7 @@
    "source": [
     "## Clean up resources\n",
     "\n",
-    "The following cell will delete the database and collection created in this lab. This is done by using the `drop_database` method on the database object. This method takes the name of the database to delete as an argument. If it is desired to simply delete the collection, the `drop_collection` method can be used on the database object. This method takes the name of the collection to delete as an argument."
+    "The following cell will delete the database and container created in this lab. This is done by using the `drop_database` method on the database object. This method takes the name of the database to delete as an argument. If it is desired to simply delete the container, the `drop_collection` method can be used on the database object. This method takes the name of the container to delete as an argument."
    ]
   },
   {

Labs/lab_3_mongodb_vector_search.ipynb

@@ -272,7 +272,7 @@
    "source": [
     "## Use vector search in Azure Cosmos DB for NoSQL\n",
     "\n",
-    "Now that each document has its associated vector embedding and the vector indexes have been created on each collection, we can now use the vector search capabilities of Azure Cosmos DB for NoSQL."
+    "Now that each document has its associated vector embedding and the vector indexes have been created on each container, we can now use the vector search capabilities of Azure Cosmos DB for NoSQL."
    ]
   },
   {

Labs/lab_4_langchain.ipynb

@@ -78,7 +78,7 @@
     "\n",
     "In the previous lab, the `pymongo` library was used to perform a vector search through a db command to find product documents that were most similar to the user's input. In this lab, you will use the `langchain` library to perform the same search. LangChain has a vector store class named **AzureCosmosDBVectorSearch**, a community contribution, that supports vector search in Azure Cosmos DB for NoSQL.\n",
     "\n",
-    "When establishing the connection to the vector store (Azure Cosmos DB for NoSQL), recall that in previous labs the products collection was populated and a contentVector field added that contains the vectorized embeddings of the document itself. Finally, a vector index was also created on the contentVector field to enable vector search. The vector index in each collection is named `VectorSearchIndex`.\n",
+    "When establishing the connection to the vector store (Azure Cosmos DB for NoSQL), recall that in previous labs the products container was populated and a contentVector field added that contains the vectorized embeddings of the document itself. Finally, a vector index was also created on the contentVector field to enable vector search. The vector index in each container is named `VectorSearchIndex`.\n",
     "\n",
     "The return value of a vector search in LangChain is a list of `Document` objects. The LangChain `Document` class contains two properties: `page_content`, that represents the textual content that is typically used to augment the prompt, and `metadata` that contains all other attributes of the document. In the cell below, we'll use the `_id` field as the page_content, and the rest of the fields are returned as metadata.\n",
     "\n",

Labs/models/customer.py

@@ -39,7 +39,7 @@ class Config:
 class CustomerList(BaseModel):
     """
     The CustomerList class represents a list of customers.
-    This class is used when deserializing a collection/array
+    This class is used when deserializing a container/array
     of customers.
     """
     items: List[Customer]

Labs/models/sales_order.py

@@ -30,7 +30,7 @@ class SalesOrderList(BaseModel):
     """
     The SalesOrderList class represents a list of sales orders.
 
-    This class is used when deserializing a collection/array
+    This class is used when deserializing a container/array
     of sales orders.
     """
     items: List[SalesOrder]