Stockage vectoriel dans Azure Cosmos DB for MongoDB sur vCore

S’APPLIQUE À : MongoDB vCore

Utilisez la Base de données Vectorielle Intégrée dans Azure Cosmos DB for MongoDB vCore pour connecter de manière fluide vos applications basées sur l’IA à vos données stockées dans Azure Cosmos DB. Cette intégration peut inclure des applications que vous avez créées à l’aide des incorporations Azure OpenAI. La base de données vectorielle intégrée en mode natif vous permet de stocker, d’indexer et d’interroger efficacement les données vectorielles à haute dimension stockées directement dans Azure Cosmos DB for MongoDB vCore, ainsi que les données d’origine depuis lesquelles les données vectorielles sont créées. Elle élimine la nécessité de transférer vos données vers d’autres magasin de vecteurs et de subir des coûts supplémentaires.

Qu'est-ce qu'un stockage vectoriel ?

Un stockage vectoriel ou une base de données vectorielle est une base de données conçue pour stocker et gérer des incorporations vectorielles, qui sont des représentations mathématiques de données dans un espace de grande dimension. Dans cet espace, chaque dimension correspond à une caractéristique des données, et des dizaines de milliers de dimensions peuvent être utilisées pour représenter des données sophistiquées. La position d’un vecteur dans cet espace représente ses caractéristiques. Les mots, expressions ou documents entiers, ainsi que les images, l’audio et d’autres types de données peuvent tous être vectorisés.

Comment fonctionne un magasin de vecteurs ?

Dans un magasin de vecteurs, des algorithmes de recherche vectorielle sont utilisés pour indexer et interroger les incorporations. Parmi les algorithmes de recherche vectorielle connus figurent entre autres HNSW (Hierarchical Navigable Small World), IVF (Inverted File), DiskANN. La recherche vectorielle est une méthode qui vous aide à trouver des éléments similaires en fonction de leurs caractéristiques de données, plutôt que des correspondances exactes sur un champ de propriété. Cette technique est utile dans des applications comme la recherche de texte similaire, la recherche d’images associées, la création de recommandations ou même la détection d’anomalies. Elle est utilisée pour interroger les incorporations vectorielles (listes de nombres) des données que vous avez créées en utilisant un modèle Machine Learning à l’aide d’une API d’incorporation. Des exemples d’API d’incorporation sont Incorporations Azure OpenAI et Hugging Face sur Azure. La recherche vectorielle mesure la distance entre les vecteurs de données et votre vecteur de requête. Les vecteurs de données les plus proches de votre vecteur de requête sont ceux qui se révèlent les plus similaires sémantiquement.

Dans la Base de données Vectorielle Intégrée dans Azure Cosmos DB for MongoDB vCore, les incorporations peuvent être stockées, indexées et interrogées en même temps que les données d’origine. Cette approche élimine le coût supplémentaire dû à la réplication des données dans une base de données vectorielle pure distincte. De plus, cette architecture conserve les incorporations vectorielles et les données d’origine ensemble, ce qui facilite les opérations de données multimodales et permet d’accroître la cohérence, la mise à l’échelle et le niveau de performance des données.

Créer un index vectoriel

Pour effectuer une recherche de similarité vectorielle sur les propriétés vectorielles dans vos documents, vous devez d’abord créer un index vectoriel.

Créer un index vectoriel à l’aide de HNSW

Vous pouvez créer des index (Hierarchical Navigable Small World) sur les niveaux de cluster M40 et versions ultérieures. Pour créer l’index HSNW, vous devez créer un index vectoriel avec le paramètre "kind" défini sur "vector-hnsw" suivant le modèle ci-dessous :

{ 
    "createIndexes": "<collection_name>",
    "indexes": [
        {
            "name": "<index_name>",
            "key": {
                "<path_to_property>": "cosmosSearch"
            },
            "cosmosSearchOptions": { 
                "kind": "vector-hnsw", 
                "m": <integer_value>, 
                "efConstruction": <integer_value>, 
                "similarity": "<string_value>", 
                "dimensions": <integer_value> 
            } 
        } 
    ] 
}

Effectuer une recherche vectorielle avec HNSW

Pour effectuer une recherche vectorielle, utilisez l’étape de pipeline d’agrégation $search de la requête avec l’opérateur cosmosSearch.

{
    "$search": {
        "cosmosSearch": {
            "vector": <query_vector>,
            "path": "<path_to_property>",
            "k": <num_results_to_return>,
            "efSearch": <integer_value>
        },
    }
  }
}

