Guide

Embeddings OpenAI : du texte transformé en nombres

Embeddings OpenAI en pratique : choix entre les deux modèles, réduction des dimensions, chunking, recherche hybride, coûts, alternatives et erreurs fréquentes.

L'équipe CodeWorlds13 min de lecture ·

Pratique Python dans des leçons interactives avec un éditeur de code.

Crée un compte gratuit→
Dans cet article10

Un embedding transforme un fragment de texte en une liste de nombres choisis pour que les textes de sens proche se retrouvent proches les uns des autres. La recherche sémantique, les systèmes de recommandation, le regroupement de documents et toute la couche de récupération de contexte des applications à base de modèles de langage reposent là-dessus.

OpenAI propose deux modèles dans cette famille, un plus petit et un plus grand, plus un plus ancien que l'éditeur déconseille pour les nouveaux projets. Cette gamme n'a pas changé depuis longtemps, et ce fait compte au moment de choisir, comme le détaille une section dédiée.

L'avantage pratique est banal : c'est la voie la plus simple vers une recherche sémantique fonctionnelle. Un appel d'API, aucune infrastructure, et des coûts qui se mesurent en centimes aux volumes habituels.

Deux modèles et comment choisir

Le plus petit modèle renvoie un vecteur de mille cinq cent trente-six dimensions et coûte environ deux centimes par million de tokens. Le plus grand renvoie trois mille soixante-douze dimensions et coûte treize centimes par million de tokens, soit six fois et demie plus.

La règle de choix est plus courte qu'on ne le croirait. Commencez par le plus petit. Pour la plupart des usages, la différence de précision est faible, alors que la différence de coût de stockage et de recherche croît linéairement avec le nombre de dimensions, donc vous la payez à chaque requête et pas seulement au moment de l'indexation.

Passez au plus grand quand vous aurez mesuré que le plus petit ne suffit pas. Pas « quand vous le soupçonnez » mais « quand vous mesurez sur votre propre jeu de questions avec les réponses attendues », car c'est la seule façon de le savoir.

L'ancien modèle fonctionne toujours et coûte cinq fois plus que le nouveau plus petit pour une qualité moindre. Si vous avez un projet construit dessus, migrer vaut la peine, même si cela demande de recalculer tout l'ensemble, car les vecteurs de modèles différents ne sont pas comparables.

Votre premier appel

Python
from openai import OpenAI

client = OpenAI()

response = client.embeddings.create(
    model="text-embedding-3-small",
    input=["What is the notice period?", "Contract termination conditions"],
)

vectors = [d.embedding for d in response.data]

Notez la liste passée en entrée. Un appel accepte de nombreux textes à la fois, et c'est l'optimisation la plus simple de tout ce domaine et aussi la plus souvent sautée. Traiter mille fragments un par un, ce sont mille allers-retours vers l'API, alors que regrouper par cent n'en fait que dix. La différence de temps d'indexation peut être de plusieurs fois.

Comparer deux vecteurs revient à un produit scalaire, puisque les modèles de cette famille renvoient des vecteurs normalisés.

Python
import numpy as np

def similarity(a, b):
    return float(np.dot(a, b))

Un résultat proche de un signifie des textes de sens proche, proche de zéro aucune relation. Il faut savoir que les valeurs descendent rarement sous zéro sur du texte naturel, donc un seuil de coupure se choisit empiriquement et non à partir de la théorie. En pratique, cela veut dire qu'un nombre comme 0,7 ne dit rien tout seul, et qu'il faut voir la distribution des scores pour votre propre collection avant de fixer un seuil.

Tronquer les dimensions

Cette fonction est sous-estimée et, sur de grandes collections, décisive pour les coûts.

Les modèles de cette famille permettent de raccourcir le vecteur renvoyé sans le recalculer. Vous indiquez un nombre de dimensions inférieur à la valeur par défaut et vous recevez un vecteur plus court qui fonctionne toujours raisonnablement, car le modèle a été entraîné à placer l'information la plus importante au début de la liste.

Python
response = client.embeddings.create(
    model="text-embedding-3-small",
    input=chunks,
    dimensions=512,
)

Le gain est double. La base de données vectorielle prend trois fois moins de place, et la recherche va plus vite, puisqu'elle compare des vecteurs plus courts. La perte de précision est souvent assez faible pour qu'elle ne se remarque pas dans de nombreux usages sans mesure.

Le conseil pratique : testez cela sur vos propres données avant de construire l'index. Prenez cinquante vraies questions avec les réponses attendues, indexez la même collection avec le nombre complet et avec un nombre réduit de dimensions, et comparez la précision. Si la différence est d'un pour cent et l'économie de trois quarts de l'espace, la décision s'impose d'elle-même.

Une réserve technique : les vecteurs tronqués méritent d'être normalisés, car la coupe perturbe leur longueur. La plupart des bibliothèques s'en chargent, tandis qu'une implémentation maison permet facilement de l'oublier.

Coûts et mode batch

La facture des embeddings est généralement la plus petite ligne du budget d'une application à base de modèle de langage, et le dire clairement compte, car on perd du temps à optimiser ce qu'il ne faut pas.

