Le flux RAG complet

Maintenant que nous avons couvert les bases du RAG, le découpage de texte et les embeddings, parcourons le pipeline complet étape par étape — sur un exemple miniature qui rend chaque étape tangible. Six étapes, dont trois appartiennent au prétraitement (exécuté une fois) et trois au traitement des questions (exécuté à chaque interaction) : cette frontière structure tout le système.

Étape 1 : Découper le texte source

Prenez votre document source et découpez-le en chunks gérables — pour notre exemple, un rapport d’entreprise à deux sections : Recherche médicale et Ingénierie logicielle. Deux chunks suffisent à la démonstration ; le vrai pipeline en produira des centaines, selon la stratégie de découpage choisie.

Étape 2 : Générer les embeddings

Convertissez chaque chunk en embeddings numériques. Pour illustrer le concept avec un modèle imaginaire à deux nombres seulement — une dimension « médical », une dimension « logiciel » :

• Section recherche médicale : [0.97, 0.34] — très médical, un peu logiciel à cause du mot « bug »
• Section ingénierie logicielle : [0.30, 0.97] — très logiciel, mais « vecteurs d’infection » a des connotations médicales

Ce petit exemple illustre une vérité qui vaut en 1024 dimensions : les scores ne sont jamais « purs ». Le vocabulaire ambigu — un « bug » informatique, des « vecteurs d’infection » système — tire chaque embedding vers l’autre dimension. L’embedding capture tout ce qu’un texte évoque, pas une étiquette unique.

Normalisation

Avant le stockage, les embeddings sont normalisés pour avoir une magnitude de 1.0 — c’est généralement fait automatiquement par l’API, et c’était le sens du paramètre normalize=True de notre fonction Titan. Après normalisation : [0.944, 0.331] et [0.295, 0.955]. L’intérêt : tous les vecteurs ramenés à la même longueur, seule leur direction les distingue — précisément ce que la similarité cosinus mesurera.

Étape 3 : Stocker dans une base vectorielle

Les embeddings normalisés sont stockés dans une base de données vectorielle, spécialisée pour stocker, comparer et rechercher des listes de nombres — vite, même parmi des millions. À ce stade, le prétraitement est terminé : on attend qu’un utilisateur soumette une requête. Tout ce qui précède ne se refera plus, quel que soit le nombre de questions posées.

Étape 4 : Traiter la requête utilisateur

Quand un utilisateur pose une question, passez-la dans le même modèle d’embedding — même modèle, c’est la règle absolue, sans quoi question et chunks vivraient dans des espaces incompatibles. Par exemple, « Qu’a fait le département d’ingénierie logicielle cette année ? » produit [0.1, 0.89] : score médical bas, score logiciel haut — la question s’est placée, dans l’espace sémantique, tout près de la section qui l’intéresse.

Étape 5 : Trouver les embeddings similaires

La base vectorielle utilise la similarité cosinus pour déterminer quels embeddings sont les plus proches. Points clés :

• Résultats entre -1 et 1
• Proche de 1 = très similaire
• Proche de 0 = sans rapport
• Proche de -1 = complètement opposé

La formule utilise le produit scalaire : cos(a) = (A . B) / (||A|| x ||B||) — c’est le cosinus de l’angle entre les deux vecteurs, d’où son nom : elle ne compare que les directions, ce que la normalisation avait préparé. En pratique, les bases vectorielles utilisent souvent la distance cosinus (1 - similarité cosinus) : les valeurs proches de 0 indiquent alors une forte similarité. Notre question [0.1, 0.89] élit sans ambiguïté la section logicielle [0.295, 0.955].

Étape 6 : Construire le prompt final

Prenez la question de l’utilisateur et le chunk le plus pertinent, combinez-les dans un prompt pour Claude — la question, l’extrait balisé comme contexte, et une consigne de répondre à partir du document. Claude répond alors depuis le texte fourni, pas depuis sa mémoire d’entraînement : c’est la promesse du RAG, tenue de bout en bout.

Résumé du pipeline complet

1. Découper les documents sources
2. Générer les embeddings pour chaque chunk
3. Stocker les embeddings dans une base vectorielle
4. Quand un utilisateur pose une question, générer l’embedding de sa requête
5. Trouver les embeddings stockés les plus similaires via la similarité cosinus
6. Ajouter les chunks pertinents au prompt avec la question de l’utilisateur
7. Envoyer le prompt enrichi à Claude pour une réponse

Les étapes 1-3 se paient une fois ; les étapes 4-7 se rejouent à chaque question, sur un index déjà prêt. La prochaine leçon transforme ce déroulé en code exécutable.

Points clés à retenir

• Prétraitement (découper, vectoriser, stocker) une fois ; question, recherche et prompt à chaque interaction
• Les embeddings capturent tout ce qu’un texte évoque — le vocabulaire ambigu teinte les scores
• Normalisation à 1.0 : seules les directions comptent, ce que mesure exactement la similarité cosinus
• Même modèle d’embedding pour chunks et questions — sinon les distances n’ont aucun sens
• Distance cosinus proche de 0 = très proche ; le chunk élu rejoint le prompt final avec la question