Problems with the method AzureCosmosDBVectorSearch.Search()

[santiagovasquez1]

Checked other resources

• I added a very descriptive title to this question.
• I searched the LangChain documentation with the integrated search.
• I used the GitHub search to find a similar question and didn't find it.

Commit to Help

• I commit to help with one of those options 👆

Example Code

def set_retriever(
        self, index_name, connection_string, db_name, collection_name, embedding
    ):
        vector_connection = AzureCosmosDBVectorSearch.from_connection_string(
            connection_string=connection_string,
            namespace=f"{db_name}.{collection_name}",
            embedding=embedding,
            index_name=index_name,
            text_key="problema_solucion",
            embedding_key="vector_content",
        )

retriever_documents = self.set_retriever(
            connection_string=self.connection_string,
            collection_name=self.container_name,
            embedding=self.embeddings,
            index_name=self.index_name,
            db_name=database_name,
        )

      try:
                prueba = retriever_documents.search(
                    query=message, search_type="similarity"
                )
                print(prueba)
            except Exception as e:
                print(e)

Description

I am trying to get indexed documents in a mongodb database through AzureCosmosDBVectorSearch, as you can see in the code, when I run it I get the following error, "metadata", which is not very clear, the configuration of the index of the collection in which the documents are in is the following:

{
    '_id_': {
        'v': 2,
        'key': [('_id', 1)]
    },
    'vector_index': {
        'v': 2,
        'key': [('vector_content', 'cosmosSearch')],
        'cosmosSearchOptions': SON([
            ('kind', 'vector-ivf'),
            ('numLists', 5),
            ('similarity', 'COS'),
            ('dimensions', 1536)
        ])
    }
}

and the structure of the elements is as follows.

{
"_id": "string",
"id": "string",
"nombre_proyecto": "DGP",
"tipo_proyecto": "comercial",
"descripcion_proyecto": "Es un sistema enfocado en calcular la demanda y la generación real hor...",
"experto": "JEAN PIERRE LEYTON OJEDA",
"problema_descripcion": "¿Para qué sirve el aplicativo? Descripción general de su funcionamiento…",
"problema_solucion": "Revisar el siguiente video en nuestra plataforma de aprendizaje MVM Ac...",
"problema_tipo": "Pregunta",
"scriptLinks": [],
"imagesLinks": [""],
"videoLinks": [""],
"fecha_publicacion": "2024-01-31T12:07:18.292094+00:00",
"fecha_actualizacion": "2024-01-31T12:07:18.292094+00:00",
"vector_content": [......],
"correo_experto": "string"
}

how is the correct way to map the vector content and the key when using AzureCosmosDBVectorSearch

### System Info

langchain==0.2.15
langchain-community==0.2.15
langchain-core==0.2.37
langchain-openai==0.1.23
langchain-text-splitters==0.2.2

[dosubot[bot]]

I found a similar solved discussion that might help you with your issue. The discussion addresses a similar problem with the AzureCosmosDBVectorSearch method and provides a solution for mapping the vector content and the key correctly.

Solution

The correct way to map the vector content and the key when using AzureCosmosDBVectorSearch is to use the from_documents or from_texts methods. These methods take the documents or texts, embeddings, and other necessary parameters to create the vector store.

Here is how it is done:

Using from_documents:

vectorstore = AzureCosmosDBVectorSearch.from_documents(
    docs,
    openai_embeddings,
    collection=collection,
    index_name=INDEX_NAME,
)

Using from_texts:

vectorstore = AzureCosmosDBVectorSearch.from_texts(
    texts,
    openai_embeddings,
    metadatas=metadatas,
    collection=collection,
    index_name=INDEX_NAME,
)

In both cases, the collection and index_name parameters are provided to configure the Cosmos DB collection and index. After creating the vector store, you can create an index and perform similarity searches as shown in the test cases:

Creating an Index:

vectorstore.create_index(
    num_lists, dimensions, similarity_algorithm, kind, m, ef_construction
)

Performing a Similarity Search:

query = "What did the president say about Ketanji Brown Jackson"
docs = vectorstore.similarity_search(query)

Additionally, when using AzureCosmosDBNoSqlVectorSearch, the vector content and key are mapped as follows:

Adding Texts:

def add_texts(
    self,
    texts: Iterable[str],
    metadatas: Optional[List[dict]] = None,
    **kwargs: Any,
) -> List[str]:
    _metadatas = list(metadatas if metadatas is not None else ({} for _ in texts))
    return self._insert_texts(list(texts), _metadatas)

Inserting Texts:

