--- title: Embeddings url: https://platform.claude.com/docs/fr/build-with-claude/embeddings description: Les embeddings de texte sont des représentations numériques du texte qui permettent de mesurer la similarité sémantique. Ce guide présente les embeddings, leurs applications et la manière d'utiliser les modèles d'embedding pour des tâches telles que la recherche, les recommandations et la détection d'anomalies. --- ## Avant d'implémenter les embeddings Lors du choix d'un fournisseur d'« embeddings » (plongements vectoriels), plusieurs facteurs peuvent être pris en compte selon vos besoins et vos préférences : * Taille du jeu de données et spécificité du domaine : taille du jeu de données d'entraînement du modèle et sa pertinence par rapport au domaine que vous souhaitez vectoriser. Des données plus volumineuses ou plus spécifiques à un domaine produisent généralement de meilleurs embeddings dans ce domaine. * Performances d'inférence : vitesse de recherche des embeddings et « latency » (latence) de bout en bout. Il s'agit d'une considération particulièrement importante pour les déploiements en production à grande échelle. * Personnalisation : options de poursuite de l'entraînement sur des données privées, ou spécialisation des modèles pour des domaines très spécifiques. Cela peut améliorer les performances sur des vocabulaires uniques. ## Comment obtenir des embeddings avec Anthropic Anthropic ne propose pas son propre modèle d'embedding. Voyage AI by MongoDB est un fournisseur d'embeddings qui offre une grande variété de modèles et de fonctionnalités. Voyage AI conçoit des modèles d'embedding et des « rerankers » (modèles de reclassement). Ses modèles d'embedding comprennent des modèles généralistes, multimodaux, contextualisés et spécifiques à un domaine. Le reste de ce guide concerne Voyage AI, mais vous devriez évaluer différents fournisseurs d'embeddings afin de trouver celui qui convient le mieux à votre cas d'utilisation spécifique. ## Modèles disponibles Voyage AI propose les modèles d'embedding de texte suivants : **Dernière génération** | Modèle | Longueur de contexte | Dimension d'embedding | Description | | ---------------- | -------------------- | --------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `voyage-4-large` | 32 000 | 1024 (par défaut), 256, 512, 2048 | La meilleure qualité de recherche généraliste et multilingue. Consultez l'[article de blog Voyage 4](https://blog.voyageai.com/2026/01/15/voyage-4/) pour plus de détails. | | `voyage-4` | 32 000 | 1024 (par défaut), 256, 512, 2048 | Optimisé pour la qualité de recherche généraliste et multilingue. Équilibre qualité et efficacité. Consultez l'[article de blog Voyage 4](https://blog.voyageai.com/2026/01/15/voyage-4/) pour plus de détails. | | `voyage-4-lite` | 32 000 | 1024 (par défaut), 256, 512, 2048 | Optimisé pour la latence et le coût. Consultez l'[article de blog Voyage 4](https://blog.voyageai.com/2026/01/15/voyage-4/) pour plus de détails. | | `voyage-code-4` | 32 000 | 1024 (par défaut), 256, 512, 2048 | Optimisé pour la recherche de **code** et les applications de codage agentique. Consultez l'[article de blog voyage-code-4](https://blog.voyageai.com/2026/08/13/voyage-code-4/) pour plus de détails. | | `voyage-4-nano` | 32 000 | 2048 (par défaut), 256, 512, 1024 | Modèle à poids ouverts (licence Apache 2.0) que vous téléchargez depuis [Hugging Face](https://huggingface.co/voyageai/voyage-4-nano) et exécutez vous-même. Non disponible via l'Atlas Embedding and Reranking API. Consultez l'[article de blog Voyage 4](https://blog.voyageai.com/2026/01/15/voyage-4/) pour plus de détails. | **Génération précédente** Pour connaître le statut du cycle de vie de chaque modèle et son remplaçant recommandé, consultez [Model deprecations, lifecycle states, and support](https://www.mongodb.com/docs/voyageai/models/lifecycle/) dans la documentation MongoDB. | Modèle | Longueur de contexte | Dimension d'embedding | Description | | ------------------ | -------------------- | --------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `voyage-3-large` | 32 000 | 1024 (par défaut), 256, 512, 2048 | Génération précédente de `voyage-4-large`. Consultez l'[article de blog voyage-3-large](https://blog.voyageai.com/2025/01/07/voyage-3-large/) pour plus de détails. | | `voyage-3.5` | 32 000 | 1024 (par défaut), 256, 512, 2048 | Génération précédente de `voyage-4`. Consultez l'[article de blog voyage-3.5](https://blog.voyageai.com/2025/05/20/voyage-3-5/) pour plus de détails. | | `voyage-3.5-lite` | 32 000 | 1024 (par défaut), 256, 512, 2048 | Génération précédente de `voyage-4-lite`. Consultez l'[article de blog voyage-3.5](https://blog.voyageai.com/2025/05/20/voyage-3-5/) pour plus de détails. | | `voyage-code-3` | 32 000 | 1024 (par défaut), 256, 512, 2048 | Génération précédente de `voyage-code-4`. Consultez l'[article de blog voyage-code-3](https://blog.voyageai.com/2024/12/04/voyage-code-3/) pour plus de détails. | | `voyage-finance-2` | 32 000 | 1024 | Optimisé pour la recherche et le RAG dans le domaine de la **finance**. Consultez l'[article de blog voyage-finance-2](https://blog.voyageai.com/2024/06/03/domain-specific-embeddings-finance-edition-voyage-finance-2/) pour plus de détails. | | `voyage-law-2` | 16 000 | 1024 | Optimisé pour la recherche et le RAG dans le domaine **juridique**. Consultez l'[article de blog voyage-law-2](https://blog.voyageai.com/2024/04/15/domain-specific-embeddings-and-retrieval-legal-edition-voyage-law-2/) pour plus de détails. | Voyage AI propose également les modèles d'embedding multimodaux suivants. Appelez ces modèles avec `multimodal_embed()` au lieu de `embed()` : | Modèle | Longueur de contexte | Dimension d'embedding | Description | | ----------------------- | -------------------- | --------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `voyage-multimodal-3.5` | 32 000 | 1024 (par défaut), 256, 512, 2048 | Modèle d'embedding multimodal riche capable de vectoriser du texte, des images et des vidéos entrelacés. Inclut la prise en charge de la vidéo en tant que premier modèle d'embedding vidéo de qualité production. Consultez l'[article de blog voyage-multimodal-3.5](https://blog.voyageai.com/2026/01/15/voyage-multimodal-3-5/) pour plus de détails. | | `voyage-multimodal-3` | 32 000 | 1024 | Génération précédente de `voyage-multimodal-3.5`. Vectorise du texte entrelacé et des images riches en contenu, telles que des captures d'écran de PDF, des diapositives, des tableaux, des figures, et plus encore. Consultez l'[article de blog voyage-multimodal-3](https://blog.voyageai.com/2024/11/12/voyage-multimodal-3/) pour plus de détails. | Les modèles d'embedding de segments contextualisés suivants produisent des vecteurs au niveau du segment qui capturent le contexte complet du document sans enrichissement manuel par métadonnées. Appelez ces modèles avec `contextualized_embed()` au lieu de `embed()` : | Modèle | Longueur de contexte | Dimension d'embedding | Description | | ------------------ | -------------------- | --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `voyage-context-4` | 120 000 | 1024 (par défaut), 256, 512, 2048 | Embeddings de segments contextualisés optimisés pour la qualité de recherche généraliste et multilingue. Consultez l'[article de blog voyage-context-4](https://blog.voyageai.com/2026/06/29/voyage-context-4/) pour plus de détails. | | `voyage-context-3` | 120 000 | 1024 (par défaut), 256, 512, 2048 | Génération précédente de `voyage-context-4`. Consultez l'[article de blog voyage-context-3](https://blog.voyageai.com/2025/07/23/voyage-context-3/) pour plus de détails. | La limite de 120 000 tokens s'applique lorsque vous définissez `enable_auto_chunking` sur `true`. Sinon, le nombre total de tokens sur l'ensemble des entrées ne peut pas dépasser 32 000. Voyage AI propose également des « rerankers » (modèles de reclassement), qui prennent une requête et une liste de documents et les renvoient classés par pertinence par rapport à la requête. Appelez ces modèles avec `rerank()` : | Modèle | Longueur de contexte | Description | | ----------------- | -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `rerank-3` | 32 000 | Précision la plus élevée. Recommandé pour la plupart des applications. Consultez l'[article de blog rerank-3](https://blog.voyageai.com/2026/09/30/rerank-3/) pour plus de détails. | | `rerank-3-lite` | 32 000 | Optimisé pour la latence et le coût. Consultez l'[article de blog rerank-3](https://blog.voyageai.com/2026/09/30/rerank-3/) pour plus de détails. | | `rerank-2.5` | 32 000 | Génération précédente de `rerank-3`. Consultez l'[article de blog rerank-2.5](https://blog.voyageai.com/2025/08/11/rerank-2-5/) pour plus de détails. | | `rerank-2.5-lite` | 32 000 | Génération précédente de `rerank-3-lite`. Consultez l'[article de blog rerank-2.5](https://blog.voyageai.com/2025/08/11/rerank-2-5/) pour plus de détails. | Besoin d'aide pour choisir le modèle à utiliser ? Consultez [Voyage AI embedding and reranking models overview](https://www.mongodb.com/docs/voyageai/models/) dans la documentation MongoDB. ## Premiers pas avec Voyage AI Pour accéder aux modèles Voyage AI, créez une clé API de modèle dans MongoDB Atlas : 1. Créez un compte MongoDB Atlas ou connectez-vous. 2. Dans votre projet Atlas, sélectionnez **AI Model APIs** dans la barre de navigation, cliquez sur **Create model API key**, nommez la clé, puis cliquez sur **Create**. 3. Pour plus de commodité, définissez la clé API comme variable d'environnement : ```bash export VOYAGE_API_KEY="" ``` Pour plus de détails, consultez [Voyage AI quick start](https://www.mongodb.com/docs/voyageai/quickstart/) dans la documentation MongoDB. Vous pouvez obtenir les embeddings soit en utilisant le [package Python officiel `voyageai`](https://github.com/voyage-ai/voyageai-python), soit au moyen de requêtes HTTP, comme décrit dans les sections suivantes. Voyage AI dispose également d'un client TypeScript officiel. Pour l'utiliser avec une clé API de modèle provenant d'Atlas, définissez son option `environment` sur `https://ai.mongodb.com/v1`, comme décrit dans [TypeScript client](https://www.mongodb.com/docs/voyageai/api-and-clients/#typescript-client) dans la documentation MongoDB. ### Bibliothèque Python Voyage AI Installez le package `voyageai` à l'aide de la commande suivante. Pour utiliser une clé API de modèle provenant d'Atlas, vous avez besoin de la version 0.3.7 ou ultérieure. ```bash pip install -U voyageai ``` Ensuite, vous pouvez créer un objet client et commencer à l'utiliser pour vectoriser vos textes : ```python import voyageai vo = voyageai.Client() # Cela utilisera automatiquement la variable d'environnement VOYAGE_API_KEY. # Vous pouvez aussi utiliser vo = voyageai.Client(api_key="") texts = ["Sample text 1", "Sample text 2"] result = vo.embed(texts, model="voyage-4", input_type="document") print(result.embeddings[0]) print(result.embeddings[1]) ``` `result.embeddings` est une liste de deux vecteurs d'embedding, chacun contenant 1024 nombres à virgule flottante. Après l'exécution du code précédent, les deux embeddings sont affichés à l'écran : ```text [-0.013131560757756233, 0.019828535616397858, ...] # embedding for "Sample text 1" [-0.0069352793507277966, 0.020878976210951805, ...] # embedding for "Sample text 2" ``` Lors de la création des embeddings, vous pouvez spécifier quelques autres arguments à la fonction `embed()`. Pour plus d'informations sur le package Python, consultez [Accessing Voyage AI models](https://www.mongodb.com/docs/voyageai/api-and-clients/) dans la documentation MongoDB. ### API HTTP Voyage AI Vous pouvez également obtenir des embeddings en envoyant des requêtes HTTP à l'Atlas Embedding and Reranking API. Par exemple, vous pouvez envoyer une requête HTTP via la commande `curl` dans un terminal : ```bash cURL curl https://ai.mongodb.com/v1/embeddings \ -H "Content-Type: application/json" \ -H "Authorization: Bearer $VOYAGE_API_KEY" \ -d '{ "input": ["Sample text 1", "Sample text 2"], "model": "voyage-4", "input_type": "document" }' ``` La réponse que vous obtiendrez est un objet JSON contenant les embeddings et l'utilisation des tokens : ```json { "object": "list", "data": [ { "object": "embedding", "embedding": [-0.013131560757756233, 0.019828535616397858 /* ... */], "index": 0 }, { "object": "embedding", "embedding": [-0.0069352793507277966, 0.020878976210951805 /* ... */], "index": 1 } ], "model": "voyage-4", "usage": { "total_tokens": 10 } } ``` Les clés API de modèle provenant d'Atlas fonctionnent avec `ai.mongodb.com`, à l'exception des clés limitées à une zone géographique, qui utilisent le point de terminaison de cette zone. Si vous disposez plutôt d'une clé API provenant de la plateforme Voyage AI, consultez [Migrate your applications to use the Atlas Embedding and Reranking API](https://www.mongodb.com/docs/voyageai/tutorials/migrate-to-atlas/) dans la documentation MongoDB. Pour la référence complète des requêtes et des réponses, consultez [Create text embeddings](https://www.mongodb.com/docs/api/doc/atlas-embedding-and-reranking-api/operation/operation-createembedding) dans la documentation de l'Atlas Embedding and Reranking API. ### AWS Marketplace Les modèles Voyage AI sont également disponibles sur AWS Marketplace via le [profil vendeur de MongoDB](https://aws.amazon.com/marketplace/seller-profile?id=c9032c7b-70dd-459f-834f-c1e23cf3d092). Pour les instructions, consultez [Deploy Voyage AI models using AWS Marketplace](https://www.mongodb.com/docs/voyageai/management/aws-marketplace/) dans la documentation MongoDB. ## Exemple de démarrage rapide Le bref exemple suivant montre comment utiliser les embeddings. Supposons que vous disposiez d'un petit corpus de six documents dans lequel effectuer des recherches ```python documents = [ "The Mediterranean diet emphasizes fish, olive oil, and vegetables, believed to reduce chronic diseases.", "Photosynthesis in plants converts light energy into glucose and produces essential oxygen.", "20th-century innovations, from radios to smartphones, centered on electronic advancements.", "Rivers provide water, irrigation, and habitat for aquatic species, vital for ecosystems.", "Apple's conference call to discuss fourth fiscal quarter results and business updates is scheduled for Thursday, November 2, 2023 at 2:00 p.m. PT / 5:00 p.m. ET.", "Shakespeare's works, like 'Hamlet' and 'A Midsummer Night's Dream,' endure in literature.", ] ``` Tout d'abord, utilisez Voyage AI pour convertir chaque document en vecteur d'embedding. ```python import voyageai vo = voyageai.Client() # Générer les embeddings des documents doc_embds = vo.embed(documents, model="voyage-4", input_type="document").embeddings ``` Les embeddings vous permettent d'effectuer une recherche sémantique / récupération dans l'espace vectoriel. Étant donné un exemple de requête, ```python query = "When is Apple's conference call scheduled?" ``` Ensuite, convertissez-la en embedding et effectuez une recherche du plus proche voisin pour trouver le document le plus pertinent en fonction de la distance dans l'espace d'embedding. ```python import numpy as np # Générer l'embedding de la requête query_embd = vo.embed([query], model="voyage-4", input_type="query").embeddings[0] # Calculer la similarité # Les embeddings Voyage AI sont normalisés à une longueur de 1, donc le produit scalaire # et la similarité cosinus sont identiques. similarities = np.dot(doc_embds, query_embd) retrieved_id = np.argmax(similarities) print(documents[retrieved_id]) ``` Notez que `input_type="document"` et `input_type="query"` sont utilisés respectivement pour l'embedding du document et de la requête. Pour en savoir plus sur `input_type`, consultez [Quand et comment dois-je utiliser le paramètre input\_type ?](https://platform.claude.com/docs/fr/build-with-claude/embeddings#faq) dans la FAQ. La sortie est le cinquième document, qui est effectivement le plus pertinent pour la requête : ```text wrap Apple's conference call to discuss fourth fiscal quarter results and business updates is scheduled for Thursday, November 2, 2023 at 2:00 p.m. PT / 5:00 p.m. ET. ``` Si vous recherchez un ensemble détaillé de recettes sur la manière de faire du RAG avec des embeddings, y compris avec des bases de données vectorielles, consultez la [recette RAG](https://platform.claude.com/cookbook/third-party-pinecone-rag-using-pinecone). ## FAQ Les modèles d'embedding s'appuient sur de puissants réseaux de neurones pour capturer et compresser le contexte sémantique, à l'instar des modèles génératifs. L'équipe de chercheurs expérimentés en IA de Voyage AI optimise chaque composant du processus d'embedding, notamment : * L'architecture du modèle * La collecte des données * Les fonctions de perte * Le choix de l'optimiseur Pour en savoir plus sur l'approche technique de Voyage AI, consultez le [blog de Voyage AI](https://blog.voyageai.com/). Pour l'embedding généraliste, les modèles recommandés sont : * `voyage-4-large` : meilleure qualité * `voyage-4-lite` : latence et coût les plus faibles * `voyage-4` : performances équilibrées Pour la recherche, utilisez le paramètre `input_type` pour spécifier si le texte est de type requête ou document. Modèles spécifiques à un domaine : * Tâches juridiques : `voyage-law-2` * Recherche de code et codage agentique : `voyage-code-4` * Tâches liées à la finance : `voyage-finance-2` Pour la recherche au niveau du segment et du document : `voyage-context-4` Pour le texte, les images et la vidéo : `voyage-multimodal-3.5` Vous pouvez utiliser les embeddings Voyage AI avec la similarité par produit scalaire, la similarité cosinus ou la distance euclidienne. Pour une explication de la similarité entre embeddings, consultez ce [guide sur la similarité vectorielle](https://www.pinecone.io/learn/vector-similarity/). Les embeddings Voyage AI sont normalisés à une longueur de 1, ce qui signifie que : * La similarité cosinus est équivalente à la similarité par produit scalaire, cette dernière pouvant être calculée plus rapidement. * La similarité cosinus et la distance euclidienne produisent des classements identiques. Consultez [Tokenization](https://www.mongodb.com/docs/voyageai/tutorials/tokenization/) dans la documentation MongoDB. Pour toutes les tâches et tous les cas d'utilisation de recherche (par exemple, le RAG), utilisez le paramètre `input_type` pour spécifier si le texte d'entrée est une requête ou un document. N'omettez pas `input_type` et ne définissez pas `input_type=None`. Spécifier si le texte d'entrée est une requête ou un document permet de créer de meilleures représentations vectorielles denses pour la recherche, ce qui peut conduire à une meilleure qualité de recherche. Lors de l'utilisation du paramètre `input_type`, des prompts spéciaux sont ajoutés au début du texte d'entrée avant l'embedding. Plus précisément : > 📘 **Prompts associés à `input_type`** > > * Pour une requête, le prompt est `"Represent the query for retrieving supporting documents: "`. > > * Pour un document, le prompt est `"Represent the document for retrieval: "`. > > * Exemple > > * Lorsque `input_type="query"`, une requête telle que « When is Apple's conference call scheduled? » deviendra « **Represent the query for retrieving supporting documents:** When is Apple's conference call scheduled? ». > * Lorsque `input_type="document"`, un document tel que « Apple's conference call to discuss fourth fiscal quarter results and business updates is scheduled for Thursday, November 2, 2023 at 2:00 p.m. PT / 5:00 p.m. ET. » deviendra « **Represent the document for retrieval:** Apple's conference call to discuss fourth fiscal quarter results and business updates is scheduled for Thursday, November 2, 2023 at 2:00 p.m. PT / 5:00 p.m. ET. ». La « quantization » (quantification) des embeddings convertit des valeurs de haute précision, telles que des nombres à virgule flottante simple précision sur 32 bits, en formats de moindre précision tels que des entiers sur 8 bits ou des valeurs binaires sur 1 bit, réduisant ainsi le stockage, la mémoire et les coûts respectivement d'un facteur 4 et 32. Les modèles Voyage AI compatibles permettent la quantification en spécifiant le type de données de sortie avec le paramètre `output_dtype` : * `float` : chaque embedding renvoyé est une liste de nombres à virgule flottante simple précision sur 32 bits (4 octets). Il s'agit de la valeur par défaut, qui offre la plus haute précision / exactitude de recherche. * `int8` et `uint8` : chaque embedding renvoyé est une liste d'entiers sur 8 bits (1 octet) allant respectivement de -128 à 127 et de 0 à 255. * `binary` et `ubinary` : chaque embedding renvoyé est une liste d'entiers sur 8 bits qui représentent des valeurs d'embedding quantifiées sur un seul bit et empaquetées par bits : `int8` pour `binary` et `uint8` pour `ubinary`. La longueur de la liste d'entiers renvoyée correspond à 1/8 de la dimension réelle de l'embedding. Le type binary utilise la méthode du binaire décalé, comme le montre l'exemple suivant. > **Exemple de quantification binaire** > > Considérez les huit valeurs d'embedding suivantes : -0.03955078, 0.006214142, -0.07446289, -0.039001465, 0.0046463013, 0.00030612946, -0.08496094 et 0.03994751. Avec la quantification binaire, les valeurs inférieures ou égales à zéro seront quantifiées en un zéro binaire, et les valeurs positives en un un binaire, ce qui donne la séquence binaire suivante : 0, 1, 0, 0, 1, 1, 0, 1. Ces huit bits sont ensuite empaquetés dans un seul entier sur 8 bits, 01001101 (le bit le plus à gauche étant le bit de poids fort). > > * `ubinary` : la séquence binaire est directement convertie et représentée sous la forme de l'entier non signé (`uint8`) 77. > * `binary` : la séquence binaire est représentée sous la forme de l'entier signé (`int8`) -51, calculé à l'aide de la méthode du binaire décalé (77 - 128 = -51). Pour connaître les modèles qui prennent en charge chaque type de données, consultez [Create text embeddings](https://www.mongodb.com/docs/api/doc/atlas-embedding-and-reranking-api/operation/operation-createembedding) dans la documentation de l'Atlas Embedding and Reranking API. L'apprentissage Matryoshka crée des embeddings comportant des représentations allant du grossier au fin au sein d'un même vecteur. Les modèles Voyage AI qui prennent en charge plusieurs dimensions de sortie, tels que `voyage-code-4`, génèrent de tels embeddings Matryoshka. Pour obtenir des vecteurs plus courts depuis l'API, passez `output_dimension` (par exemple, `output_dimension=256`). Pour raccourcir des vecteurs que vous avez déjà stockés, tronquez-les en conservant le sous-ensemble initial de dimensions, puis normalisez-les à nouveau. Par exemple, le code Python suivant montre comment tronquer des vecteurs de 1024 dimensions à 256 dimensions : ```python import voyageai import numpy as np def embd_normalize(v: np.ndarray) -> np.ndarray: """ Normalize the rows of a 2D numpy array to unit vectors by dividing each row by its Euclidean norm. Raises a ValueError if any row has a norm of zero to prevent division by zero. """ row_norms = np.linalg.norm(v, axis=1, keepdims=True) if np.any(row_norms == 0): raise ValueError("Cannot normalize rows with a norm of zero.") return v / row_norms vo = voyageai.Client() # Générer des vecteurs voyage-code-4, qui sont par défaut des nombres à virgule flottante de dimension 1024. embd = vo.embed(["Sample text 1", "Sample text 2"], model="voyage-code-4").embeddings # Définir une dimension plus courte. short_dim = 256 # Redimensionner et normaliser les vecteurs à la dimension plus courte. resized_embd = embd_normalize(np.array(embd)[:, :short_dim]).tolist() ``` ## Tarification Pour obtenir les informations tarifaires les plus récentes, consultez [Model pricing](https://www.mongodb.com/docs/voyageai/management/billing/#model-pricing) dans la documentation MongoDB.