Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

RAG geavanceerd: Multi-Query, HyDE, Step-Back

Les 14 van 22 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Doelstellingen
  2. Het probleem: één query volstaat niet
  3. Multi-Query: stel de vraag anders
  4. HyDE: Hypothetical Document Embeddings
  5. Step-Back Prompting
  6. De technieken vergelijken
  7. Technieken combineren
  8. Belangrijkste punten

Doelstellingen

  • De ophaalkwaliteit verbeteren met geavanceerde technieken
  • Multi-query, HyDE en step-back prompting implementeren
  • Weten wanneer u welke techniek inzet

Het probleem: één query volstaat niet

De herordening uit de vorige les verbeterde hoe kandidaten werden gerangschikt, maar kon niets doen aan documenten die de ophaalfase nooit heeft teruggevonden. De meest voorkomende oorzaak van deze misses is niet het model of de index, maar de query zelf. Een gebruiker typt misschien “het werkt niet op mijn telefoon”, terwijl de documentatie spreekt over “incompatibiliteit met Android-versies ouder dan 12”. Geen enkel embedding-model brengt deze twee formuleringen spontaan dichter bij elkaar.

De volgende technieken delen één principe: in plaats van de query als zodanig te accepteren, transformeren of vermenigvuldigen we deze voordat we zoeken. Ze werken allemaal op recall: het vermogen om het juiste document in de kandidatenlijst te krijgen.

Multi-Query: stel de vraag anders

De eerste aanpak is het meest direct. We vragen de LLM om de vraag vanuit meerdere hoeken te herformuleren, voeren voor elke variant een zoekopdracht uit en voegen de resultaten samen. De vraag “hoe zeg ik mijn abonnement op?” wordt dan ook “opzegprocedure”, “stop de maandelijkse afschrijving” en “verwijder mijn betaalde account”—drie verschillende vocabulaires, drie kansen om de formulering van de documentatieauteur te raken.

De samenvoegstap verdient aandacht: de regel np.maximum houdt voor elk document de beste score die over alle queries heen is behaald. Een document dat bij slechts één herformulering goed matcht, stijgt toch naar boven; dat zou niet gebeuren als we de scores middelden. De temperatuur van 0,7 is hier bewust gekozen, omdat we variatie willen, niet reproduceerbaarheid.

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: Hypothetical Document Embeddings

HyDE pakt het probleem aan vanaf de andere kant. In plaats van vragen te vermenigvuldigen, laten we het model een plausibel antwoord genereren—zelfs als dat deels onjuist is, maakt dat niet uit—en zoeken we vervolgens naar documenten die dicht bij dat antwoord liggen. De vraag “hoe configureer ik SSO?” levert een alinea op over identity providers, SAML en metadata, precies het vocabulaire dat in de echte documentatie voorkomt.

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
    ]

Als deze techniek werkt, komt dat doordat de embedding van een antwoord meer lijkt op de embedding van een document dan de embedding van een vraag dat doet. Een vraag is kort, vragend en vaak in eigen woorden geformuleerd; een document is lang, bevestigend en geschreven in vakjargon. HyDE overbrugt deze kloof tussen query en document door de query naar het terrein van de corpus te verplaatsen. Daarom specificeert de prompt ook “as if it were an excerpt from technical documentation”: we bootsen het beoogde register na.

Step-Back Prompting

De derde techniek behandelt het tegenovergestelde geval: vragen die zo specifiek zijn dat geen enkel document ze rechtstreeks beantwoordt. “Kan ik een in februari gekochte elektrische fiets aftrekken?” komt nergens voor, maar de sectie over aftrekbare bedrijfskosten wel. We vragen het model daarom naar de algemene vraag die achter de specifieke vraag schuilgaat, en zoeken vervolgens met beide, met een weging van 0,7 voor de originele vraag en 0,3 voor de bredere vraag—de brede context helpt, maar mag niet domineren.

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
    ]

De technieken vergelijken

Elke techniek pakt een specifieke pathologie in de ophaalfase aan, en elke techniek heeft extra calls en dus hogere latentie als prijs.

TechniekWanneer inzettenExtra kosten
Multi-queryAmbiguïteit in queries, gevarieerd vocabulairen embedding-calls + 1 LLM-call
HyDEKloof tussen query en document, technische domeinen1 LLM-call + 1 embedding-call
Step-backZeer specifieke vragen, behoefte aan context1 LLM-call + 2 embedding-calls

Technieken combineren

U hoeft niet voor slechts één techniek te kiezen. De volgende functie accepteert een lijst met strategieën, accumuleert de scores die elke strategie produceert in een dictionary geïndexeerd op document, en houdt het maximum aan. Een document dat alleen door HyDE wordt gevonden, staat zo naast een document dat via direct zoeken naar boven komt. Houd er wel rekening mee dat het stapelen van drie strategieën het budget verdrievoudigt en de responstijd verlengt: reserveer deze combinatie voor moeilijke queries, of voor offline verwerking waar latentie niet uitmaakt.

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
    ]

Belangrijkste punten

  • Multi-query herformuleert de vraag vanuit meerdere hoeken om meer vocabulaire te dekken
  • HyDE genereert een hypothetisch antwoord dat meer lijkt op de beoogde documenten
  • Step-back stelt een allgemeinere vraag om brede context vast te leggen
  • Deze technieken voegen latentie toe, maar verbeteren de recall aanzienlijk