RAG geavanceerd: Multi-Query, HyDE, Step-Back
Op deze pagina
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.
| Techniek | Wanneer inzetten | Extra kosten |
|---|---|---|
| Multi-query | Ambiguïteit in queries, gevarieerd vocabulaire | n embedding-calls + 1 LLM-call |
| HyDE | Kloof tussen query en document, technische domeinen | 1 LLM-call + 1 embedding-call |
| Step-back | Zeer specifieke vragen, behoefte aan context | 1 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