Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Pokročilé RAG: Multi-Query, HyDE, Step-Back

Lekce 14 z 22 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Cíle
  2. Problém: Jeden dotaz nestačí
  3. Multi-Query: Polož otázku jinak
  4. HyDE: Hypotetické embeddingy dokumentů
  5. Step-Back Prompting
  6. Porovnání technik
  7. Kombinování technik
  8. Klíčové poznatky

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.

TechnikaKdy ji použítDodatečné náklady
Multi-queryNejasné dotazy, různorodá slovní zásoban volání embeddingu + 1 volání LLM
HyDEPropast mezi dotazem a dokumentem, technické domény1 volání LLM + 1 volání embeddingu
Step-backVelmi specifické otázky, potřeba kontextu1 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)