Compartilhar via

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

  • Artigo
  • 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 Inserções do Azure OpenAI ou 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 de serviço M40 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 Type Descrição
index_name string Nome exclusivo do índice.
path_to_property string 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 devem ser um number[] para serem indexados e retornados nos resultados da busca em 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 string 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é 2.000 dimensões, com suporte futuro planejado para mais de 40.000.
similarity string 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, use a fase do pipeline de agregação $search em uma consulta 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 Type Descrição
lSearch Número inteiro 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 O número de resultados de pesquisa a ser retornado. O valor k deve ser menor ou igual a lSearch.

Habilitando DiskANN em um novo cluster

Para habilitar DiskANN Vector Index em um cluster do Azure Cosmos DB para MongoDB (vCore) recém-provisionado, siga estas etapas para executar um registro no nível do cluster por meio da CLI do Azure:

  1. Entrar na CLI do Azure
az login
  1. Recupere as configurações atuais para os sinalizadores de recursos em seu cluster. Isso garante que você mantenha quaisquer sinalizadores existentes ao adicionar o novo recurso.
az resource show --ids "/subscriptions/<sub id>/resourceGroups/<resource group name>/providers/Microsoft.DocumentDB/mongoClusters/<resource name of your Cosmos DB for MongoDB cluster>" --api-version <cluster's api version>
  1. Adicione o sinalizador DiskANNIndex à lista de recursos de visualização sem remover os existentes.
az resource patch --ids "/subscriptions/<sub id>/resourceGroups/<resource group name>/providers/Microsoft.DocumentDB/mongoClusters/<resource name of your Cosmos DB for MongoDB cluster>" --api-version <cluster's api version> --properties "{\"previewFeatures\": [\"GeoReplicas\", \"DiskANNIndex\"]}"

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 as inserções usando seu próprio modelo, as Inserções do OpenAI do Azure 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 negócios 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'
  }
]

Busca em vetores filtrada (versão prévia)

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. Habilite o recurso "filtragem de busca em vetores" na guia "Versões prévias do recurso" da sua Assinatura do Azure. Saiba mais sobre as versões prévias do recurso aqui.

Primeiro, você precisará definir um índice para o filtro, além de um índice de vetor. Por exemplo, você pode definir o índice de filtro em uma propriedade

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

Em seguida, você pode adicionar o termo "filter" à sua busca em vetores, conforme mostrado abaixo. Neste exemplo, o filtro está procurando documentos em que a propriedade "title" não esteja na lista de ["not in this text", "or this text"].


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

Durante a versão prévia, a busca em vetores filtrada pode exigir um ajuste dos parâmetros de índice de vetor para obter maior precisão. Por exemplo, aumentar m, efConstruction ou efSearch ao usar HNSW, ou numLists, ou nProbes ao usar IVF, pode levar a melhores resultados. Você deve testar sua configuração antes do uso para garantir que os resultados sejam satisfatórios.

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 com suporte: L2 (Euclidiano), produto escalar e cosseno.
  • Métodos de indexação com suporte: IVFFLAT, HNSW e DiskANN (versão prévia)
  • Indexação de vetores de até 2.000 dimensões de tamanho.
  • 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 gratuita com tempo de vida para o Azure Cosmos DB for MongoDB