Ir al contenido principal
Español— Elegir un idioma
Menú

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

Lección 14 de 22 Actualizado el 29 de julio de 2026 Desarrollador
En esta página
  1. Objetivos
  2. El problema: una única consulta no basta
  3. Multi-Query: formular la pregunta de otra manera
  4. HyDE: embeddings de documentos hipotéticos
  5. Step-Back Prompting
  6. Comparación de las técnicas
  7. Combinación de técnicas
  8. Resumen

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écnicaCuándo usarlaCoste adicional
Multi-queryConsultas ambiguas, vocabulario variadon llamadas de embeddings + 1 llamada LLM
HyDEBrecha consulta-documento, dominios técnicos1 llamada LLM + 1 llamada de embeddings
Step-backPreguntas muy específicas, necesidad de contexto1 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)