RAG avanzado: Multi-Query, HyDE, Step-Back
En esta página
Objetivos
- Mejorar la recuperación mediante técnicas avanzadas
- Implementar los métodos multi-query, HyDE y step-back prompting
- Saber cuándo utilizar cada técnica
El problema: una única consulta no basta
La reordenación (reranking) de la lección anterior mejoró la clasificación de los candidatos, pero no pudo ayudar con los documentos que el sistema de recuperación nunca llegó a mostrar en primer lugar. La causa más frecuente de estos fallos no es el modelo ni el índice, sino la propia consulta. Un usuario puede escribir «no funciona en mi teléfono», mientras que la documentación habla de «incompatibilidad con versiones de Android anteriores a la 12». Ningún modelo de embeddings acercará espontáneamente esas dos formulaciones.
Las siguientes técnicas comparten un único principio: en lugar de aceptar la consulta tal cual, la transformamos o multiplicamos antes de buscar. Todas actúan sobre la exhaustividad (recall); es decir, sobre la capacidad de incluir el documento correcto en la lista de candidatos.
Multi-Query: formular la pregunta de otra manera
El primer enfoque es el más directo. Pedimos al LLM que reformule la pregunta desde varios ángulos, ejecutamos una búsqueda con cada variante y fusionamos los resultados. La pregunta «¿cómo cancelo mi suscripción?» se convierte también en «procedimiento de cancelación», «detener el cargo mensual» y «eliminar mi cuenta de pago»: tres vocabularios distintos, tres oportunidades de acertar con la redacción que utilizó el autor de la documentación.
El paso de fusión merece una nota: la línea np.maximum conserva, para cada documento, la mejor puntuación obtenida entre todas las consultas. Un documento que encaja bien con solo una reformulación asciende así a los primeros puestos, algo que no ocurriría si promediáramos las puntuaciones. La temperatura de 0,7 es intencionada aquí, porque buscamos variedad, no reproducibilidad.
from openai import OpenAI
import numpy as np
client = OpenAI()
def generer_multi_queries(question: str, n: int = 3) -> list[str]:
"""Genera n reformulaciones de la pregunta."""
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]:
"""Búsqueda con múltiples reformulaciones."""
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: embeddings de documentos hipotéticos
HyDE aborda el problema desde el extremo opuesto. En lugar de multiplicar las preguntas, hacemos que el modelo genere una respuesta plausible —aunque sea parcialmente incorrecta, no importa— y luego buscamos documentos cercanos a esa respuesta. La pregunta «¿cómo configuro SSO?» produce un párrafo que habla de proveedores de identidad, SAML y metadatos, exactamente el vocabulario que aparece en la documentación real.
def recherche_hyde(
question: str,
corpus_embeddings: np.ndarray,
documents: list[dict],
k: int = 5
) -> list[dict]:
"""Búsqueda con un documento hipotético (HyDE)."""
# 1. Generar un documento hipotético
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. Codificar el documento hipotético
hyde_emb = client.embeddings.create(
input=doc_hypothetique,
model="text-embedding-3-large"
).data[0].embedding
# 3. Buscar documentos similares
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
]
Si esta técnica funciona, es porque el embedding de una respuesta se parece más al embedding de un documento que el embedding de una pregunta. Una pregunta es breve, interrogativa y suele estar formulada con las propias palabras del usuario; un documento es extenso, afirmativo y está escrito en jerga del dominio. HyDE salva esta brecha entre consulta y documento trasladando la consulta al terreno del corpus. Por eso mismo el prompt especifica «as if it were an excerpt from technical documentation»: estamos imitando el registro objetivo.
Step-Back Prompting
La tercera técnica aborda el caso contrario: preguntas tan específicas que ningún documento las trata de frente. «¿Puedo deducir una bicicleta eléctrica comprada en febrero?» no aparece en ninguna parte, pero sí la sección sobre gastos deducibles de la actividad empresarial. Así que pedimos al modelo la pregunta general que se esconde tras la específica y buscamos con ambas, ponderándolas al 0,7 para la pregunta original y al 0,3 para la más amplia: el contexto amplio ayuda, pero no debe dominar.
def recherche_step_back(
question: str,
corpus_embeddings: np.ndarray,
documents: list[dict],
k: int = 5
) -> list[dict]:
"""Búsqueda en dos pasos: general y luego específica."""
# 1. Generar una pregunta step-back
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. Buscar con ambas preguntas
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
]
Comparación de las técnicas
Cada una aborda una patología específica de la recuperación y todas implican un coste adicional en llamadas y, por tanto, mayor latencia.
| Técnica | Cuándo usarla | Coste adicional |
|---|---|---|
| Multi-query | Consultas ambiguas, vocabulario variado | n llamadas de embeddings + 1 llamada LLM |
| HyDE | Brecha consulta-documento, dominios técnicos | 1 llamada LLM + 1 llamada de embeddings |
| Step-back | Preguntas muy específicas, necesidad de contexto | 1 llamada LLM + 2 llamadas de embeddings |
Combinación de técnicas
No tienes que elegir solo una. La siguiente función acepta una lista de estrategias, acumula las puntuaciones que produce cada una en un diccionario indexado por documento y conserva el máximo. Un documento encontrado solo por HyDE se sitúa así junto a uno hallado mediante búsqueda directa. Ten en cuenta, sin embargo, que apilar tres estrategias triplica el presupuesto y alarga el tiempo de respuesta: reserva esta combinación para consultas difíciles o para procesamiento fuera de línea, donde la latencia no importe.
def recherche_avancee(
question: str,
corpus_embeddings: np.ndarray,
documents: list[dict],
k: int = 5,
strategies: list[str] = ["direct", "multi_query", "hyde"]
) -> list[dict]:
"""Combina múltiples estrategias de búsqueda."""
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"])
# Puntuación final = máximo de las puntuaciones
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
]
Resumen
- Multi-query reformula la pregunta desde múltiples ángulos para cubrir más vocabulario
- HyDE genera una respuesta hipotética que se parece más a los documentos objetivo
- Step-back plantea una pregunta más general para capturar contexto amplio
- Estas técnicas añaden latencia, pero mejoran significativamente la exhaustividad (recall)