Indexer cent mille fragments de cinq cents tokens, ce sont cinquante millions de tokens, environ un dollar avec le plus petit modèle. La recherche coûte encore moins, puisqu'une requête fait une douzaine de tokens environ.

Les vrais coûts sont ailleurs : dans les appels au modèle qui génère les réponses et dans la maintenance de la base de données vectorielle. C'est là qu'il vaut la peine de chercher des économies.

Si vous indexez malgré tout des millions de documents, le mode batch divise le prix par deux en échange de résultats livrés sous un jour. Pour un passage unique sur des archives, c'est un choix évident ; pour une indexation continue, c'est inutile.

Construisez aussi un cache pour les vecteurs. Le même fragment de texte traité deux fois donne le même résultat, donc stocker un hash du contenu à côté du vecteur permet de sauter tout ce qui n'a pas changé. Sur des archives mises à jour de façon incrémentale, cela transforme un recalcul complet nocturne en quelques minutes de rattrapage.

Prévoyez séparément les limites côté API. Indexer une grande collection butera sur un plafond de requêtes par minute, et bien que la bibliothèque relance par défaut ces réponses, sans votre propre backoff exponentiel le processus peut rester bloqué pendant des heures. Un montage raisonnable est de traiter des lots de quelques dizaines de fragments, avec une poignée de workers en parallèle, et d'écrire la progression dans un fichier, pour qu'une exécution interrompue reprenne là où elle s'est arrêtée plutôt que depuis le début.

Le chunking, la décision qui pèse plus que le modèle

Les embeddings se calculent pour des fragments, et la façon de découper le texte en fragments influence la précision de la recherche plus que le choix entre deux modèles. C'est la partie la plus souvent sautée de tout le processus.

Un fragment trop court porte trop peu de contexte pour répondre à quoi que ce soit. Deux phrases arrachées au milieu d'un contrat paraissent sensées et ne disent rien de la partie concernée ni des circonstances dans lesquelles elles s'appliquent.

Un fragment trop long dilue le sens. Le vecteur fait la moyenne de tout le contenu, donc une page de texte qui couvre quatre sujets différents produit un vecteur proche d'aucun d'eux.

Un point de départ raisonnable est des fragments qui correspondent aux sections du document, de quelques centaines à environ quinze cents caractères, avec un petit chevauchement. Le chevauchement règle le problème d'une phrase coupée en deux par la limite d'un fragment.

Deux choses améliorent la précision plus que le réglage de la longueur. La première est de faire précéder chaque fragment du titre de sa section et du titre du document dont il provient. Un fragment qui commence par « Chapter 4, Termination conditions » porte un contexte que la phrase seule n'a pas. La seconde est de filtrer les en-têtes, pieds de page et numéros de page avant l'indexation, car un texte répété présent dans chaque fragment dilue son sens.

Passez en revue vingt fragments générés avant de construire quoi que ce soit d'autre. Un quart d'heure de ce travail montre généralement que les paramètres doivent être ajustés, et cela change la qualité des réponses plus que n'importe quel réglage de prompt.

La recherche hybride

Les embeddings seuls ont une faiblesse à connaître avant de construire toute une couche de récupération dessus.

La recherche fondée sur le sens manque les correspondances exactes. Une requête sur un numéro de facture, un code d'erreur, un nom propre ou un identifiant de produit peut ne pas atteindre le document qui contient exactement cette valeur, car les vecteurs opèrent sur le sens et une chaîne comme un code de produit n'a aucun sens pour le modèle.

La réponse est de combiner deux méthodes de recherche : la classique, fondée sur la correspondance de mots, et la sémantique, fondée sur les vecteurs. Les résultats des deux se fusionnent en une seule liste, ce qui donne un système qui se débrouille aussi bien avec une question descriptive qu'avec un numéro précis.

La plupart des bases de données vectorielles prennent cela en charge directement aujourd'hui, il est donc inutile de le construire vous-même. Vérifiez quand même que la vôtre le fait avant de décider, car l'ajouter plus tard signifie un deuxième index à côté du premier. Si Elasticsearch tourne déjà dans votre système, vous obtenez cela presque gratuitement : un moteur à index inversé gère la correspondance de mots-clés et la correspondance vectorielle en une seule requête, et ajouter un stockage vectoriel séparé est rarement rentable dans ce cas.

Un troisième élément, généralement ajouté en dernier, est le réordonnancement des résultats par un modèle distinct qui note l'adéquation entre une requête et un fragment. Cela coûte un appel supplémentaire par requête et peut relever nettement la précision, car un tel modèle voit la requête et le fragment ensemble plutôt que seulement la distance entre deux points de l'espace.

L'état de la concurrence

Il faut dire ici quelque chose que la documentation de l'éditeur ne dira pas, et cela compte pour choisir sur un nouveau projet.

L'offre d'OpenAI dans ce domaine n'a pas changé depuis longtemps, alors qu'au cours de 2026 des concurrents ont publié des modèles qui vont plus loin. Des options sont apparues qui gèrent plusieurs types de contenu à la fois, images et audio compris, ainsi que des modèles spécialisés dans des domaines précis, plus performants sur les textes juridiques ou sur le code.

