Compartilhar via

Repositório de vetores no Azure Cosmos DB for MongoDB vCore

  • Aplica-se a: ✅ MongoDB vCore

Use o banco de dados de vetores integrado do Azure Cosmos DB for MongoDB vCore para conectar perfeitamente seus aplicativos baseados em IA aos seus dados que estão armazenados no Azure Cosmos DB. Essa integração pode incluir aplicativos criados usando inserções OpenAI do Azure. O banco de dados de vetores integrado nativamente permite armazenar, indexar e consultar com eficiência dados de vetores de alta dimensão armazenados diretamente no Azure Cosmos DB for MongoDB vCore, juntamente com os dados originais a partir dos quais os dados de vetores são criados. Ele elimina a necessidade de transferir seus dados para repositórios de vetores alternativos e gerar custos adicionais.

O que é um repositório de vetores?

Um repositório de vetores é um banco de dados de vetores projetado para armazenar e gerenciar inserções de vetores, que são representações matemáticas de dados em um espaço altamente dimensional. Nesse espaço, cada dimensão corresponde a um recurso dos dados e dezenas de milhares de dimensões podem ser usadas para representar dados sofisticados. A posição de um vetor nesse espaço representa as características dele. Palavras, frases ou documentos inteiros e imagens, áudio e outros tipos de dados podem ser vetorizados.

Como funciona um repositório de vetores?

Em um repositório de vetores, algoritmos de busca em vetores são usados para indexar e consultar inserções. Alguns algoritmos de busca em vetores conhecidos incluem HNSW (Hierarchical Navigable Small World), IVF (Arquivo Invertido), DiskANN etc. A busca em vetores é um método que ajuda a localizar itens semelhantes com base em suas características de dados, em vez de correspondências exatas em um campo de propriedade. Essa técnica é útil em usos como pesquisa de texto semelhante, localização de imagens relacionadas, recomendações ou até mesmo detecção de anomalias. Ela é usada para consultar as inserções de vetores (listas de números) dos seus dados que você criou usando um modelo de machine learning por meio de uma API de inserções. Exemplos de APIs de inserções são as Inserções do Azure OpenAI ou o Hugging Face no Azure. A busca em vetores mede a distância entre os vetores de dados e o vetor de consulta. Os vetores de dados mais próximos do vetor de consulta são os mais semelhantes semanticamente.

No Banco de Dados de vetores integrado do Azure Cosmos DB for MongoDB vCore, as inserções podem ser armazenadas, indexadas e consultadas junto com os dados originais. Essa abordagem elimina o custo extra de replicação de dados em um banco de dados vetoriais puro separado. Além disso, essa arquitetura mantém as inserções vetoriais e os dados originais juntos, o que facilita melhor as operações de dados multimodais e possibilita maior consistência, escala e desempenho de dados.

O Azure Cosmos DB for MongoDB (vCore) fornece recursos robustos de busca em vetores, permitindo que você execute pesquisas de similaridade de alta velocidade em conjuntos de dados complexos. Para executar a busca em vetores no Azure Cosmos DB for MongoDB, primeiro você precisa criar um índice de vetor. No momento, o Azure Cosmos DB é compatível com três tipos de índices:

  • DiskANN (recomendado): ideal para conjuntos de dados em grande escala, aproveitando SSDs para uso eficiente de memória, mantendo um recall alto em pesquisas aproximadas de vizinhos mais próximos (ANN).
  • HNSW: adequado para conjuntos de dados de tamanho moderado que precisam de recall alto, com uma estrutura baseada em grafo que equilibra a precisão e a eficiência dos recursos.
  • FIV: usa o clustering para otimizar a velocidade de pesquisa em conjuntos de dados expansivos, concentrando pesquisas em clusters direcionados para acelerar o desempenho.

Os índices DiskANN estão disponíveis em camadas M30 e superiores. Para criar o índice DiskANN, defina o parâmetro "kind" como "vector-diskann" seguindo o modelo abaixo:

