Pourquoi RAG donne encore des réponses incorrectes : recherche hybride, réclassification et Recall@K
Des fragments propres ne garantissent pas des réponses de qualité. Voyez où l’extraction de vecteurs échoue et comment la fusion, un réclassificateur à codeur croisé, HyDE et la mesure Recall@K y remédient.
Sources: The AI Series: The Hardest Part of RAG, Part 2 — Why Perfect Chunks Still Give You Bad Retrieval
Un schéma courant dans les projets RAG : le travail de parsing est terminé. Les fragments sont propres, les tableaux sont générés au format Markdown, et chaque fragment porte un numéro de page ainsi qu’un titre de section. Pourtant, les utilisateurs en environnement de production reçoivent encore des réponses incorrectes aux questions que le système devrait pouvoir traiter facilement. Les fragments ne sont pas le problème ; le système de récupération continue simplement de sélectionner les mauvais.
Un bon parsing produit de bons données, mais de bonnes données ne garantissent pas une bonne récupération. Il s’agit de problèmes distincts, et le second reçoit bien moins d’attention qu’il ne le mérite.
Ce que fait réellement la recherche de similarité
De nombreuses équipes traitent similarity_search() comme une boîte noire, il est donc utile de jeter un coup d’œil à son fonctionnement. Un modèle d’embedding convertit du texte en une liste de nombres, un vecteur, qui représente un point dans un espace ayant entre 384 et 3072 dimensions selon le modèle. Les textes ayant un sens similaire devraient se trouver proches les uns des autres, tandis que les textes sans rapport se trouveront éloignés.
Une version simplifiée à seulement 4 dimensions permet de garder les nombres lisibles :
"How do I reset my password?" → [0.81, 0.12, -0.44, 0.09]
"Steps to change your password" → [0.79, 0.15, -0.41, 0.11]
"How do I cancel my subscription?"→ [0.22, 0.68, 0.05, -0.39]
Deux vecteurs sont comparés à l’aide de la similarité cosinus, qui mesure dans quelle mesure ils pointent dans la même direction en ignorant leur longueur. Une note de 1,0 indique une direction identique, 0 signifie qu’ils ne sont pas liés, et les valeurs négatives indiquent des directions opposées.
from numpy import dot
from numpy.linalg import norm
def cosine_similarity(a, b):
return dot(a, b) / (norm(a) * norm(b))
query = [0.80, 0.13, -0.42, 0.10] # "reset my password"
print(cosine_similarity(query, [0.81, 0.12, -0.44, 0.09])) # 0.998 - very close
print(cosine_similarity(query, [0.22, 0.68, 0.05, -0.39])) # 0.310 - far apart
Derrière l’expression « L’IA comprend la question », il n’y a rien de plus que cela. Il s’agit de géométrie plutôt que de compréhension, et c’est la géométrie qui explique les échecs : elle ne peut pas percevoir que « interdit » inverse le sens de « autorisé », ni que « Erreur 4092 » est une chaîne de caractères littérale que l’utilisateur doit faire correspondre.
Quatre manières dont la récupération échoue
Réduire un paragraphe à un seul point entraîne la perte d’informations. Dès que le système quitte le mode démonstration, ces mêmes quatre échecs continuent d’apparaître.
- Désaccord lexical. Quelqu’un cherche un code d’erreur ou un ID de produit exact, l’embedding le traite comme un token ordinaire, et le groupe contenant cette chaîne précise ne figure pas parmi les 10 meilleurs résultats.
- Ignorance de la négation. Une politique stipulant que les remboursements s’arrêtent après un mois et une question concernant un remboursement après ce délai partagent la plupart de leur vocabulaire, ce qui peut les rapprocher de manière préoccupante bien que leurs significations soient contradictoires.
- Isolation des blocs. La réponse se situe entre deux blocs : un nombre dans l’un et l’étiquette l’expliquant dans l’autre, et le système de récupération ne renvoie qu’un d’eux.
- Confusion liée à la proximité dans le temps. Un index vectoriel ne perçoit pas que un document est obsolète, de sorte que les versions anciennes et nouvelles d’une même politique sont souvent jugées également pertinentes.
Une démonstration avec 20 documents ne met en évidence aucun de ces problèmes. Ceux-ci apparaissent uniquement lorsque le corpus contient de véritables doublons, chevauchements et ambiguïtés, ce qui caractérise tous les systèmes de production.
Un pipeline plutôt qu’une seule requête
Une seule requête vers un stock de vecteurs ne constitue pas un système de récupération. Un système fiable comporte plusieurs étapes :
Chaque étape existe parce que la précédente ne suffit pas à elle seule. C’est là le changement de perspective majeur entre une démonstration RAG et une implémentation RAG en production : chaque étape corrige une faiblesse spécifique à un niveau antérieur, et aucune n’est purement décorative.
Recherche hybride avec fusion des classements
La recherche vectorielle gère mal les correspondances exactes, tandis que la recherche par mots-clés (BM25) gère mal les correspondances conceptuelles. Plutôt que de choisir l’une ou l’autre, il faut les exécuter toutes les deux puis fusionner les résultats.
La fusion des classements réciproques est le moyen le plus simple de combiner deux listes classées lorsque leurs scores ne sont pas sur une même échelle. Une implémentation typique se présente comme ceci :
from collections import defaultdict
def reciprocal_rank_fusion(result_lists, k=60):
scores = defaultdict(float)
for result_list in result_lists:
for rank, doc_id in enumerate(result_list):
scores[doc_id] += 1 / (k + rank + 1)
return sorted(scores, key=scores.get, reverse=True)
vector_ids = [d.metadata["chunk_id"] for d in vector_store.similarity_search(query, k=20)]
bm25_ids = [d.metadata["chunk_id"] for d in bm25_index.search(query, k=20)]
final_ranking = reciprocal_rank_fusion([vector_ids, bm25_ids])
Une erreur fréquente au début est de concaténer les deux listes de résultats sans les fusionner. La liste qui apparaît en premier domine silencieusement le contexte final, ce qui annule l’intérêt d’utiliser deux stratégies.
Réclassement
La phase la plus difficile du traitement du texte est l’extraction des tableaux, tandis que celle du système de recherche est le réclassement. Les modèles d’incorporation encodent indépendamment une requête et chaque document, avant de comparer les résultats par la suite. Un outil de réclassement, généralement un encodage croisé, lit conjointement la requête et les fragments de documents candidats pour produire directement un score de pertinence. Cela prend plus de temps, c’est pourquoi il n’est utilisé que sur les 20 à 50 meilleurs candidats après fusion, et jamais sur l’ensemble de l’index.
from sentence_transformers import CrossEncoder
reranker = CrossEncoder("BAAI/bge-reranker-base")
def rerank(query, candidates, top_n=5):
pairs = [(query, c["text"]) for c in candidates]
scores = reranker.predict(pairs)
for c, s in zip(candidates, scores):
c["rerank_score"] = float(s)
return sorted(candidates, key=lambda c: c["rerank_score"], reverse=True)[:top_n]
Dans un système interne de recherche de support, un réclassificateur ajouté après la fusion a permis d’augmenter le taux de rappel à 5 points de près de 61 % à 84 %, sans modifier le modèle d’incorporation ni la taille des blocs de texte. Ce seul changement a eu un impact supérieur à celui du reste du processus combiné, ce qui en fait la première suggestion habituelle lorsque les réponses RAG semblent proches mais pas tout à fait correctes.
Compléter l’écart de vocabulaire
Parfois, l’index est en bon état et le véritable problème réside dans le choix des mots. Les utilisateurs écrivent de manière informelle (“Pourquoi ne me laisse-t-il pas me connecter ?”) tandis que la documentation est formelle (“Des erreurs d’authentification peuvent survenir lorsque les tokens de session expirent”).
Deux techniques permettent de le résoudre. La réécriture de la requête consiste pour un LLM à reformuler une question vague de manière plus proche de la formulation du matériel source. HyDE (Hypothetical Document Embeddings) va encore plus loin : l’LLM rédige une courte réponse imaginaire, et c’est ce texte, et non la question brute, qui est intégré et recherché, car une réponse plausible se trouve bien plus près des réponses réelles dans l’espace vectoriel que la question elle-même.
def hyde_retrieve(query, llm, vector_store, k=5):
hypothetical = llm.invoke(f"Write a short passage answering: {query}")
return vector_store.similarity_search(hypothetical, k=k)
Un système de tickets de support qui a adopté cette approche a pu récupérer une part significative des requêtes qui n’avaient rien donné d’utile, simplement parce que les utilisateurs et la documentation emploient des dialectes différents.
Évaluer directement la récupération
Une solution rapide et tentante consiste à juger de la récupération en se basant sur le fait que la réponse finale du LLM semble correcte. Cela ne révèle presque rien sur l’étape qui a échoué.
Il faut disposer d’un petit ensemble étiqueté, même 50 à 100 paires de requête et de fragment correct, afin de pouvoir mesurer le Recall@K avant que le LLM ne soit impliqué. Le Recall@K demande : parmi les fragments qui contiennent réellement la réponse, combien se trouvent parmi les K meilleurs ?
def recall_at_k(retrieved_ids, relevant_ids, k):
top_k = set(retrieved_ids[:k])
return len(top_k & relevant_ids) / len(relevant_ids) if relevant_ids else 0.0
Sans cela, chaque modification de la taille des blocs, du modèle d’incorporation ou du reranker n’est qu’une supposition déguisée en amélioration.
Pièges et stack judicieux
Augmenter la valeur de k ne corrige que rarement une récupération insuffisante, car cela fournit principalement au LLM davantage de distractions. Consacrer la première semaine à l’ajustement de la taille des blocs n’apporte pas non plus beaucoup de valeur par rapport aux progrès réalisés grâce à un reranker. Enfin, construisez l’ensemble d’évaluation avant même que les plaintes n’arrivent, car diagnostiquer un problème de récupération ultérieurement entraîne la perte d’un entire sprint.
Un stack raisonnable pour développer cette couche depuis zéro : Qdrant pour la recherche vectorielle, BM25 via OpenSearch combiné à RRF, un reranker BGE auto-hébergé avec Cohere Rerank en solution de secours hébergée, et HyDE réservé au trafic de requêtes conversationnelles.
D’où provient réellement la qualité des réponses
Les débats portent généralement sur lequel LLM produit la réponse finale la plus fluide, mais le véritable facteur déterminant se trouve en amont du modèle : les bons fragments ont-ils été récupérés ? Un modèle brillant, confronté à un contexte incorrect, produit à chaque fois une réponse brillante, convaincante, mais fausse.
Le parsing introduit les données dans le système, tandis que la récupération détermine si la partie appropriée de ces données parvient au modèle. Lorsque l’un ou l’autre échoue, l’ingénierie des prompts ultérieure ne peut pas sauver la réponse. Une fois une récupération fiable en place, la question suivante est de savoir comment vérifier automatiquement, de bout en bout, que le système raisonne correctement sur ce qu’il a obtenu, plutôt que d’examiner les résultats un par un.
Lectures complémentaires
- RAG en temps de requête avec dix millions de documents : entonnoirs de récupération, routeurs, agents et évaluations — Un entonnoir de récupération en moins de 200 ms grâce à des filtres SQL, une recherche hybride et un réclassement, ainsi qu’à un routage des requêtes, une orchestration par agents, des métriques d’évaluation et un script de pipeline Qdrant.
- Recette Spring AI : filtrage des résultats RAG avec des métadonnées par titre de jeu — Une démarche pas à pas avec Spring AI qui met des étiquettes sur les documents en fonction de leur titre, utilise un LLM pour sélectionner la bonne valeur parmi les questions, puis filtre la recherche vectorielle en fonction de celle-ci.