Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

RAG avancé : Multi-Query, HyDE, Step-Back

Lektion 14 av 22 Uppdaterad 29 juli 2026 Utvecklare
På denna sida
  1. Objectifs
  2. Le problème : une seule requête ne suffit pas
  3. Multi-Query : poser la question autrement
  4. HyDE : embeddings de documents hypothétiques
  5. Prompting Step-Back
  6. Comparaison des techniques
  7. Combinaison des techniques
  8. Viktiga punkter

Objectifs

  • Améliorer la récupération grâce à des techniques avancées
  • Mettre en œuvre le multi-query, HyDE et le prompting step-back
  • Savoir quand utiliser chaque technique

Le problème : une seule requête ne suffit pas

Le reranking de la leçon précédente a amélioré le classement des candidats, mais il n’a pas pu aider pour les documents que la récupération n’a jamais fait remonter en premier lieu. La cause la plus fréquente de ces échecs 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 partagent un seul principe : au lieu d’accepter la requête telle quelle, nous la transformons ou la multiplions 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.

Multi-Query : poser la question autrement

La première approche est la plus directe. Nous demandons au LLM de reformuler la question sous plusieurs angles, d’exécuter une recherche avec chaque variante, puis de fusionner 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.

L’étape de fusion mérite une précision : 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 nous faisions la moyenne des scores. La température de 0,7 est ici intentionnelle, car nous cherchons la variété, pas 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, nous faisons générer au modèle une réponse plausible – même si elle est partiellement fausse, peu importe – puis nous recherchons les documents proches de cette réponse. La question « comment configurer le SSO ? » produit un paragraphe parlant de fournisseurs d’identité, de SAML et de métadonnées, 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 plus à 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 déplaçant la requête sur le terrain du corpus. C’est aussi pour cela que le prompt précise « comme s’il s’agissait d’un extrait de documentation technique » : nous imitons le registre cible.

Prompting Step-Back

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. Nous demandons donc au modèle la question générale qui se cache derrière la question spécifique, puis nous recherchons avec les deux, en les pondérant à 0,7 pour la question originale et 0,3 pour la plus large : 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 en appels supplémentaires, donc en latence accrue.

TechniqueQuand l’utiliserCoût supplémentaire
Multi-queryRequêtes ambiguës, vocabulaire varién appels d’embedding + 1 appel LLM
HyDEÉcart requête-document, domaines techniques1 appel LLM + 1 appel d’embedding
Step-backQuestions très spécifiques, besoin de contexte1 appel LLM + 2 appels d’embedding

Combinaison des 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 classé aux côtés d’un document trouvé par recherche directe. Garde toutefois à l’esprit que l’empilement de 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
    ]

Viktiga punkter

  • Le multi-query reformule 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
  • Le step-back pose une question plus générale pour capturer un contexte large
  • Ces techniques ajoutent de la latence mais améliorent significativement le rappel