{ 
    "createIndexes": "<collection_name>",
    "indexes": [
        {
            "name": "<index_name>",
            "key": {
                "<path_to_property>": "cosmosSearch"
            },
            "cosmosSearchOptions": { 
                "kind": "vector-diskann", 
                "dimensions": <integer_value>,
                "similarity": <string_value>,
                "maxDegree" : <integer_value>, 
                "lBuild" : <integer_value>, 
            } 
        } 
    ] 
}
Campo Tipo Descrição
index_name cadeia de caracteres Nome exclusivo do índice.
path_to_property cadeia de caracteres Caminho para a propriedade que contém o vetor. Esse caminho pode ser uma propriedade de nível superior ou um caminho de notação de ponto para a propriedade. Os vetores precisam ser um number[] para serem indexados e utilizados em buscas de vetores. O uso de outro tipo, como double[], impede que o documento seja indexado. Os documentos não indexados não serão retornados no resultado de uma pesquisa de vetor.
kind cadeia de caracteres Tipo de índice de vetor a ser criado. As opções são vector-ivf, vector-hnsw e vector-diskann.
dimensions Número inteiro Número de dimensões para similaridade de vetor. O DiskANN dá suporte a até 16.000 dimensões (com o Product Quantization), com suporte futuro planejado para mais de 40.000.
similarity cadeia de caracteres Métrica de similaridade a ser usada com o índice. As opções possíveis são COS (distância do cosseno), L2 (distância euclidiana) e IP (produto interno).
maxDegree Número inteiro Número máximo de bordas por nó no grafo. Esse parâmetro varia de 20 a 2048 (o padrão é 32). maxDegree superior é adequado para conjuntos de dados com requisitos de alta dimensionalidade e/ou alta precisão.
lBuild Número inteiro Define o número de vizinhos candidatos avaliados durante a construção do índice DiskANN. Esse parâmetro, que varia de 10 a 500 (o padrão é 50), equilibra a precisão e a sobrecarga computacional: valores mais altos melhoram a qualidade e a precisão do índice, mas aumentam o tempo de build

Fazer uma busca em vetores com DiskANN

Para realizar uma busca em vetores, utilize a etapa de agregação do pipeline $search e consulte com o operador cosmosSearch. O DiskANN permite pesquisas de alto desempenho em conjuntos de dados massivos com filtragem opcional, como filtros geoespaciais ou baseados em texto.

{
  "$search": {
    "cosmosSearch": {
      "path": "<path_to_property>",
      "query": "<query_vector>",  
      "k": <num_results_to_return>,  
      "filter": {"$and": [
        { "<attribute_1>": { "$eq": <value> } },
        {"<location_attribute>": {"$geoWithin": {"$centerSphere":[[<longitude_integer_value>, <latitude_integer_value>], <radius>]}}}
      ]}
    }
  }
},
Campo Tipo Descrição
lSearch Número inteiro Especifica o tamanho da lista de candidatos dinâmicos para a busca. O valor padrão é 40, com um intervalo configurável de 10 até 1000. Aumentar o valor aprimora o recall, mas pode reduzir a velocidade de pesquisa.
k Número inteiro Define o número de resultados de pesquisa a ser retornado. O valor k deve ser menor ou igual a lSearch.

Exemplo usando um índice DiskANN com filtragem

Adicionando vetores ao banco de dados

Para usar a busca em vetores com filtros geoespaciais, adicione documentos que incluam inserções de vetor e coordenadas de localização. Você pode criar os embeddings usando seu próprio modelo, Azure OpenAI Embeddings, ou outra API (como Hugging Face no Azure).

from pymongo import MongoClient

client = MongoClient("<your_connection_string>")
db = client["test"]
collection = db["testCollection"]

documents = [
    {"name": "Eugenia Lopez", "bio": "CEO of AdventureWorks", "is_open": 1, "location": [-118.9865, 34.0145], "contentVector": [0.52, 0.20, 0.23]},
    {"name": "Cameron Baker", "bio": "CFO of AdventureWorks", "is_open": 1, "location": [-0.1278, 51.5074], "contentVector": [0.55, 0.89, 0.44]},
    {"name": "Jessie Irwin", "bio": "Director of Our Planet initiative", "is_open": 0, "location": [-118.9865, 33.9855], "contentVector": [0.13, 0.92, 0.85]},
    {"name": "Rory Nguyen", "bio": "President of Our Planet initiative", "is_open": 1, "location": [-119.0000, 33.9855], "contentVector": [0.91, 0.76, 0.83]}
]

