Pokročilé RAG: Multi-Query, HyDE, Step-Back
Na této stránce
Cíle
- Zlepšit vyhledávání pomocí pokročilých technik
- Implementovat promptingové strategie multi-query, HyDE a step-back
- Vědět, kdy kterou techniku použít
Problém: Jeden dotaz nestačí
Přeřazení (reranking) z předchozí lekce sice vylepšilo pořadí kandidátů, ale nepomohlo s dokumenty, které se ve vyhledávání vůbec neobjevily. Nejčastější příčinou těchto výpadků není model ani index – je to samotný dotaz. Uživatel může napsat „na mém telefonu to nefunguje“, zatímco dokumentace hovoří o „nekompatibilitě s verzemi Androidu staršími než 12“. Žádný embeddingový model tyto dvě formulace spontánně nepřiblíží.
Následující techniky sdílejí jediný princip: místo aby přijaly dotaz tak, jak je, před vyhledáním jej transformují nebo rozmnoží. Všechny působí na úplnost (recall), tedy na schopnost dostat správný dokument do seznamu kandidátů.
Multi-Query: Polož otázku jinak
První přístup je nejpřímější. Požádáme LLM, aby otázku přeformulovalo z několika úhlů, s každou variantou provedeme vyhledávání a výsledky sloučíme. Otázka „jak zruším předplatné?“ se tak změní na „postup zrušení“, „zastavení měsíčního účtování“ a „smazání placeného účtu“ – tři různé slovníky, tři šance trefit formulaci, kterou použil autor dokumentace.
Slučování si zaslouží poznámku: řádek s np.maximum pro každý dokument zachová nejlepší skóre dosažené napříč všemi dotazy. Dokument, který dobře odpovídá jen jedné přeformulaci, se tak dostane nahoru, což by se při průměrování skóre nestalo. Teplota 0,7 je zde záměrná, protože chceme rozmanitost, nikoli reprodukovatelnost.
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: Hypotetické embeddingy dokumentů
HyDE řeší problém z opačného konce. Místo násobení otázek necháme model vygenerovat pravděpodobnou odpověď – i když je částečně špatná, nevadí – a poté vyhledáme dokumenty blízké této odpovědi. Otázka „jak nakonfigurovat SSO?“ tak vytvoří odstavec o poskytovatelích identity, SAML a metadatech, což je přesně slovník nalezený ve skutečné dokumentaci.
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
]
Pokud tato technika funguje, je to proto, že embedding odpovědi se více podobá embeddingu dokumentu než embedding otázky. Otázka je krátká, tázací a často formulovaná vlastními slovy uživatele; dokument je dlouhý, oznamovací a psaný odborným žargonem. HyDE překonává tuto propast mezi dotazem a dokumentem tím, že přesune dotaz na půdu korpusu. Proto také prompt specifikuje „jako by šlo o úryvek z technické dokumentace“: napodobujeme cílový registr.
Step-Back Prompting
Třetí technika řeší opačný případ: otázky tak specifické, že je žádný dokument přímo nezodpovídá. „Mohu si odečíst elektrické kolo koupené v únoru?“ se nikde nevyskytuje, ale sekce o odečitatelných firemních výdajích ano. Požádáme tedy model o obecnou otázku skrývající se za tou specifickou a vyhledáme s oběma, přičemž původní otázce přiřadíme váhu 0,7 a té obecnější 0,3 – široký kontext pomáhá, ale neměl by dominovat.
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
]
Porovnání technik
Každá řeší specifickou patologii vyhledávání a každá má svou cenu v podobě dalších volání, a tedy vyšší latence.
| Technika | Kdy ji použít | Dodatečné náklady |
|---|---|---|
| Multi-query | Nejasné dotazy, různorodá slovní zásoba | n volání embeddingu + 1 volání LLM |
| HyDE | Propast mezi dotazem a dokumentem, technické domény | 1 volání LLM + 1 volání embeddingu |
| Step-back | Velmi specifické otázky, potřeba kontextu | 1 volání LLM + 2 volání embeddingu |
Kombinování technik
Nemusíš si vybírat jen jednu. Následující funkce přijímá seznam strategií, akumuluje skóre, které každá z nich vyprodukuje, do slovníku indexovaného podle dokumentu, a ponechá maximum. Dokument nalezený pouze pomocí HyDE se tak umístí vedle dokumentu nalezeného přímým vyhledáváním. Měj však na paměti, že kombinace tří strategií ztrojnásobí rozpočet a prodlouží dobu odezvy: tuto kombinaci si rezervuj pro obtížné dotazy nebo pro offline zpracování, kde na latenci nezáleží.
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
]
Klíčové poznatky
- Multi-query přeformulovává otázku z více úhlů, aby pokryla širší slovní zásobu
- HyDE generuje hypotetickou odpověď, která se více podobá cílovým dokumentům
- Step-back klade obecnější otázku, aby zachytil širší kontext
- Tyto techniky přidávají latenci, ale výrazně zlepšují úplnost (recall)