Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

RAG haladó szinten: Multi-Query, HyDE, Step-Back

14. lecke 22 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Célok
  2. A probléma: Egyetlen lekérdezés nem elég
  3. Multi-Query: Tegyük fel másképp a kérdést
  4. HyDE: Hipotetikus dokumentum-beágyazások
  5. Step-Back Promptolás
  6. A technikák összehasonlítása
  7. Technikák kombinálása
  8. Főbb megállapítások

Célok

  • A visszakeresés javítása haladó technikákkal
  • A multi-query, HyDE és step-back promptolás implementálása
  • Annak ismerete, hogy melyik technikát mikor érdemes alkalmazni

A probléma: Egyetlen lekérdezés nem elég

Az előző leckében tárgyalt újra rangsorolás (reranking) javította a jelöltek sorrendjét, de nem tudott segíteni azokon a dokumentumokon, amelyeket a visszakeresés eleve nem talált meg. Ezeknek a tévesztéseknek a leggyakoribb oka nem a modell vagy az index, hanem maga a lekérdezés. A felhasználó például azt írhatja be, hogy „nem működik a telefonomon“, míg a dokumentáció az „Android 12 előtti verziókkal való incompatibilitásról“ beszél. Egyetlen beágyazási modell sem fogja spontán közelebb hozni egymáshoz ezt a két megfogalmazást.

A következő technikák egyetlen elven osztoznak: ahelyett, hogy elfogadnánk a lekérdezést olyannak, amilyen, átalakítjuk vagy megsokszorozzuk azt a keresés előtt. Mindegyik módszer a visszaidézést (recall) célozza meg – vagyis annak a képességét, hogy a megfelelő dokumentum felkerüljön a jelöltek listájára.

Multi-Query: Tegyük fel másképp a kérdést

Az első megközelítés a legközvetlenebb. Megkérjük az LLM-et, hogy több szemszögből fogalmazza át a kérdést, lefuttatunk egy-egy keresést minden variánssal, majd egyesítjük az eredményeket. A „hogyan mondhatom le az előfizetésemet?“ kérdésből így lesz „lemondási eljárás“, „a havi díj megszüntetése“ és „fizetett fiókom törlése“ – három különböző szókincs, három esély arra, hogy eltaláljuk a dokumentáció szerzője által használt megfogalmazást.

Az egyesítési lépésnél érdemes megjegyezni: a np.maximum sor minden dokumentum esetén megtartja az összes lekérdezés közül elért legjobb pontszámot. Egy dokumentum, amely csak egyetlen átfogalmazással illeszkedik jól, így az élre kerül, ami átlagolás esetén nem történne meg. A 0,7-es hőmérséklet (temperature) itt szándékos, mert változatosságra van szükségünk, nem pedig reprodukálhatóságra.

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: Hipotetikus dokumentum-beágyazások

A HyDE a probléma másik végéről közelíti meg a helyzetet. Ahelyett, hogy megsokszorozzuk a kérdéseket, megkérjük a modellt, hogy generáljon egy valószínűsíthető választ – még ha az részben hibás is, az nem számít –, majd olyan dokumentumokat keresünk, amelyek közel állnak ehhez a válaszhoz. A „hogyan konfiguráljam az SSO-t?“ kérdésből olyan bekezdés születik, amely az identitásszolgáltatókról, a SAML-ről és a metaadatokról szól, pontosan azzal a szókincssel, amely a valódi dokumentációban is megtalálható.

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
    ]

Ha ez a technika működik, annak az az oka, hogy egy válasz beágyazása jobban hasonlít egy dokumentum beágyazására, mint maga a kérdésé. A kérdés rövid, kérdő mondat, és gyakran a felhasználó saját szavaival fogalmazódik meg; a dokumentum hosszú, kijelentő jellegű, és szakmai zsargonban íródott. A HyDE áthidalja ezt a lekérdezés és dokumentum közötti szakadékot azáltal, hogy a lekérdezést a korpusz területére viszi át. Ez az oka annak is, hogy a prompt előírja: „mintha technikai dokumentáció részlete lenne“: a célzott stílust utánozzuk.

Step-Back Promptolás

A harmadik technika az ellenkező esetet kezeli: olyan kérdéseket, amelyek annyira specifikusak, hogy egyetlen dokumentum sem foglalkozik velük közvetlenül. A „Leírhatok adózási célból egy februárban vásárolt elektromos kerékpárt?“ kérdés sehol sem szerepel, de a levonható üzleti költségekről szóló rész igen. Ezért megkérjük a modellt, hogy találja meg a specifikus kérdés mögött rejlő általános kérdést, majd mindkettővel keresünk, 0,7-es súllyal az eredeti kérdésre és 0,3-assal az általánosabbra – a tágabb kontextus segít, de nem dominálhat.

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
    ]

A technikák összehasonlítása

Mindegyik módszer egy specifikus visszakeresési patológiára nyújt megoldást, és mindegyik plusz hívásokat, ezáltal nagyobb késleltetést igényel.

TechnikaMikor alkalmazdTovábbi költség
Multi-queryKétértelmű lekérdezések, változatos szókincsn beágyazási hívás + 1 LLM hívás
HyDELekérdezés-dokumentum szakadék, műszaki területek1 LLM hívás + 1 beágyazási hívás
Step-backNagyon specifikus kérdések, kontextus szükségessége1 LLM hívás + 2 beágyazási hívás

Technikák kombinálása

Nem kell csak egyet választanod. Az alábbi függvény elfogad egy stratégiák listáját, összegyűjti az egyes stratégiák által előállított pontszámokat egy dokumentumindexelt szótárba, és megtartja a maximumot. Így egy csak HyDE által megtalált dokumentum ugyanolyan rangot kaphat, mint egy közvetlen kereséssel talált. Ne feledd azonban, hogy három stratégia egymásra halmozása megháromszorozza a költséget és növeli a válaszidőt: ezt a kombinációt csak nehéz lekérdezésekre, vagy olyan offline feldolgozásra tartogasd, ahol a késleltetés nem számít.

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
    ]

Főbb megállapítások

  • A multi-query több szemszögből fogalmazza át a kérdést, hogy lefedje a szélesebb szókincset
  • A HyDE egy hipotetikus választ generál, amely jobban hasonlít a célzott dokumentumokra
  • A step-back egy általánosabb kérdést tesz fel a tágabb kontextus megragadásához
  • Ezek a technikák növelik a késleltetést, de jelentősen javítják a visszaidézést