collection.insert_many(documents)

Criar um índice de vetor DiskANN

O exemplo a seguir demonstra como configurar um índice de vetor DiskANN com recursos de filtragem. Isso inclui a criação do índice de vetor para pesquisa de similaridade, a adição de documentos com propriedades vetoriais e geoespaciais e a indexação de campos para filtragem adicional.

db.command({
    "createIndexes": "testCollection",
    "indexes": [
        {
            "name": "DiskANNVectorIndex",
            "key": {
                "contentVector": "cosmosSearch"
            },
            "cosmosSearchOptions": {
                "kind": "vector-diskann",
                "dimensions": 3,
                "similarity": "COS",
                "maxDegree": 32,
                "lBuild": 64
            }
        },
        { 
            "name": "is_open",
            "key": { 
                "is_open": 1 
            }      
        },
        {
            "name": "locationIndex",
            "key": {
                "location": 1
            }
        }
    ]
})

Esse comando cria um índice de vetor DiskANN no campo contentVector em exampleCollection, permitindo pesquisas de similaridade. Ele também adiciona:

  • Um índice no campo is_open, permitindo que você filtre os resultados com base em se as empresas estão abertas.
  • Um índice geoespacial no campo location a ser filtrado por proximidade geográfica.

Para localizar documentos com vetores semelhantes em um raio geográfico específico, especifique o queryVector como pesquisa de similaridade e inclua um filtro geoespacial.

query_vector = [0.52, 0.28, 0.12]
pipeline = [
    {
        "$search": {
            "cosmosSearch": {
                "path": "contentVector",
                "vector": query_vector,
                "k": 5,
                "filter": {
                    "$and": [
                        {"is_open": {"$eq": 1}},
                        {"location": {"$geoWithin": {"$centerSphere": [[-119.7192861804, 34.4102485028], 100 / 3963.2]}}}
                    ]
                }
            }
        }
    }
]

results = list(collection.aggregate(pipeline))
for result in results:
    print(result)

Neste exemplo, a pesquisa de similaridade de vetor retorna os k principais vetores mais próximos com base na métrica de similaridade COS especificada, enquanto filtra os resultados para incluir apenas negócios abertos em um raio de 160 km.

[
  {
    similarityScore: 0.9745354109084544,
    document: {
      _id: ObjectId("645acb54413be5502badff94"),
      name: 'Eugenia Lopez',
      bio: 'CEO of AdventureWorks',
      is_open: 1,
      location: [-118.9865, 34.0145],
      contentVector: [0.52, 0.20, 0.23]
    }
  },
  {
    similarityScore: 0.9006955671333992,
    document: {
      _id: ObjectId("645acb54413be5502badff97"),
      name: 'Rory Nguyen',
      bio: 'President of Our Planet initiative',
      is_open: 1,
      location: [-119.7302, 34.4005],
      contentVector: [0.91, 0.76, 0.83]
    }
  }
]

Esse resultado mostra os principais documentos semelhantes a queryVector, restritos a um raio de 160 km e a comércios abertos. Cada resultado inclui a pontuação de similaridade e metadados, demonstrando como o DiskANN no Cosmos DB para MongoDB dá suporte a consultas vetoriais e geoespaciais combinadas para experiências de pesquisa enriquecidas e sensíveis à localização.

Obter definições de índice de vetor

Para recuperar sua definição de índice vetorial da coleção, use o comando listIndexes:

db.exampleCollection.getIndexes();

Nesse exemplo, vectorIndex é retornado com todos os parâmetros cosmosSearch que foram utilizados para criar o índice:

[
  { v: 2, key: { _id: 1 }, name: '_id_', ns: 'test.exampleCollection' },
  {
    v: 2,
    key: { vectorContent: 'cosmosSearch' },
    name: 'vectorSearchIndex',
    cosmosSearch: {
      kind: <index_type>, // options are `vector-ivf`, `vector-hnsw`, and `vector-diskann`
      numLists: 3,
      similarity: 'COS',
      dimensions: 3
    },
    ns: 'test.exampleCollection'
  }
]