def _insert_texts(
    self, texts: List[str], metadatas: List[Dict[str, Any]]
) -> List[str]:
    embeddings = self._embedding.embed_documents(texts)
    text_key = "text"

    to_insert = [
        {
            "id": str(uuid.uuid4()),
            text_key: t,
            self._embedding_key: embedding,
            "metadata": m,
        }
        for t, m, embedding in zip(texts, metadatas, embeddings)
    ]
    doc_ids: List[str] = []
    for item in to_insert:
        created_doc = self._container.create_item(item)
        doc_ids.append(created_doc["id"])
    return doc_ids

In this implementation, the text_key is mapped to the text content, and self._embedding_key is mapped to the embedding vector. The metadata is also included in the document structure ^[1][2][3][4].

This should help you correctly map the vector content and the key when using AzureCosmosDBVectorSearch.

To continue talking to Dosu, mention @dosu.

[santiagovasquez1]

@dosu

but how can you work with elements already indexed in the database, which did not use the structure given by the framework?

[dosubot[bot]]

To work with elements already indexed in the database that did not use the structure given by the framework when using AzureCosmosDBVectorSearch, you can use the from_connection_string method. This method allows you to connect to an existing collection and perform operations on it.

Here is an example of how you can use the from_connection_string method:

from langchain_community.vectorstores import AzureCosmosDBVectorSearch
from langchain_community.embeddings.openai import OpenAIEmbeddings

# Assuming connection_string and namespace are already defined
vectorstore = AzureCosmosDBVectorSearch.from_connection_string(
    connection_string="<YOUR-CONNECTION-STRING>",
    namespace="<db_name>.<collection_name>",
    embedding=OpenAIEmbeddings()
)

# Now you can perform similarity search on the existing data
output = vectorstore.similarity_search("Dogs", k=2)
print(output)

This code snippet demonstrates how to connect to an existing collection and perform a similarity search on the data already indexed in the database.

Additionally, you can create an index and run queries against it using the following approach:

from pymongo import MongoClient
from langchain_community.vectorstores.azure_cosmos_db import (
    AzureCosmosDBVectorSearch,
    CosmosDBSimilarityType,
    CosmosDBVectorSearchType,
)
from langchain_community.embeddings.openai import OpenAIEmbeddings

# Set up the connection and collection
client = MongoClient("<YOUR-CONNECTION-STRING>")
collection = client["<db_name>"]["<collection_name>"]

# Set up OpenAI embeddings
openai_embeddings = OpenAIEmbeddings(
    deployment="smart-agent-embedding-ada",
    model="text-embedding-ada-002",
    chunk_size=1
)

# Create the vector store
vectorstore = AzureCosmosDBVectorSearch(
    collection=collection,
    embedding=openai_embeddings,
    index_name="your_index_name"
)

# Define index parameters
num_lists = 100
dimensions = 1536
similarity_algorithm = CosmosDBSimilarityType.COS
kind = CosmosDBVectorSearchType.VECTOR_IVF
m = 16
ef_construction = 64
ef_search = 40
score_threshold = 0.1

# Create the index
vectorstore.create_index(
    num_lists, dimensions, similarity_algorithm, kind, m, ef_construction
)

# Perform a similarity search
query = "What did the president say about Ketanji Brown Jackson"
docs = vectorstore.similarity_search(query)
print(docs[0].page_content)

This example shows how to set up the connection, create an index, and perform a similarity search on the existing data in the collection ^[1][2][3].

To continue talking to Dosu, mention @dosu.

[santiagovasquez1]

@dofu
and how define the custom text_key?

[dosubot[bot]]

To define a custom text_key when using AzureCosmosDBVectorSearch, you need to modify the _insert_texts method where the text_key is set. Here is the relevant part of the code with the text_key set to a custom value:

def _insert_texts(
    self, texts: List[str], metadatas: List[Dict[str, Any]], text_key: str = "textContent"
) -> List[str]:
    """Used to Load Documents into the collection

    Args:
        texts: The list of documents strings to load
        metadatas: The list of metadata objects associated with each document
        text_key: The key under which the text will be stored in the document

    Returns:
        List of ids from adding the texts into the vectorstore.
    """
    # If the texts is empty, throw an error
    if not texts:
        raise Exception("Texts can not be null or empty")

    # Embed and create the documents
    embeddings = self._embedding.embed_documents(texts)

    to_insert = [
        {
            "id": str(uuid.uuid4()),
            text_key: t,
            self._embedding_key: embedding,
            "metadata": m,
        }
        for t, m, embedding in zip(texts, metadatas, embeddings)
    ]
    # insert the documents in CosmosDB No Sql
    doc_ids: List[str] = []
    for item in to_insert:
        created_doc = self._collection.insert_one(item)
        doc_ids.append(created_doc.inserted_id)
    return doc_ids

You can then call _insert_texts with your custom text_key:

custom_text_key = "custom_text"
vectorstore._insert_texts(list_of_texts, list_of_metadatas, text_key=custom_text_key)

This will store the texts under the specified custom_text_key in the documents ^[1][2].

To continue talking to Dosu, mention @dosu.