Les embeddings de texte

Une fois le document découpé, il faut trouver les morceaux pertinents pour une question. C’est un problème de recherche, et la méthode la plus courante en RAG est la recherche sémantique : elle compare le sens de la question et celui de chaque morceau, plutôt que leurs mots. Elle repose sur les embeddings.

Qu’est-ce qu’un embedding ?

Un embedding est une représentation numérique du sens d’un texte. On envoie un texte à un modèle d’embedding, qui renvoie une longue liste de nombres : un vecteur, de 3 072 nombres par défaut pour le modèle gemini-embedding-001 de Google.

On peut imaginer que chaque nombre note une qualité du texte : « à quel point il est joyeux », « à quel point il parle d’océans ». Ce n’est qu’une image. Le sens de chaque dimension est appris par le modèle pendant son entraînement, et il n’est pas interprétable par un humain. Ce qui compte, c’est que des textes de sens proche reçoivent des vecteurs proches.

D’après la documentation de Google, les vecteurs sont normalisés : la similarité cosinus, le produit scalaire et la distance euclidienne donnent alors le même classement. La leçon suivante utilise la similarité cosinus.

Un modèle d’embedding sur Google Cloud

Claude ne produit pas d’embeddings. Sur Google Cloud, c’est Agent Platform qui les fournit, avec ses propres modèles, appelés avec les mêmes identifiants Google Cloud que Claude. Au 5 novembre 2026, la documentation de Google présente ces modèles de texte :

Le cours officiel utilise text-embedding-005. Ce modèle ne traite que l’anglais : pour des documents en français, ce cours prend gemini-embedding-001.

Installer le SDK de Google

Les embeddings passent par le SDK Google Gen AI. Sa version actuelle, 2.34.0 au 5 novembre 2026, demande Python 3.11 ou plus :

pip install -U google-genai

Aucune clé à créer : le SDK lit les identifiants par défaut (ADC) configurés à la leçon 2, comme le client AnthropicVertex.

Générer des embeddings

from google import genai
from google.genai.types import EmbedContentConfig

genai_client = genai.Client(enterprise=True, project="votre-projet", location="global")

TASK_TYPES = {"query": "RETRIEVAL_QUERY", "document": "RETRIEVAL_DOCUMENT"}

def generate_embedding(texts, model="gemini-embedding-001", input_type="query"):
    single = isinstance(texts, str)
    vectors = []
    for text in ([texts] if single else texts):
        response = genai_client.models.embed_content(
            model=model,
            contents=text,
            config=EmbedContentConfig(task_type=TASK_TYPES[input_type]),
        )
        vectors.append(response.embeddings[0].values)
    return vectors[0] if single else vectors

Trois détails comptent.

• enterprise=True fait passer le client par les points de terminaison d’Agent Platform, avec vos identifiants Google Cloud, plutôt que par l’API Gemini Developer et sa clé API. Le cours officiel écrit vertexai=True, l’ancien nom de ce réglage, que le SDK accepte encore.
• Un texte par requête. La fonction accepte un texte seul ou une liste, mais elle envoie les textes un par un : la référence de l’API de Google limite gemini-embedding-001 à un texte par requête.
• Le type de tâche. Google optimise les vecteurs selon l’usage annoncé : RETRIEVAL_DOCUMENT pour les morceaux que l’on indexe, RETRIEVAL_QUERY pour la question de l’utilisateur. Le paramètre input_type de la fonction choisit l’un ou l’autre. Le cours officiel ne précise pas de type ; nous distinguons les deux.

chunk_vectors = generate_embedding(chunks, input_type="document")
question_vector = generate_embedding("Qu'a fait l'équipe logicielle cette année ?", input_type="query")
len(question_vector)   # 3072

Deux réglages restent disponibles dans EmbedContentConfig. output_dimensionality réduit la taille des vecteurs, au prix d’un peu de qualité. auto_truncate=False fait échouer la requête quand un texte dépasse 2 048 tokens, au lieu de le tronquer sans prévenir : utile pour vérifier que votre découpage produit des morceaux assez courts.

À vous de jouer

Mesurer des proximités. Vectorisez cinq phrases : deux sur le même sujet avec des mots différents, deux qui partagent un mot ambigu (« bug », « virus ») dans des sens différents, et une sans rapport. Calculez le produit scalaire de chaque paire avec sum(x * y for x, y in zip(a, b)) et vérifiez que les paires de même sens sont les plus proches.

Sources officielles : Text embeddings (Claude Academy) · Get text embeddings (Google Cloud : modèles, limites, normalisation, SDK) · Choose an embeddings task type (Google Cloud : types de tâche)

Points clés à retenir

• Un embedding est un vecteur qui représente le sens d’un texte ; ses dimensions ne sont pas interprétables une à une.
• Claude ne produit pas d’embeddings : sur Google Cloud, Agent Platform les fournit, avec les mêmes identifiants.
• Pour du français, gemini-embedding-001, multilingue ; le text-embedding-005 du cours officiel ne traite que l’anglais.
• Un texte par requête, et un type de tâche : RETRIEVAL_DOCUMENT pour les morceaux, RETRIEVAL_QUERY pour les questions.
• Les vecteurs sont normalisés : cosinus, produit scalaire et distance euclidienne classent de la même façon.