Créer un index vectoriel à l’aide d’IVF

Pour créer un index vectoriel à l’aide de l’algorithme IVF (Fichier inversé), utilisez le modèle de createIndexes suivant et définissez le paramètre "kind" sur "vector-ivf":

{
  "createIndexes": "<collection_name>",
  "indexes": [
    {
      "name": "<index_name>",
      "key": {
        "<path_to_property>": "cosmosSearch"
      },
      "cosmosSearchOptions": {
        "kind": "vector-ivf",
        "numLists": <integer_value>,
        "similarity": "<string_value>",
        "dimensions": <integer_value>
      }
    }
  ]
}

Effectuer une recherche vectorielle avec IVF

Pour effectuer une recherche vectorielle, utilisez l’étape de $search pipeline d’agrégation dans une requête MongoDB. Pour utiliser l’index cosmosSearch, utilisez le nouvel opérateur cosmosSearch.

{
  {
  "$search": {
    "cosmosSearch": {
        "vector": <query_vector>,
        "path": "<path_to_property>",
        "k": <num_results_to_return>,
      },
      "returnStoredSource": True }},
  {
    "$project": { "<custom_name_for_similarity_score>": {
           "$meta": "searchScore" },
            "document" : "$$ROOT"
        }
  }
}

Pour récupérer le score de similarité (searchScore) avec les documents trouvés par la recherche vectorielle, utilisez l’opérateur $project pour inclure searchScore et le renommer comme <custom_name_for_similarity_score> dans les résultats. Ensuite, le document est également projeté en tant qu’objet imbriqué. Notez que le score de similarité est calculé à l’aide de la métrique définie dans l’index vectoriel.

Exemple utilisant un index HNSW.

Les exemples suivants montrent comment indexer des vecteurs, ajouter des documents possédant des propriétés vectorielles, effectuer une recherche vectorielle et récupérer la configuration de l’index.

use test;

db.createCollection("exampleCollection");

db.runCommand({ 
    "createIndexes": "exampleCollection",
    "indexes": [
        {
            "name": "VectorSearchIndex",
            "key": {
                "contentVector": "cosmosSearch"
            },
            "cosmosSearchOptions": { 
                "kind": "vector-hnsw", 
                "m": 16, 
                "efConstruction": 64, 
                "similarity": "COS", 
                "dimensions": 3
            } 
        } 
    ] 
});

Cette commande crée un index HNSW sur la propriété contentVector dans les documents stockés dans la collection spécifiée, exampleCollection. La propriété cosmosSearchOptions spécifie les paramètres de l’index vectoriel HNSW. Si votre document contient le vecteur stocké dans une propriété imbriquée, vous pouvez définir cette propriété en utilisant un chemin d’accès en notation par points. Par exemple, vous pouvez utiliser text.contentVector si contentVector est une sous-propriété de text.

Ajoutez des vecteurs à votre base de données

Pour ajouter des vecteurs à la collection de votre base de données, vous devez d’abord créer les incorporations en utilisant votre propre modèle, Incorporations Azure OpenAI ou une autre API (comme Hugging Face sur Azure). Dans cet exemple, de nouveaux documents sont ajoutés grâce à l’incorporation d’échantillons :

db.exampleCollection.insertMany([
  {name: "Eugenia Lopez", bio: "Eugenia is the CEO of AdvenureWorks.", vectorContent: [0.51, 0.12, 0.23]},
  {name: "Cameron Baker", bio: "Cameron Baker CFO of AdvenureWorks.", vectorContent: [0.55, 0.89, 0.44]},
  {name: "Jessie Irwin", bio: "Jessie Irwin is the former CEO of AdventureWorks and now the director of the Our Planet initiative.", vectorContent: [0.13, 0.92, 0.85]},
  {name: "Rory Nguyen", bio: "Rory Nguyen is the founder of AdventureWorks and the president of the Our Planet initiative.", vectorContent: [0.91, 0.76, 0.83]},
]);

Effectuez une recherche vectorielle

En poursuivant l’exemple précédent, créez un autre vecteur, queryVector. La recherche vectorielle mesure la distance entre queryVector et les vecteurs dans le chemin contentVector de vos documents. Vous pouvez définir le nombre de résultats que la recherche renvoie en définissant le paramètre k, qui est défini sur 2 ici. Vous pouvez également définir efSearch, qui est un entier qui contrôle la taille de la liste vectorielle candidate. Une valeur plus élevée peut améliorer l’exactitude, mais la recherche sera en conséquence plus lente. Il s’agit d’un paramètre facultatif dont la valeur par défaut est 40.