Agora é possível executar buscas em vetores com qualquer filtro de consulta com suporte, como $lt, $lte, $eq, $neq, $gte, $gt, $in, $nin e $regex.

Para utilizar a pré-filtragem, primeiro você precisará definir um índice padrão na propriedade pela qual pretende filtrar, além do índice de vetor. Aqui está um exemplo de criação de um índice de filtro:

db.runCommand({
  "createIndexes": "<collection_name>",
  "indexes": [ {
    "key": {
      "<property_to_filter>": 1
    },
    "name": "<name_of_filter_index>"
  }
  ]
});

Depois que o índice de filtro estiver em vigor, você poderá incorporar a "filter" cláusula diretamente na consulta de pesquisa de vetor, conforme demonstrado abaixo. Este exemplo mostra como filtrar resultados em que o "title" valor da propriedade não está presente na lista fornecida:

db.exampleCollection.aggregate([
  {
    '$search': {
      "cosmosSearch": {
        "vector": "<query_vector>",
        "path": <path_to_vector>,
        "k": num_results,
        "filter": {<property_to_filter>: {"$nin": ["not in this text", "or this text"]}}
      },
      "returnStoredSource": True }},
  {'$project': { 'similarityScore': { '$meta': 'searchScore' }, 'document' : '$$ROOT' }
}
]);

Importante

Para otimizar o desempenho e a precisão de suas pesquisas de vetor pré-filtradas, considere ajustar os parâmetros de índice de vetor. Para os índices DiskANN, aumentar maxDegree ou lBuild pode produzir melhores resultados. Para índices HNSW , experimentar valores mais altos para m, efConstructionou efSearch pode melhorar o desempenho. Da mesma forma, para índices IVF, ajustar numLists ou nProbes pode levar a resultados mais satisfatórios. É crucial testar sua configuração específica com seus dados para garantir que os resultados atendam aos seus requisitos. Esses parâmetros influenciam a estrutura de índice e o comportamento de pesquisa e os valores ideais podem variar de acordo com suas características de dados e padrões de consulta.

Usar ferramentas de Orquestração LLM

Usar como um banco de dados de vetor com Kernel Semântico

Use o Kernel Semântico para orquestrar sua recuperação de informações do vCore do Azure Cosmos DB for MongoDB e seu LLM. Saiba mais aqui.

https://github.com/microsoft/semantic-kernel/tree/main/python/semantic_kernel/connectors/memory/azure_cosmosdb

Usar como um banco de dados de vetores com LangChain

Use o LangChain para orquestrar sua recuperação de informações do vCore do Azure Cosmos DB for MongoDB e seu LLM. Saiba mais aqui.

Usar como um cache semântico com LangChain

Use o LangChain e o Azure Cosmos DB for MongoDB (vCore) para orquestrar o Cache Semântico, usando repositórios LLM gravados anteriormente que podem economizar custos da API de LLM e reduzir a latência para respostas. Saiba mais aqui

Recursos e limitações

  • Métricas de distância suportadas: L2 (Euclidiano), produto interno e cosseno.
  • Métodos de indexação com suporte: IVFFLAT, HNSW e DiskANN.
  • Com DiskANN e Product Quantization, você pode indexar vetores até 16.000 dimensões.
  • O uso de HNSW ou FIV com meia precisão permite indexação de vetores de até 4.000 dimensões.
  • Sem compactação, a dimensão de vetor máximo padrão para indexação é de 2.000.
  • A indexação se aplica a apenas um vetor por caminho.
  • Somente um índice pode ser criado por caminho de vetor.

Resumo

Esse guia demonstra como criar um índice vetorial, adicionar documentos que tenham dados vetoriais, realizar uma pesquisa de similaridade e recuperar a definição do índice. Usando o banco de dados de vetores integrado, você pode armazenar, indexar e consultar com eficiência dados vetoriais altamente dimensionais diretamente no Azure Cosmos DB for MongoDB vCore. Ele permite que você aproveite todo o potencial dos seus dados por meio de inserções de vetores e capacita você a criar aplicativos mais precisos, eficientes e sofisticados.

Conteúdo relacionado

Próxima etapa

Criar um cluster do vCore de camada livre vitalício para o Azure Cosmos DB for MongoDB