RAG Avanzato: Multi-Query, HyDE, Step-Back
In questa pagina
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.
| Tecnica | Quando usarla | Costo aggiuntivo |
|---|---|---|
| Multi-query | Query ambigue, vocabolario variegato | n chiamate di embedding + 1 chiamata LLM |
| HyDE | Divario query-documento, domini tecnici | 1 chiamata LLM + 1 chiamata di embedding |
| Step-back | Domande molto specifiche, bisogno di contesto | 1 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