const queryVector = [0.52, 0.28, 0.12];
db.exampleCollection.aggregate([
  {
    "$search": {
        "cosmosSearch": {
            "vector": "queryVector",
            "path": "contentVector",
            "k": 2,
            "efSearch": 40
        },
    }
  }
}
]);

Dans cet exemple, une recherche vectorielle est effectuée en utilisant queryVector comme entrée via l’interpréteur de commandes Mongo. Le résultat de la recherche est une liste des deux éléments qui sont les plus similaires au vecteur de la requête, triés en fonction de leur score de similarité.

[
  {
    similarityScore: 0.9465376,
    document: {
      _id: ObjectId("645acb54413be5502badff94"),
      name: 'Eugenia Lopez',
      bio: 'Eugenia is the CEO of AdvenureWorks.',
      vectorContent: [ 0.51, 0.12, 0.23 ]
    }
  },
  {
    similarityScore: 0.9006955,
    document: {
      _id: ObjectId("645acb54413be5502badff97"),
      name: 'Rory Nguyen',
      bio: 'Rory Nguyen is the founder of AdventureWorks and the president of the Our Planet initiative.',
      vectorContent: [ 0.91, 0.76, 0.83 ]
    }
  }
]

Obtenir des définitions d’index vectoriel

Pour récupérer votre définition d’index vectoriel à partir de la collection, utilisez la commande listIndexes :

db.exampleCollection.getIndexes();

Dans cet exemple, vectorIndex est renvoyé avec tous les paramètres cosmosSearch qui ont été utilisés pour créer l’index :

[
  { v: 2, key: { _id: 1 }, name: '_id_', ns: 'test.exampleCollection' },
  {
    v: 2,
    key: { contentVector: 'cosmosSearch' },
    name: 'vectorSearchIndex',
    cosmosSearch: {
      kind: 'vector-hnsw',
      m: 40,
      efConstruction: 64,
      similarity: 'COS',
      dimensions: 3
    },
    ns: 'test.exampleCollection'
  }
]

Exemple utilisant un index IVF

L’indexation de fichiers inversés (IVF) est une méthode qui organise les vecteurs en clusters. Lors d’une recherche vectorielle, le vecteur de requête est d’abord comparé aux centres de ces clusters. La recherche est ensuite effectuée dans le cluster dont le centre est le plus proche du vecteur de requête.

Le paramètre numLists détermine le nombre de clusters à créer. Un cluster unique implique que la recherche est effectuée sur tous les vecteurs de la base de données, comme une recherche par force brute ou kNN. Ce paramètre fournit la précision la plus élevée, mais également la latence la plus élevée.

L’augmentation de la valeur numLists entraîne davantage de clusters, chacun contenant moins de vecteurs. Par exemple, si numLists=2, chaque cluster contient plus de vecteurs que si numLists=3, etc. Un nombre moindre de vecteurs par cluster accélère la recherche (latence inférieure, requêtes plus élevées par seconde). Toutefois, cela augmente la probabilité de manquer le vecteur de votre base de données le plus similaire au vecteur de requête. Cela est dû à la nature imparfaite du clustering, où la recherche peut se concentrer sur un cluster alors que le vecteur réel le plus « proche » réside dans un autre cluster.

Le paramètre nProbes contrôle le nombre de clusters à rechercher. Par défaut, il est défini sur 1, ce qui signifie qu’il recherche uniquement le cluster dont le centre est le plus proche du vecteur de requête. L’augmentation de cette valeur permet à la recherche de couvrir davantage de clusters, d’améliorer la précision, mais également d’augmenter la latence (ce qui diminue les requêtes par seconde), car davantage de clusters et de vecteurs sont recherchés.

Les exemples suivants montrent comment indexer des vecteurs, ajouter des documents possédant des propriétés vectorielles, effectuer une recherche vectorielle et récupérer la configuration de l’index.

Créer un index vectoriel

use test;

db.createCollection("exampleCollection");

db.runCommand({
  createIndexes: 'exampleCollection',
  indexes: [
    {
      name: 'vectorSearchIndex',
      key: {
        "vectorContent": "cosmosSearch"
      },
      cosmosSearchOptions: {
        kind: 'vector-ivf',
        numLists: 3,
        similarity: 'COS',
        dimensions: 3
      }
    }
  ]
});

