RAG avancé : requêtes multiples, HyDE, étape en arrière
Sellel lehel
Objectifs
- Améliorer la récupération grâce à des techniques avancées
- Mettre en œuvre les requêtes multiples, HyDE et l’invite « étape en arrière » (step-back)
- Savoir quand utiliser chaque technique
Le problème : une seule requête ne suffit pas
Le reclassement vu dans la leçon précédente a amélioré le rang des candidats, mais il n’a rien pu faire pour les documents que la récupération n’a jamais fait remonter. La cause la plus fréquente de ces oublis n’est ni le modèle ni l’index, mais la requête elle-même. Un utilisateur peut taper « ça ne marche pas sur mon téléphone », tandis que la documentation parle d’« incompatibilité avec les versions Android antérieures à la 12 ». Aucun modèle d’embedding ne rapprochera spontanément ces deux formulations.
Les techniques suivantes reposent sur un même principe : au lieu d’accepter la requête telle quelle, on la transforme ou on la multiplie avant la recherche. Elles agissent toutes sur le rappel (recall), c’est-à-dire la capacité à faire entrer le bon document dans la liste des candidats.
Requêtes multiples : poser la question autrement
La première approche est la plus directe. On demande au LLM de reformuler la question sous plusieurs angles, on lance une recherche avec chaque variante, puis on fusionne les résultats. La question « comment annuler mon abonnement ? » devient aussi « procédure d’annulation », « arrêter le prélèvement mensuel » et « supprimer mon compte payant » : trois vocabulaires différents, trois chances de tomber sur la formulation choisie par l’auteur de la documentation.
Une précision sur l’étape de fusion : la ligne np.maximum conserve, pour chaque document, le meilleur score obtenu parmi toutes les requêtes. Un document qui correspond bien à une seule reformulation remonte ainsi en tête, ce qui n’arriverait pas si l’on faisait la moyenne des scores. La température de 0,7 est volontaire ici, car on cherche de la variété, pas de la reproductibilité.
from openai import OpenAI
import numpy as np
client = OpenAI()
def generer_multi_queries(question: str, n: int = 3) -> list[str]:
"""Generate n rephrasings of the question."""
response = client.chat.completions.create(
model="gpt-5.6-terra",
messages=[{
"role": "user",
"content": (
f"Generate {n} different rephrasings of this question "
f"for document search. Each rephrasing "
f"should cover a different angle.\n\n"
f"Original question: {question}\n\n"
f"Return only the rephrasings, one per line."
)
}],
temperature=0.7
)
queries = response.choices[0].message.content.strip().split("\n")
return [q.strip().lstrip("0123456789.-) ") for q in queries if q.strip()]
def recherche_multi_query(
question: str,
corpus_embeddings: np.ndarray,
documents: list[dict],
k: int = 5,
n_queries: int = 3
) -> list[dict]:
"""Search with multiple rephrasings."""
queries = [question] + generer_multi_queries(question, n_queries)
print(f"Queries: {queries}")
tous_scores = np.zeros(len(documents))
for query in queries:
query_emb = client.embeddings.create(
input=query, model="text-embedding-3-large"
).data[0].embedding
scores = corpus_embeddings @ np.array(query_emb)
tous_scores = np.maximum(tous_scores, scores)
top_k = np.argsort(tous_scores)[-k:][::-1]
return [
{**documents[i], "score": float(tous_scores[i])}
for i in top_k
]
HyDE : embeddings de documents hypothétiques
HyDE attaque le problème par l’autre bout. Au lieu de multiplier les questions, on fait générer au modèle une réponse plausible – même partiellement fausse, peu importe – puis on cherche les documents proches de cette réponse. La question « comment configurer le SSO ? » produit un paragraphe évoquant les fournisseurs d’identité, SAML et les métadonnées, soit exactement le vocabulaire présent dans la documentation réelle.
def recherche_hyde(
question: str,
corpus_embeddings: np.ndarray,
documents: list[dict],
k: int = 5
) -> list[dict]:
"""Search with a hypothetical document (HyDE)."""
# 1. Generate a hypothetical document
response = client.chat.completions.create(
model="gpt-5.6-terra",
messages=[{
"role": "user",
"content": (
f"Write a short paragraph (3-5 sentences) that would answer "
f"this question. Write as if it were an excerpt "
f"from technical documentation.\n\n"
f"Question: {question}"
)
}],
temperature=0.3
)
doc_hypothetique = response.choices[0].message.content
# 2. Encode the hypothetical document
hyde_emb = client.embeddings.create(
input=doc_hypothetique,
model="text-embedding-3-large"
).data[0].embedding
# 3. Search for similar documents
scores = corpus_embeddings @ np.array(hyde_emb)
top_k = np.argsort(scores)[-k:][::-1]
return [
{**documents[i], "score": float(scores[i])}
for i in top_k
]
Si cette technique fonctionne, c’est parce que l’embedding d’une réponse ressemble davantage à l’embedding d’un document que ne le fait l’embedding d’une question. Une question est courte, interrogative et souvent formulée avec les mots de l’utilisateur ; un document est long, affirmatif et rédigé dans le jargon du domaine. HyDE comble cet écart entre requête et document en ramenant la requête sur le terrain du corpus. C’est aussi pour cela que l’invite précise « comme s’il s’agissait d’un extrait de documentation technique » : on imite le registre cible.
Invite « étape en arrière » (Step-Back Prompting)
La troisième technique gère le cas opposé : des questions si spécifiques qu’aucun document ne les traite frontalement. « Puis-je déduire un vélo électrique acheté en février ? » n’apparaît nulle part, mais la section sur les charges professionnelles déductibles, si. On demande donc au modèle la question générale qui se cache derrière la question spécifique, puis on recherche avec les deux, en pondérant à 0,7 la question originale et à 0,3 la question élargie : le contexte large aide, mais il ne doit pas dominer.
def recherche_step_back(
question: str,
corpus_embeddings: np.ndarray,
documents: list[dict],
k: int = 5
) -> list[dict]:
"""Two-pass search: general then specific."""
# 1. Generate a step-back question
response = client.chat.completions.create(
model="gpt-5.6-terra",
messages=[{
"role": "user",
"content": (
f"What is the more general question or underlying concept "
f"behind this specific question?\n\n"
f"Specific question: {question}\n\n"
f"Return only the general question."
)
}],
temperature=0.3
)
question_generale = response.choices[0].message.content.strip()
# 2. Search with both questions
resultats_combines = {}
for q, poids in [(question, 0.7), (question_generale, 0.3)]:
q_emb = client.embeddings.create(
input=q, model="text-embedding-3-large"
).data[0].embedding
scores = corpus_embeddings @ np.array(q_emb)
for i, s in enumerate(scores):
if i not in resultats_combines:
resultats_combines[i] = 0.0
resultats_combines[i] += float(s) * poids
top_k = sorted(
resultats_combines.items(),
key=lambda x: x[1], reverse=True
)[:k]
return [
{**documents[idx], "score": score}
for idx, score in top_k
]
Comparaison des techniques
Chacune répond à une pathologie spécifique de la récupération, et chacune a un coût : des appels supplémentaires, donc une latence plus élevée.
| Technique | Quand l’utiliser | Coût supplémentaire |
|---|---|---|
| Requêtes multiples | Requêtes ambiguës, vocabulaire varié | n appels d’embedding + 1 appel LLM |
| HyDE | Écart requête-document, domaines techniques | 1 appel LLM + 1 appel d’embedding |
| Étape en arrière | Questions très spécifiques, besoin de contexte | 1 appel LLM + 2 appels d’embedding |
Combiner les techniques
Tu n’es pas obligé de n’en choisir qu’une. La fonction suivante accepte une liste de stratégies, accumule les scores produits par chacune dans un dictionnaire indexé par document, et conserve le maximum. Un document trouvé uniquement par HyDE se retrouve ainsi aux côtés d’un document trouvé par recherche directe. Garde toutefois en tête qu’empiler trois stratégies triple le budget et allonge le temps de réponse : réserve cette combinaison aux requêtes difficiles, ou au traitement hors ligne où la latence importe peu.
def recherche_avancee(
question: str,
corpus_embeddings: np.ndarray,
documents: list[dict],
k: int = 5,
strategies: list[str] = ["direct", "multi_query", "hyde"]
) -> list[dict]:
"""Combine multiple search strategies."""
tous_resultats = {}
if "direct" in strategies:
q_emb = client.embeddings.create(
input=question, model="text-embedding-3-large"
).data[0].embedding
scores = corpus_embeddings @ np.array(q_emb)
for i, s in enumerate(scores):
tous_resultats.setdefault(i, []).append(float(s))
if "hyde" in strategies:
res_hyde = recherche_hyde(
question, corpus_embeddings, documents, k=k*2
)
for r in res_hyde:
tous_resultats.setdefault(r["id"], []).append(r["score"])
# Final score = max of scores
scores_finaux = {
idx: max(scores) for idx, scores in tous_resultats.items()
}
top_k = sorted(
scores_finaux.items(), key=lambda x: x[1], reverse=True
)[:k]
return [
{**documents[idx], "score": score}
for idx, score in top_k
]
Peamised punktid
- Les requêtes multiples reformulent la question sous plusieurs angles pour couvrir plus de vocabulaire
- HyDE génère une réponse hypothétique qui ressemble davantage aux documents cibles
- L’invite « étape en arrière » pose une question plus générale pour capturer un contexte large
- Ces techniques ajoutent de la latence, mais améliorent significativement le rappel