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

Reordenación: mejora de la relevancia

Lección 13 de 22 Actualizado el 29 de julio de 2026 Desarrollador
En esta página
  1. Objetivos
  2. El problema del bi-codificador
  3. Reordenación con Cohere
  4. Reordenación con un LLM
  5. Integración en la canalización RAG
  6. Impacto de la reordenación
  7. Resumen

Objetivos

  • Comprender por qué la reordenación mejora los resultados
  • Implementar un reordenador mediante un codificador cruzado (cross-encoder)
  • Integrar la reordenación en una canalización RAG

El problema del bi-codificador

Toda la búsqueda que has construido hasta ahora se basa en un bi-codificador: la consulta y los documentos se codifican por separado, de forma independiente, y se comparan mediante producto escalar. Esto es lo que hace que la búsqueda sea instantánea incluso entre un millón de fragmentos, ya que los vectores del corpus se calcularon de una vez por todas. También es lo que la hace imprecisa, porque el modelo nunca ve la consulta y el documento juntos: debe resumir cada texto en un vector sin saber qué se le preguntará más tarde.

Un codificador cruzado, también llamado reordenador, toma el par (consulta, documento) como entrada y produce una puntuación de relevancia mucho más fina, porque lee ambos textos conjuntamente y puede detectar que un documento trata el tema pero en un sentido opuesto. Esta ganancia tiene un coste: el modelo debe procesar cada documento individualmente, lo que prohíbe su uso en todo el corpus. La solución es emplearlo donde resulte rentable, sobre un pequeño conjunto de candidatos ya preseleccionados.

De ahí la canalización de dos etapas, donde cada modelo hace lo que mejor sabe hacer: el rápido reduce el campo de búsqueda y el preciso realiza la selección final.

Consulta → Bi-codificador → 50 mejores candidatos → Codificador cruzado → 5 mejores resultados

Reordenación con Cohere

Cohere expone un reordenador de alto rendimiento mediante API, lo que evita tener que alojar un modelo. La siguiente función encadena los dos pasos: primero recupera veinte candidatos mediante similitud vectorial y luego pide a rerank-v3.5 que conserve solo cinco. Observa el campo index_original preservado en el resultado: el reordenador devuelve posiciones relativas a la lista de candidatos y necesitarás esto para mapear de vuelta al documento real en tu corpus.

import cohere
from openai import OpenAI

co = cohere.Client(api_key="your-cohere-key")
openai_client = OpenAI()

def search_and_rerank(
    question: str,
    documents: list[str],
    embeddings_corpus,
    k_retrieval: int = 20,
    k_final: int = 5
) -> list[dict]:
    """Búsqueda semántica + reordenación."""
    # Paso 1: Recuperación rápida (bi-codificador)
    query_emb = openai_client.embeddings.create(
        input=question,
        model="text-embedding-3-large"
    ).data[0].embedding

    import numpy as np
    scores = embeddings_corpus @ np.array(query_emb)
    top_indices = np.argsort(scores)[-k_retrieval:][::-1]
    candidates = [documents[i] for i in top_indices]

    # Paso 2: Reordenación (codificador cruzado)
    rerank_response = co.rerank(
        query=question,
        documents=candidates,
        top_n=k_final,
        model="rerank-v3.5"
    )

    return [
        {
            "text": candidates[r.index],
            "rerank_score": r.relevance_score,
            "original_index": int(top_indices[r.index])
        }
        for r in rerank_response.results
    ]

Reordenación con un LLM

Si prefieres no añadir otro proveedor a tu arquitectura —ya sea por razones contractuales, localización de datos o simplemente facturación—, un LLM que ya utilices puede asumir este papel. Envías la pregunta y un documento, solicitas una puntuación de 0 a 10 y ordenas los resultados. Fijar la temperatura en cero y reducir max_tokens a cinco garantiza una salida determinista y económica; el bloque try/except gestiona los casos en los que el modelo responde con algo distinto a un número.

from openai import OpenAI

client = OpenAI()