Cette commande crée un index vector-ivf sur la propriété vectorContent dans les documents qui sont stockés dans la collection spécifiée, exampleCollection. La propriété cosmosSearchOptions spécifie les paramètres de l’index vectoriel IVF. Si votre document contient le vecteur stocké dans une propriété imbriquée, vous pouvez définir cette propriété en utilisant un chemin d’accès en notation par points. Par exemple, vous pouvez utiliser text.vectorContent si vectorContent est une sous-propriété de text.

Ajoutez des vecteurs à votre base de données

Pour ajouter des vecteurs à la collection de votre base de données, vous devez d’abord créer les incorporations en utilisant votre propre modèle, Incorporations Azure OpenAI ou une autre API (comme Hugging Face sur Azure). Dans cet exemple, de nouveaux documents sont ajoutés grâce à l’incorporation d’échantillons :

db.exampleCollection.insertMany([
  {name: "Eugenia Lopez", bio: "Eugenia is the CEO of AdvenureWorks.", vectorContent: [0.51, 0.12, 0.23]},
  {name: "Cameron Baker", bio: "Cameron Baker CFO of AdvenureWorks.", vectorContent: [0.55, 0.89, 0.44]},
  {name: "Jessie Irwin", bio: "Jessie Irwin is the former CEO of AdventureWorks and now the director of the Our Planet initiative.", vectorContent: [0.13, 0.92, 0.85]},
  {name: "Rory Nguyen", bio: "Rory Nguyen is the founder of AdventureWorks and the president of the Our Planet initiative.", vectorContent: [0.91, 0.76, 0.83]},
]);

Effectuez une recherche vectorielle

Pour effectuer une recherche vectorielle, utilisez l’étape de $search pipeline d’agrégation dans une requête MongoDB. Pour utiliser l’index cosmosSearch, utilisez le nouvel opérateur cosmosSearch.

{
  {
  "$search": {
    "cosmosSearch": {
        "vector": <vector_to_search>,
        "path": "<path_to_property>",
        "k": <num_results_to_return>,
      },
      "returnStoredSource": True }},
  {
    "$project": { "<custom_name_for_similarity_score>": {
           "$meta": "searchScore" },
            "document" : "$$ROOT"
        }
  }
}

Pour récupérer le score de similarité (searchScore) avec les documents trouvés par la recherche vectorielle, utilisez l’opérateur $project pour inclure searchScore et le renommer comme <custom_name_for_similarity_score> dans les résultats. Ensuite, le document est également projeté en tant qu’objet imbriqué. Notez que le score de similarité est calculé à l’aide de la métrique définie dans l’index vectoriel.

Interroger les vecteurs et distances vectorielles (ou scores de similarité) à l’aide de $search"

En poursuivant l’exemple précédent, créez un autre vecteur, queryVector. La recherche vectorielle mesure la distance entre queryVector et les vecteurs dans le chemin vectorContent de vos documents. Vous pouvez définir le nombre de résultats que la recherche renvoie en définissant le paramètre k, qui est défini sur 2 ici. Vous pouvez également définir nProbes, qui est un entier contrôlant le nombre de clusters proches inspectés dans chaque recherche. Une valeur plus élevée peut améliorer l’exactitude, mais la recherche sera en conséquence plus lente. Il s’agit d’un paramètre facultatif avec une valeur par défaut de 1 et qui ne peut pas être supérieur à la valeur numLists spécifiée dans l’index vectoriel.

const queryVector = [0.52, 0.28, 0.12];
db.exampleCollection.aggregate([
  {
    $search: {
      "cosmosSearch": {
        "vector": queryVector,
        "path": "vectorContent",
        "k": 2
      },
    "returnStoredSource": true }},
  {
    "$project": { "similarityScore": {
           "$meta": "searchScore" },
            "document" : "$$ROOT"
        }
  }
]);

Dans cet exemple, une recherche vectorielle est effectuée en utilisant queryVector comme entrée via l’interpréteur de commandes Mongo. Le résultat de la recherche est une liste des deux éléments qui sont les plus similaires au vecteur de la requête, triés en fonction de leur score de similarité.