Cela ne veut pas dire que les modèles d'OpenAI ont cessé d'être un bon choix. Cela veut dire qu'ils ont cessé d'être le choix par défaut fait sans réfléchir. Si vous construisez une recherche sur des documents texte en anglais ou dans une autre grande langue, ils restent raisonnables, peu coûteux et prévisibles. Si vous avez besoin de gérer des images, de chercher dans du code ou d'une haute qualité dans un domaine étroit, les alternatives méritent d'être vérifiées.

Deux alternatives méritent d'être vérifiées en premier, car elles se trouvent aux deux extrémités de l'échelle. BGE est une famille de modèles à poids ouverts que vous exécutez vous-même en ne payant que le matériel, ce qui change fondamentalement l'arithmétique à fort volume. Les embeddings Vertex AI vont dans l'autre sens, en ajoutant le contrôle de la région de traitement et la facturation dans Google Cloud.

La méthode de vérification est toujours la même et prend un après-midi. Un jeu de cinquante vraies questions avec les réponses attendues, la même collection indexée avec deux modèles, et une comparaison de la fréquence à laquelle le bon document est arrivé dans les cinq premiers résultats. Les benchmarks publics mesurent des tâches qui ressemblent rarement aux vôtres.

Embeddings OpenAI face aux alternatives

OptionPoint fortPoint faibleÀ choisir quand
OpenAISimplicité, prix bas, prévisibilitéGamme inchangée depuis un moment, texte seulementRecherche sur des documents texte
CohereBons résultats multilingues, réordonnancement des résultatsUn fournisseur de plus à facturerCollections en plusieurs langues
GeminiGère plusieurs types de contenu à la foisChangements fréquents de noms de modèlesRecherche à travers images et documents
Un modèle localAucun coût par token, les données restent chez vousDemande du matériel et de l'entretienDonnées qui ne peuvent pas quitter l'entreprise

La dernière ligne mérite l'attention, car on la saute. Les modèles d'embeddings exécutés en local sont aujourd'hui assez bons pour que, sur une recherche dans des documents d'entreprise, l'écart avec les services payants soit souvent faible, et les données ne quittent jamais votre infrastructure. Le coût est le matériel et l'entretien, donc sur une petite collection cela ne se rentabilise pas alors que sur une grande cela peut décider.

Erreurs courantes

La première est d'envoyer les fragments un par un au lieu de les regrouper. La différence de temps d'indexation peut être de plusieurs fois, et le changement tient en une ligne de code.

La deuxième est de mélanger dans un seul index des vecteurs de modèles différents. Ils ne sont pas comparables, donc la recherche renvoie des résultats aléatoires. Changer de modèle demande de recalculer toute la collection.

La troisième est de choisir le plus grand modèle sans mesurer. Vous payez six fois et demie plus et vous augmentez les coûts de stockage, souvent sans différence de précision perceptible.

La quatrième est de sauter la troncature des dimensions sur une grande collection. Un index trois fois plus petit pour une perte d'environ un pour cent est généralement un bon échange.

La cinquième est d'optimiser le coût des embeddings au lieu du coût de génération des réponses. La première ligne est généralement des dizaines de fois plus petite que la seconde.

La sixième est de n'avoir aucun cache sur des archives mises à jour de façon incrémentale. Tout recalculer à chaque changement, c'est du coût et du temps jetés pour rien.

FAQ

Par quel modèle commencer ?

Le plus petit des deux modèles actuels. Pour la plupart des usages, l'écart de précision avec le plus grand est faible, alors que les coûts de stockage et de recherche croissent avec le nombre de dimensions. Ne passez au plus grand que lorsque vous aurez mesuré que le plus petit est insuffisant.

Combien cela coûte-t-il ?

Indexer cent mille fragments de cinq cents tokens coûte environ un dollar avec le plus petit modèle. Le mode batch divise cela par deux en échange de résultats sous un jour. C'est généralement la plus petite ligne du budget d'une application à base de modèle de langage.

Puis-je raccourcir un vecteur après coup ?

Oui, les modèles de cette famille acceptent un nombre de dimensions plus bas au moment de l'appel sans que le résultat perde son sens. Sur une grande collection, cela signifie un index trois fois plus petit pour une faible perte de précision qui vaut la peine d'être mesurée sur vos propres données.

Changer de modèle oblige-t-il à tout recalculer ?

Oui. Les vecteurs de modèles différents vivent dans des espaces différents et ne sont pas comparables, donc les mélanger dans un seul index produit des résultats aléatoires. Intégrez cela à la planification, car recalculer de grandes archives prend du temps.

Où doivent vivre les vecteurs obtenus ?

Dans une base de données vectorielle ou dans une extension d'une base relationnelle. Sur une petite collection, l'option décrite dans l'article sur pgvector suffit ; sur une plus grande, Qdrant ou Chroma méritent d'être envisagés.

Les modèles sont documentés sur le site d'OpenAI, et les tarifs figurent sur la page des prix.

À lire aussi