Partager via

Stockage vectoriel dans Azure Cosmos DB for MongoDB sur vCore

  • Article

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> 
            } 
        } 
    ] 
}
Champ Type Description
index_name string Nom unique de l’index.
path_to_property string Chemin d’accès à la propriété qui contient le vecteur. Ce chemin peut être une propriété de niveau supérieur ou un chemin d’accès en notation par points à la propriété. Si un chemin en notation par points est utilisé, tous les éléments non-feuilles ne peuvent pas être des tableaux. Les vecteurs doivent être de type number[] pour être indexés et apparaître dans les résultats de la recherche vectorielle.
kind string Type d’index vectoriel à créer. Les options sont vector-ivf et vector-hnsw. Notez que vector-ivf est disponible sur tous les niveaux de cluster et vector-hnsw est disponible sur les niveaux de cluster M40 et versions ultérieures.
m entier Nombre maximal de connexions par couche (16 par défaut, valeur minimale 2, valeur maximale 100). Le m plus élevé convient aux jeux de données dont la dimensionnalité et/ou les exigences d’exactitude sont élevées.
efConstruction entier la taille de la liste de candidats dynamiques pour la construction du graphique (64 par défaut, valeur minimale 4, valeur maximale 1000). Une valeur efConstruction plus élevée se traduira par une meilleure qualité de l’index et une plus grande exactitude, mais augmentera également le temps nécessaire pour générer l’index. efConstruction doit être au moins de 2 * m
similarity string Métrique de similarité à utiliser avec l’index. Les options possibles sont COS (distance cosinus), L2 (distance euclidienne) et IP (produit interne).
dimensions entier Nombre de dimensions pour la similarité vectorielle. Le nombre maximal de dimensions prises en charge est de 2000.

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>
        },
    }
  }
}
Champ Type Description
efSearch entier Taille de la liste de candidats dynamiques pour la recherche (40 par défaut). Une valeur plus élevée offre un meilleur rappel au détriment de la vitesse.
k entier Nombre de résultats à renvoyer. il doit être inférieur ou égal à efSearch

Remarque

La création d’un index HSNW avec des jeux de données volumineux peut entraîner l’épuisement de la mémoire de votre ressource vCore Azure Cosmos DB for MongoDB ou limiter les performances d’autres opérations exécutées sur votre base de données. Si vous rencontrez de tels problèmes, ceux-ci peuvent être atténués en mettant à l’échelle votre ressource vers un niveau de cluster supérieur ou en réduisant la taille du jeu de données.

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>
      }
    }
  ]
}
Champ Type Description
index_name string Nom unique de l’index.
path_to_property string Chemin d’accès à la propriété qui contient le vecteur. Ce chemin peut être une propriété de niveau supérieur ou un chemin d’accès en notation par points à la propriété. Si un chemin en notation par points est utilisé, tous les éléments non-feuilles ne peuvent pas être des tableaux. Les vecteurs doivent être de type number[] pour être indexés et apparaître dans les résultats de la recherche vectorielle.
kind string Type d’index vectoriel à créer. Les options sont vector-ivf et vector-hnsw. Notez que vector-ivf est disponible sur tous les niveaux de cluster et vector-hnsw est disponible sur les niveaux de cluster M40 et versions ultérieures.
numLists entier Cet entier est le nombre de clusters que l’index du fichier inversé (IVF) utilise pour regrouper les données vectorielles. Nous vous recommandons de définir numLists sur documentCount/1000 pour un nombre de documents inférieur ou égal à 1 million et sur sqrt(documentCount) pour un nombre de documents supérieur à 1 million. L’utilisation d’une numLists valeur de 1 s’apparente à l’exécution d’une recherche par force brute qui présente des performances limitées.
similarity string Métrique de similarité à utiliser avec l’index. Les options possibles sont COS (distance cosinus), L2 (distance euclidienne) et IP (produit interne).
dimensions entier Nombre de dimensions pour la similarité vectorielle. Le nombre maximal de dimensions prises en charge est de 2000.

Important

Il est important de définir correctement le paramètre numLists pour obtenir une bonne exactitude et de bonnes performances. Nous vous recommandons de définir numLists sur documentCount/1000 pour un nombre de documents inférieur ou égal à 1 million et sur sqrt(documentCount) pour un nombre de documents supérieur à 1 million.

À mesure que le nombre d’éléments de votre base de données augmente, vous devez ajuster numLists pour qu’il soit plus volumineux afin d’obtenir de bonnes performances de latence pour la recherche vectorielle.

Si vous expérimentez un nouveau scénario ou créez une petite démonstration, vous pouvez commencer par numLists défini sur 1 pour effectuer une recherche par force brute sur tous les vecteurs. Cela devrait vous fournir les résultats les plus précis de la recherche vectorielle, mais sachez que la vitesse de recherche et la latence seront lentes. Après votre configuration initiale, vous devez régler le paramètre numLists à l’aide des instructions ci-dessus.

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.

Important

Les vecteurs doivent être de type number[] pour être indexés. L’utilisation d’un autre type, tel que double[], empêche l’indexation du document. Les documents non indexés ne seront pas renvoyés dans le résultat d’une recherche vectorielle.

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]},
]);

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

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.

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' }
}
]);

Important

Dans la préversion, la recherche vectorielle filtrée peut vous obliger à ajuster vos paramètres d’index vectoriel pour obtenir une précision plus élevée. Par exemple, augmenter m, efConstructionou efSearch lors de l’utilisation de HNSW, ou numLists, ou nProbes lors de l’utilisation d’IVF, peut entraîner de meilleurs résultats. Vous devez tester votre configuration avant d’utiliser pour vous assurer que les résultats sont satisfaisants.

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

Étape suivante

Créer un cluster vCore de niveau gratuit durable pour Azure Cosmos DB for MongoDB