def llm_reranker(
    question: str,
    candidates: list[str],
    k: int = 5
) -> list[dict]:
    """Utiliza un LLM para puntuar la relevancia."""
    scores = []

    for i, doc in enumerate(candidates):
        response = client.chat.completions.create(
            model="gpt-5.6-terra",
            messages=[{
                "role": "user",
                "content": (
                    f"En una escala de 0 a 10, ¿qué tan relevante es este documento "
                    f"para responder a la pregunta?\n\n"
                    f"Pregunta: {question}\n\n"
                    f"Documento: {doc}\n\n"
                    f"Responde solo con un número entre 0 y 10."
                )
            }],
            temperature=0,
            max_tokens=5
        )
        try:
            score = float(response.choices[0].message.content.strip())
        except ValueError:
            score = 0.0
        scores.append({"index": i, "text": doc, "score": score})

    scores.sort(key=lambda x: x["score"], reverse=True)
    return scores[:k]

Esta versión cuesta una llamada por candidato, es decir, veinte llamadas y tanta latencia acumulada para una única pregunta del usuario. En la práctica, esto resulta prohibitivo en una interfaz interactiva. En su lugar, pedimos al modelo que ordene todos los documentos de una vez, presentando cada candidato truncado a 200 caracteres y numerado, esperando recibir únicamente una lista de índices como respuesta.

def llm_batch_reranker(
    question: str,
    candidates: list[str],
    k: int = 5
) -> list[int]:
    """Reordenación en una única llamada al LLM."""
    formatted_docs = "\n".join(
        f"[{i}] {doc[:200]}" for i, doc in enumerate(candidates)
    )

    response = client.chat.completions.create(
        model="gpt-5.6-terra",
        messages=[{
            "role": "user",
            "content": (
                f"Ordena estos documentos por relevancia respecto a la pregunta. "
                f"Devuelve los índices de los {k} documentos más relevantes, "
                f"separados por comas, de mayor a menor relevancia.\n\n"
                f"Pregunta: {question}\n\n"
                f"Documentos:\n{formatted_docs}\n\n"
                f"Índices (p. ej., 3,1,7,0,5):"
            )
        }],
        temperature=0,
        max_tokens=50
    )

    indices_str = response.choices[0].message.content.strip()
    return [int(i.strip()) for i in indices_str.split(",")][:k]

Integración en la canalización RAG

En una canalización completa, la reordenación se sitúa entre la recuperación y la generación sin cambiar nada más. El punto clave en la clase siguiente es el umbral de 0,3 sobre relevance_score: permite devolver menos de cinco contextos cuando ningún candidato es realmente relevante, en lugar de alimentar al generador con ruido. A menudo, este filtro, más que la propia reordenación, elimina respuestas alucinadas.

class RAGPipelineWithReranking:
    def __init__(self):
        self.client = OpenAI()
        self.co = cohere.Client()

    def respond(self, question: str, chunks, embeddings_corpus):
        # 1. Recuperación amplia
        candidates = self.search(question, embeddings_corpus, k=20)

        # 2. Reordenación
        candidate_docs = [chunks[i]["text"] for i in candidates]
        reranked = self.co.rerank(
            query=question,
            documents=candidate_docs,
            top_n=5,
            model="rerank-v3.5"
        )

        # 3. Selección de los mejores
        contexts = [
            chunks[candidates[r.index]]
            for r in reranked.results
            if r.relevance_score > 0.3  # Umbral de relevancia
        ]

        # 4. Generar la respuesta
        return self.generate(question, contexts)

Impacto de la reordenación

MétricaSin reordenaciónCon reordenaciónGanancia
Recall@50,720,72=
Precision@50,580,78+34 %
MRR0,650,82+26 %

Estas cifras indican con precisión qué hace un reordenador. El recall no se mueve, y es lógico: los candidatos son los mismos y el codificador cruzado no puede rescatar un documento que el bi-codificador no haya surfaced. Sin embargo, la precisión y el MRR mejoran significativamente, porque el documento correcto pasa del sexto lugar al primero. Corolario práctico: si tu recall es pobre, la reordenación no te salvará; primero debes ampliar la recuperación o revisar el fragmentado.

Resumen

  • La reordenación clasifica de nuevo los candidatos con un modelo más preciso
  • Canalización típica: bi-codificador (top 20–50) → codificador cruzado (top 5)
  • Cohere rerank-v3.5 es una solución llave en mano
  • Un LLM puede actuar como reordenador si prefieres evitar una dependencia externa
  • La ganancia en precisión es significativa (típicamente 20–35 %)