Embeddings de texte

Après avoir découpé un document en chunks, l’étape suivante du pipeline RAG est de trouver quels chunks sont les plus pertinents pour la question de l’utilisateur. C’est fondamentalement un problème de recherche — et la recherche par mots-clés ne suffit pas : l’utilisateur demande « quels problèmes l’entreprise a-t-elle rencontrés ? » quand le document parle de « défis opérationnels ». Il faut comprendre le sens et le contexte, pas compter des correspondances. L’outil qui rend cela possible s’appelle l’embedding.

Qu’est-ce qu’un embedding de texte ?

Un embedding de texte est une représentation numérique du sens contenu dans un texte — une conversion de mots et de phrases en un format que les ordinateurs peuvent manipuler mathématiquement.

Le processus :

1. Vous alimentez un modèle d’embedding avec du texte
2. Le modèle produit une longue liste de nombres (typiquement 1024 nombres)
3. Chaque nombre représente un « score » pour une qualité du texte d’entrée
4. Les nombres vont de -1 à +1

Le point décisif est la propriété géométrique qui en résulte : deux textes de sens voisin produisent des listes de nombres voisines. Le sens devient une position dans un espace mathématique — et « parler de la même chose » devient une distance qu’on peut calculer.

Comprendre les nombres

Chaque nombre dans un embedding est un score pour un aspect du texte — mais nous ne savons pas exactement ce que chaque position représente : le modèle d’embedding apprend ces patterns pendant l’entraînement, et ils ne sont pas interprétables par l’humain. Ce n’est pas gênant en pratique : on ne lit jamais un embedding, on le compare à d’autres. Seules les distances comptent, jamais les valeurs individuelles.

Générer des embeddings avec du code

Claude ne produit pas d’embeddings — c’est un modèle de conversation. Sur Bedrock, on utilise un modèle dédié du catalogue : Titan Text Embeddings d’Amazon.

def generate_embedding(
    text,
    embedding_model_id="amazon.titan-embed-text-v2:0",
    dimensions=1024,
    normalize=True,
):
    request_body = {
        "inputText": text,
        "dimensions": dimensions,
        "normalize": normalize,
    }

    request_json = json.dumps(request_body)
    response = client.invoke_model(
        modelId=embedding_model_id,
        body=request_json,
        accept="application/json",
        contentType="application/json",
    )

    response_body = json.loads(response.get("body").read())
    return response_body["embedding"]

Quelques lectures utiles de ce code. L’appel passe par invoke_model, l’API bas niveau de Bedrock — Titan n’étant pas un modèle de conversation, l’API converse ne s’applique pas ; on sérialise soi-même la requête JSON et on parse la réponse. Le paramètre dimensions fixe la taille du vecteur (1024 ici), et normalize=True demande des vecteurs de longueur 1 — un prérequis pour que la comparaison par similarité cosinus, qui arrive à la prochaine leçon, fonctionne proprement. Dernier point logistique : vous devrez peut-être demander l’accès au modèle d’embedding Titan dans la console AWS Bedrock, comme vous l’aviez fait pour Claude.

Pourquoi les embeddings comptent pour le RAG

Des textes similaires auront des valeurs d’embedding similaires. Vous pouvez donc comparer mathématiquement la question d’un utilisateur à vos chunks de documents et trouver les plus sémantiquement proches, même s’ils ne partagent pas les mêmes mots exacts — la question sur les « problèmes » retrouvera le chunk des « défis opérationnels », parce que leurs vecteurs se ressemblent.

Cette représentation numérique est ce qui rend la recherche sémantique possible et bien plus efficace que la simple correspondance de mots-clés. Il ne manque plus qu’une règle du jeu : comment mesurer précisément que deux vecteurs sont « proches » ? C’est l’objet de la prochaine leçon.

Points clés à retenir

• Un embedding convertit un texte en vecteur de ~1024 nombres : le sens devient une position comparable
• Les positions individuelles ne s’interprètent pas — seules les distances entre vecteurs comptent
• Sur Bedrock : modèle Titan (amazon.titan-embed-text-v2:0) via invoke_model, accès à activer dans la console
• normalize=True prépare les vecteurs pour la similarité cosinus de la prochaine leçon
• La comparaison de vecteurs retrouve le sens sans correspondance de mots — le cœur de la recherche sémantique