[
  {
    similarityScore: 0.9465376,
    document: {
      _id: ObjectId("645acb54413be5502badff94"),
      name: 'Eugenia Lopez',
      bio: 'Eugenia is the CEO of AdvenureWorks.',
      vectorContent: [ 0.51, 0.12, 0.23 ]
    }
  },
  {
    similarityScore: 0.9006955,
    document: {
      _id: ObjectId("645acb54413be5502badff97"),
      name: 'Rory Nguyen',
      bio: 'Rory Nguyen is the founder of AdventureWorks and the president of the Our Planet initiative.',
      vectorContent: [ 0.91, 0.76, 0.83 ]
    }
  }
]

Obtenir des définitions d’index vectoriel

Pour récupérer votre définition d’index vectoriel à partir de la collection, utilisez la commande listIndexes :

db.exampleCollection.getIndexes();

Dans cet exemple, vectorIndex est renvoyé avec tous les paramètres cosmosSearch qui ont été utilisés pour créer l’index :

[
  { v: 2, key: { _id: 1 }, name: '_id_', ns: 'test.exampleCollection' },
  {
    v: 2,
    key: { vectorContent: 'cosmosSearch' },
    name: 'vectorSearchIndex',
    cosmosSearch: {
      kind: 'vector-ivf',
      numLists: 3,
      similarity: 'COS',
      dimensions: 3
    },
    ns: 'test.exampleCollection'
  }
]

Recherche vectorielle filtrée (préversion)

Vous pouvez désormais exécuter des recherches vectorielles avec n’importe quel filtre de requête pris en charge, tel que $lt, $lte, $eq, $neq, $gte, $gt, $in, $ninet $regex. Activez la fonctionnalité « recherche vectorielle de filtrage » sous l’onglet « Fonctionnalités en préversion » de votre abonnement Azure. En savoir plus sur les fonctionnalités en préversion ici.

Tout d’abord, vous devez définir un index pour votre filtre en plus d’un index vectoriel. Par exemple, vous pouvez définir l’index de filtre sur une propriété

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

Ensuite, vous pouvez ajouter le terme "filter" à votre recherche vectorielle, comme indiqué ci-dessous. Dans cet exemple, le filtre recherche des documents où la propriété "title" n’est pas dans la liste des ["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' }
}
]);

Utiliser les outils d’orchestration LLM

Utiliser comme base de données vectorielle avec le noyau sémantique

Utilisez le noyau sémantique pour orchestrer la récupération des informations à partir d’Azure Cosmos DB for MongoDB vCore et de votre LLM. En savoir plus ici.

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

Utiliser comme base de données vectorielle avec LangChain

Utilisez LangChain pour orchestrer votre récupération d’informations à partir d’Azure Cosmos DB for MongoDB vCore et de votre LLM. En savoir plus ici.

Utiliser comme cache sémantique avec LangChain

Utilisez LangChain et Azure Cosmos DB for MongoDB (vCore) pour orchestrer la mise en cache sémantique, en utilisant des responsabilités LLM précédemment enregistrées qui peuvent vous économiser les coûts de l’API LLM et réduire la latence des réponses. Apprenez-en davantage ici.

Fonctionnalités et limitations

• Mesures de distance prises en charge : L2 (euclidienne), produit interne et cosinus.
• Méthodes d’indexation prises en charge : IVFFLAT (disponibilité générale) et HSNW (préversion)
• Indexation de vecteurs d’une taille maximale de 2 000 dimensions.
• L’indexation ne s’applique qu’à un seul vecteur par tracé.
• Un seul index peut être créé par tracé vectoriel.

Résumé

Ce guide montre comment créer un index vectoriel, ajouter des documents contenant des données vectorielles, effectuer une recherche de similarité et récupérer la définition d’index. En utilisant notre base de données vectorielle intégrée, vous pouvez stocker, indexer et interroger efficacement des données vectorielles à haute dimension directement dans Azure Cosmos DB for MongoDB vCore. Elle vous permet de libérer le potentiel de vos données grâce à des incorporations vectorielles et vous permet de générer des applications plus précises, plus efficaces et plus puissantes.

Contenu connexe

• Solution de référence sur la vente au détail des modèles .NET RAG
• Tutoriel .NET : chatbot de recette
• Modèle RAG C# - Intégrer Open AI Services à Cosmos
• Modèle RAG Python - Chatbot de produit Azure
• didacticiel sur notebook Python - Intégration de la base de données Vector via LangChain
• didacticiel surnotebook Python - Intégration de la mise en cache LLM via LangChain
• Python -d’intégration LlamaIndex
• Python - Intégration de la mémoire du noyau sémantique

Étape suivante