Aller au contenu

TechniquePratique5 min de lecture

Lab 2 : un pipeline RAG observé de bout en bout

Découper un pipeline RAG en cinq étapes instrumentées, trouver celle qui ralentit tout, transformer un score de fidélité en métrique et passer d'une trace lente à la métrique correspondante.

Pour : ingénieurs et SREPrérequis : Avoir réussi le lab 1 du parcours.

Durée : 1 h 30. Prérequis : lab 1 réussi, Qdrant accessible sur localhost:6333.

Un pipeline RAG fonctionne comme un documentaliste à qui l’on pose une question. Il commence par la reformuler pour savoir où chercher, va chercher quelques fiches dans ses rayons, les pose sur le bureau avec la question, rédige sa réponse, puis la relit. Si la réponse est fausse, il faut savoir à quel moment les choses ont mal tourné : la mauvaise fiche, trop peu de fiches ou une rédaction qui s’éloigne des fiches. Ce lab donne à chacune de ces étapes son propre span, pour que la trace raconte toute l’histoire.

L’embedding transforme la question en vecteur, une liste de nombres qui résume son sens. La récupération cherche dans Qdrant, la base vectorielle, les fragments de documents dont le vecteur est le plus proche ; top_k fixe combien on en garde. L’assemblage colle ces fragments et la question dans le prompt. La génération appelle le LLM. L’évaluation, enfin, note la réponse : sa fidélité au contexte (s’appuie-t-elle sur les fragments ?) et la présence d’hallucinations.

ÉtapeRôleSpanAttribut
Embeddingvectoriser la questionembeddings nomic-embed-textmttl.rag.stage = embedding
Récupérationchercher dans Qdrant (top_k)rag retrievalmttl.rag.stage = retrieval
Assemblageconcaténer contexte et questionrag prompt assemblymttl.rag.stage = prompt_assembly
Générationappeler le LLMchat mistral:7bmttl.rag.stage = generation
Évaluationfidélité, hallucinationrag evaluationmttl.rag.stage = evaluation

Les deux appels au modèle suivent le nommage de la convention GenAI (opération puis modèle) et alimentent gen_ai.client.operation.duration. Chaque étape alimente aussi l’histogramme mttl.rag.stage.duration, découpé par l’attribut d’étape : c’est lui que lit le tableau de bord RAG.

Fenêtre de terminal
cd app && python lab2_rag_pipeline.py

Au premier lancement, ensure_collection() crée la collection Qdrant et indexe sept documents. Les lancements suivants ne réindexent pas, sauf avec l’option --reindex : le lab 3 s’appuie sur ce comportement.

Dans Tempo, ouvrez une trace rag query :

rag query
├── embeddings nomic-embed-text ~150 ms
├── rag retrieval ~50 ms
├── rag prompt assembly ~5 ms
├── chat mistral:7b ~1500 ms
└── rag evaluation ~10 ms

Ces durées sont un exemple : sur un poste sans GPU, la génération peut prendre plusieurs secondes. Les mêmes spans placés sur une ligne de temps rendent la proportion visible :

gantt
  title Trace rag query, environ 1,7 s
  dateFormat x
  axisFormat %-S,%L s
  section Racine
  rag query          :q, 0, 1715ms
  section Étapes
  embedding          :e1, 0, 150ms
  retrieval          :e2, after e1, 50ms
  prompt assembly    :e3, after e2, 5ms
  generation         :e4, after e3, 1500ms
  evaluation         :e5, after e4, 10ms

Dans cet exemple, la génération représente 1 500 ms sur 1 715, soit environ 87 % du temps total. C’est attendu dans ce lab : générer 200 jetons coûte bien plus qu’une recherche dans sept documents. Ce n’est pas pour autant là que se cachent les problèmes de qualité. Pour reprendre l’image du documentaliste, c’est la récupération qui décide des fiches posées sur le bureau, donc de ce que le modèle a sous les yeux.

  1. --top-k 1 contre --top-k 5 : mesurez l’effet sur la latence de récupération et sur la fidélité.
  2. Cache d’embeddings : à vous d’ajouter un dictionnaire en mémoire dans rag_query, puis de mesurer le gain.
  3. --stream : la génération passe en flux et le temps au premier fragment remonte dans la métrique standard gen_ai.client.operation.time_to_first_chunk.

Notez chaque résultat. La première optimisation montre qu’un gain de latence peut coûter cher en qualité.

PanneauCe qu’on doit voir
Durée p95 par étapela génération domine, la récupération reste rapide
Débit par étapeconstant entre étapes, sans décrochage
Fidélité moyenneau-dessus de 0,6, le seuil commun à l’alerte qualité et au SLO du lab 4
Hallucinations détectées sur 1 hzéro idéalement ; enquêter dès la première

Le compteur d’hallucinations (mttl.hallucinations) repose sur une heuristique simple du kit : une réponse qui contient plus de deux nombres absents du contexte. C’est un signal grossier, à compléter par un juge, c’est-à-dire un modèle chargé de noter les réponses (module 4).

Augmentez la charge (python lab2_rag_pipeline.py --repeat 4) et repérez l’étape qui décroche la première.

Une trace raconte une requête ; une métrique résume toutes les autres. Passer de l’une à l’autre permet de savoir si un span lent est un cas isolé ou une tendance. Ce lien est préconfiguré dans la source Tempo (grafana/provisioning/datasources/datasources.yaml, bloc tracesToMetrics) : depuis un span lent, ouvrez la latence p95 ou la durée par étape du même service, filtre déjà appliqué. Ajoutez-y une requête, par exemple la fidélité moyenne du service.

NotionCe que le lab montre
Hiérarchieun span racine RAG, un span enfant par étape
Attribut d’étapepermet le découpage par étape sans double instrumentation
Évaluation en lignela fidélité du lab est un ratio de mots communs entre contexte et réponse, à compléter par un juge
Taillemoins de 1 Ko par attribut ; l’identifiant des fragments, pas leur contenu

Deux prolongements sont possibles. Le premier ajoute une étape de reclassement (bge-reranker), un modèle qui remet les fragments récupérés dans le bon ordre de pertinence, puis mesure le gain de fidélité. Le second exporte les paires question et réponse vers Phoenix pour une évaluation en lot.

Révisé le 2 octobre 2026 : encadré sur l’état du kit, recherche Qdrant migrée vers query_points, compteur mttl.hallucinations réellement émis, seuil de fidélité aligné sur 0,6, part de la génération recalculée (87 %).