Vai al contenuto principale
Italiano— Scegli una lingua
Menu

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

Lezione 14 di 22 Aggiornata il 29 luglio 2026 Sviluppatore
In questa pagina
  1. Obiettivi
  2. Il problema: una singola query non basta
  3. Multi-Query: porre la domanda in modo diverso
  4. HyDE: Hypothetical Document Embeddings
  5. Step-Back Prompting
  6. Confronto delle tecniche
  7. Combinare le tecniche
  8. Punti chiave

Obiettivi

  • Migliorare il recupero utilizzando tecniche avanzate
  • Implementare i prompt multi-query, HyDE e step-back
  • Sapere quando utilizzare ciascuna tecnica

Il problema: una singola query non basta

Il reranking della lezione precedente ha migliorato il modo in cui i candidati vengono classificati, ma non ha potuto aiutare con i documenti che il recupero non ha mai fatto emergere in primo luogo. La causa più comune di queste omissioni non è il modello né l’indice: è la query stessa. Un utente potrebbe digitare “non funziona sul mio telefono”, mentre la documentazione discute di “incompatibilità con le versioni di Android precedenti alla 12”. Nessun modello di embedding avvicinerà spontaneamente queste due formulazioni.

Le tecniche seguenti condividono un unico principio: invece di accettare la query così com’è, la trasformiamo o la moltiplichiamo prima di cercare. Agiscono tutte sul recall, ovvero sulla capacità di inserire il documento giusto nell’elenco dei candidati.

Multi-Query: porre la domanda in modo diverso

Il primo approccio è il più diretto. Chiediamo all’LLM di riformulare la domanda da diverse angolazioni, eseguiamo una ricerca con ciascuna variante e uniamo i risultati. La domanda “come disdico il mio abbonamento?” diventa anche “procedura di cancellazione”, “interrompere l’addebito mensile” e “eliminare il mio account a pagamento”: tre vocabolari diversi, tre possibilità di colpire la formulazione usata dall’autore della documentazione.

La fase di unione merita una nota: la riga np.maximum mantiene, per ogni documento, il punteggio migliore ottenuto tra tutte le query. Un documento che corrisponde bene a una sola riformulazione sale comunque in cima, cosa che non accadrebbe se facessimo la media dei punteggi. La temperatura di 0.7 è intenzionale qui, perché vogliamo varietà, non riproducibilità.

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 affronta il problema dall’altra estremità. Invece di moltiplicare le domande, facciamo generare al modello una risposta plausibile – anche se parzialmente errata, non importa – e poi cerchiamo documenti vicini a quella risposta. La domanda “come configuro l’SSO?” produce un paragrafo che parla di provider di identità, SAML e metadati, esattamente il vocabolario trovato nella documentazione reale.

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
    ]

Se questa tecnica funziona, è perché l’embedding di una risposta assomiglia più all’embedding di un documento di quanto non faccia l’embedding di una domanda. Una domanda è breve, interrogativa e spesso formulata con le parole dell’utente; un documento è lungo, affermativo e scritto nel gergo del settore. HyDE colma questo divario query-documento spostando la query sul terreno del corpus. È anche per questo che il prompt specifica “come se fosse un estratto della documentazione tecnica”: stiamo imitando il registro di destinazione.

Step-Back Prompting

La terza tecnica gestisce il caso opposto: domande così specifiche che nessun documento le affronta direttamente. “Posso detrarre una bici elettrica acquistata a febbraio?” non appare da nessuna parte, ma la sezione sulle spese aziendali detraibili sì. Chiediamo quindi al modello la domanda generale che si nasconde dietro quella specifica, poi cerchiamo con entrambe, pesandole 0.7 per la domanda originale e 0.3 per quella più ampia: il contesto ampio aiuta, ma non deve dominare.

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
    ]

Confronto delle tecniche

Ognuna affronta una specifica patologia del recupero e ognuna ha un costo in termini di chiamate extra e quindi di latenza maggiore.

TecnicaQuando usarlaCosto aggiuntivo
Multi-queryQuery ambigue, vocabolario variegaton chiamate di embedding + 1 chiamata LLM
HyDEDivario query-documento, domini tecnici1 chiamata LLM + 1 chiamata di embedding
Step-backDomande molto specifiche, bisogno di contesto1 chiamata LLM + 2 chiamate di embedding

Combinare le tecniche

Non devi sceglierne solo una. La funzione seguente accetta un elenco di strategie, accumula i punteggi prodotti da ciascuna in un dizionario indicizzato per documento e mantiene il massimo. Un documento trovato solo da HyDE si classifica quindi accanto a un documento trovato tramite ricerca diretta. Tieni presente, tuttavia, che sovrapporre tre strategie triplica il budget e allunga i tempi di risposta: riserva questa combinazione per query difficili o per elaborazioni offline dove la latenza non conta.

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
    ]

Punti chiave

  • Multi-query riformula la domanda da più angolazioni per coprire più vocabolario
  • HyDE genera una risposta ipotetica che assomiglia di più ai documenti di destinazione
  • Step-back pone una domanda più generale per catturare un contesto ampio
  • Queste tecniche aggiungono latenza ma migliorano significativamente il recall