Cápsula 07: Decision framework — qué reranker elegir y cuándo

Descripción de la cápsula

Esta es la cápsula que vas a volver a leer cada vez que empiezes un nuevo proyecto RAG. Es la consolidación de las cápsulas 03-06: cross-encoder, LLM-based, Cohere Rerank, optimizaciones operativas. Acá las pones lado a lado, comparas trade-offs sobre dimensiones que importan en el mundo real (calidad, latencia, costo, multilingüe, mantenimiento), y aplicas un decision framework reproducible para tomar la decisión correcta para tu caso.

No es una cápsula de teoría — es operativa. Cuando termines, tienes un flowchart que aplicas en 5 minutos para cualquier proyecto, sin necesidad de releer las 4 cápsulas previas.

Al finalizar esta cápsula serás capaz de:

• ✅ Comparar las tres técnicas de re-ranking sobre seis dimensiones (calidad, latencia, costo, idioma, mantenimiento, vendor lock-in)
• ✅ Aplicar un decision framework reproducible para elegir reranker en menos de 10 minutos
• ✅ Identificar los tres patrones de pipeline más comunes (sin rerank, single-stage, cascada)
• ✅ Justificar la elección de reranker ante un Tech Lead con datos cuantitativos
• ✅ Anticipar cuándo conviene combinar dos rerankers en cascada
• ✅ Identificar señales para migrar de un reranker a otro mientras tu producto evoluciona

Tiempo estimado: 30-35 minutos

Benchmark consolidado: las tres técnicas lado a lado

Calidad y latencia

Costo y mantenimiento

Operacional

Decision framework en flowchart

                    ┌──────────────────────────────────────┐
                    │ ¿Tu precision@5 actual es <85%?      │
                    └──────────────┬───────────────────────┘
                                   │
                  ┌────────────────┴────────────────┐
                  │ NO                              │ SÍ
                  ▼                                 ▼
       ┌──────────────────────┐         ┌──────────────────────────┐
       │ NO uses re-ranking.  │         │ ¿Datos sensibles que NO  │
       │ El sistema funciona. │         │ pueden salir de tu infra?│
       └──────────────────────┘         └──────────┬───────────────┘
                                                   │
                                  ┌────────────────┴────────────┐
                                  │ SÍ                          │ NO
                                  ▼                             ▼
                       ┌──────────────────────┐      ┌────────────────────────┐
                       │ Cross-encoder local. │      │ ¿Tu corpus es          │
                       │ Datos quedan locales.│      │ multilingüe?           │
                       └──────────────────────┘      └──────────┬─────────────┘
                                                                │
                                              ┌─────────────────┴───────────┐
                                              │ SÍ                          │ NO (inglés puro)
                                              ▼                             ▼
                                   ┌──────────────────────┐    ┌────────────────────────┐
                                   │ ¿Volumen >1M         │    │ ¿Equipo tiene MLE para │
                                   │ queries/mes?         │    │ mantener modelo local? │
                                   └──────────┬───────────┘    └──────────┬─────────────┘
                                              │                           │
                                  ┌───────────┴────────┐      ┌───────────┴──────────┐
                                  │ SÍ                 │ NO   │ SÍ                   │ NO
                                  ▼                    ▼      ▼                      ▼
                       ┌──────────────────┐  ┌──────────────────┐  ┌──────────────────┐
                       │ Considera        │  │ Cohere Rerank    │  │ Cohere Rerank    │
                       │ cross-encoder    │  │ multilingual-v3. │  │ multilingual-v3  │
                       │ multilingual     │  │                  │  │ o LLM rerank.    │
                       │ local (mantener) │  │ Default sensato. │  │                  │
                       │ vs Cohere ($).   │  │                  │  │                  │
                       └──────────────────┘  └──────────────────┘  └──────────────────┘

Aplicado a casos reales

Tres patrones de pipeline

Patrón 1: sin re-ranking (cosine only)

Query ──> Embedding ──> Cosine retrieve ──> Top-5 ──> LLM

Cuándo: MVPs, dataset chico (<10K), precision@5 >85% sobre eval set.

No agregues re-ranking solo porque sí. Si el sistema funciona, no toques. Re-rank tiene costo y agrega complejidad.

Patrón 2: single-stage rerank (lo más común)

Query ──> Embedding ──> Cosine retrieve top-20-30 ──> Reranker ──> Top-5 ──> LLM

Cuándo: producción típica. Cubre el 80% de los casos. Reranker = cross-encoder o Cohere según tu contexto.

Configuración recomendada:

def standard_rag_pipeline(query: str):
    # Etapa 1: retrieval amplio
    candidates = collection.query(
        query_texts=[query],
        n_results=25  # más amplio que top-5 final
    )['documents'][0]

    # Etapa 2: re-ranking
    reranked = reranker.rerank(query, candidates, top_k=5)

    # Etapa 3: filtrar por threshold de relevancia
    relevant = [doc for doc in reranked if doc.score > THRESHOLD]

    return relevant  # 3-5 docs realmente relevantes

Patrón 3: cascada multi-stage (para casos críticos)

Query ──> Embedding ──> Cosine retrieve top-50 ──> Cross-encoder rerank top-15 ──> LLM rerank top-5 ──> LLM
                                                       (rápido, gratis)              (preciso, caro)

Cuándo: dominios críticos donde 3-5% extra de precision se justifica + presupuesto permite gasto extra.

Por qué cascada en lugar de LLM directo:

• Cross-encoder filtra "obviamente irrelevantes" baratamente.
• LLM solo evalúa los 15 mejores → menos llamadas, mismo resultado de calidad.
• Costo total ~70% menor que LLM directo sobre 50 candidatos.

def critical_rag_pipeline(query: str):
    # Etapa 1: retrieval amplio
    candidates = collection.query(
        query_texts=[query],
        n_results=50
    )['documents'][0]

    # Etapa 2: cross-encoder filtra a top-15 (rápido y gratis)
    cross_top_15 = cross_encoder.rerank(query, candidates, top_k=15)
    cross_docs = [item.document for item in cross_top_15]

    # Etapa 3: LLM rerank refina a top-5 (preciso pero caro)
    llm_top_5 = llm_rerank(query, cross_docs, top_k=5)

    return llm_top_5

Cuándo migrar de uno a otro

Tu producto evoluciona, los rerankers también. Señales para migrar:

De "sin rerank" a "cross-encoder local":

• Precision@5 cayó bajo 85% sobre eval set.
• Volumen de queries con respuesta vaga/incorrecta supera ~10%.
• Tickets de soporte mencionando "el bot no encuentra cosas" aumentan.

De "cross-encoder local" a "Cohere":

• Empezaste a recibir queries en otros idiomas y la calidad bajó.
• Equipo no tiene bandwidth para mantener modelos.
• Volumen creció a punto que paying for managed se justifica vs ingeniería.

De "Cohere" a "LLM rerank en cascada":

• Stakeholders piden precision@5 ≥94%.
• Producto entró en dominio crítico (legal, médico).
• Margen del producto permite el costo extra.

Migrar HACIA ATRÁS (downgrade):

A veces el mejor reranker no es el más caro. Casos donde conviene downgrade:

• Volumen creció 10x. Cohere ahora cuesta $500/mes — cross-encoder local mantiene calidad similar gratis.
• Compliance cambió y datos no pueden salir → forzar cross-encoder local.
• Producto pivoteó a inglés monolingüe → cross-encoder MS MARCO suficiente, ahorrar $$/mes de Cohere.

La decisión completa: framework de 6 preguntas

Cuando empiezas un proyecto, recorre estas 6 preguntas en orden. La primera respuesta "no" o "sí" relevante define tu reranker:

1. ¿Tu precision@5 actual con cosine only ya es ≥90%?
   → Sí: NO uses reranker. Tu sistema funciona.
   → No: continuar a 2.

2. ¿Tus datos NO pueden salir de tu infraestructura (compliance)?
   → Sí: Cross-encoder local. Sin alternativas válidas.
   → No: continuar a 3.

3. ¿Tu corpus tiene queries en idiomas no-ingleses (>10% del tráfico)?
   → Sí: Cohere multilingual. Cross-encoder MS MARCO falla acá.
   → No: continuar a 4.

4. ¿Tu dominio es crítico (legal, médico, financiero, compliance)?
   → Sí: cascada cross-encoder + LLM rerank. Vale el costo extra.
   → No: continuar a 5.

5. ¿Tu equipo tiene MLE/ingeniero para mantener modelos locales?
   → Sí: Cross-encoder local. Gratis, control total.
   → No: continuar a 6.

6. ¿Tu volumen es <500K queries/mes y presupuesto permite ~$50/mes?
   → Sí: Cohere. Buena calidad sin maintenance.
   → No: Cross-encoder local. Volumen alto justifica setup local.

El 80% de los casos termina en cross-encoder local o Cohere. Solo casos especiales justifican LLM rerank.

Trampas y errores comunes al elegir

Trampa 1: elegir LLM rerank "porque es lo mejor"

El error: ves benchmark "GPT-4 da 96% precision", lo eligen sin considerar que tu volumen de 100K queries/día genera $1500/mes de costo.

Cómo prevenir: seguir el framework. Empezar con la opción más barata que cumple los requisitos. Subir solo si métricas lo justifican.

Trampa 2: comparar rerankers sin eval set propio

El error: copias benchmarks de blog posts. Asumes que Cohere da 91% en tu caso porque dio 91% en el benchmark del blog.

Síntoma: la realidad de tu dataset puede ser distinta. Algunos dominios favorecen unos rerankers sobre otros.

Cómo prevenir: siempre construir eval set propio (30-100 queries representativas con ground truth). Medir cada reranker candidato sobre tu eval set. Decidir con datos propios.

Trampa 3: cambiar reranker sin medir el efecto

El error: migras de cross-encoder a Cohere porque "Cohere es mejor". No mediste antes ni después.

Síntoma: no sabes si mejoraste o empeoraste. Stakeholders preguntan, no puedes responder.

Cómo prevenir: A/B testing antes/después con eval set fijo. Si Cohere mejora <3% precision, considerar si vale el costo recurrente.

Trampa 4: ignorar el costo de migración

El error: asumes que cambiar de reranker es "solo cambiar el código".

Realidad: cada migración requiere:

• Implementación + testing (2-5 días)
• Re-validación sobre eval set
• Update de dashboards de monitoring
• Cambios en runbooks (si la API tiene mode de fallo distinto)
• Rollback plan

Cómo prevenir: estimar costo de ingeniería, comparar con costo recurrente del cambio. A veces es más barato pagar Cohere que migrar a cross-encoder.

Trampa 5: elegir cross-encoder MS MARCO para corpus no-inglés

El error: tu sistema procesa documentación en español. Eliges ms-marco-MiniLM-L-12-v2 porque "es el más popular".

Síntoma: precision sobre queries en español es 75%, mientras que en inglés es 90%. Inconsistente y mal.

Cómo prevenir: para corpus no-inglés, usar cross-encoder multilingual o Cohere multilingual. Nunca MS MARCO en idiomas no-ingleses para producción.

Trampa 6: vendor lock-in sin plan B

El error: todo el código asume Cohere específicamente. Cohere sube precios 50%, no puedes migrar rápido.

Cómo prevenir: abstraer la interfaz de re-ranking detrás de una clase. Tener implementaciones de al menos 2 rerankers. Poder cambiar con feature flag.

Ejercicio aplicado

Escenario: evalúa los siguientes 4 proyectos y decide qué reranker elegir para cada uno. Justifica con el framework de 6 preguntas.

Proyecto A: Chatbot de soporte interno para una empresa SaaS. 80K artículos de documentación en inglés. 500 empleados son los usuarios. Precision actual con cosine only: 76%. Equipo: 2 ingenieros backend.

Proyecto B: RAG médico para un hospital. 200K artículos clínicos en español. Compliance: datos NO pueden salir del hospital. Volumen: 1000 queries/día.

Proyecto C: Asistente jurídico SaaS para abogados de LATAM. 500K casos en español/portugués/inglés. Precision target: 95%. Cobramos $500/mes/usuario, tenemos 200 usuarios premium. Equipo de 5 ingenieros + 1 MLE.

Proyecto D: Buscador interno de Stack Overflow para una startup. 10M preguntas/respuestas, mayoría en inglés con código embebido. Volumen: 50K queries/día. Precision actual sin rerank: 84%.

def legal_rag_pipeline(query, stakes="normal"):
    # Etapa 1: retrieval amplio
    candidates = collection.query(query_texts=[query], n_results=50)['documents'][0]

    # Etapa 2: Cohere multilingual rerank
    cohere_top_15 = cohere_rerank(query, candidates, top_k=15, model="rerank-multilingual-v3")

    if stakes == "high":
        # Etapa 3: LLM rerank con GPT-4o (premium)
        cohere_docs = [item.document for item in cohere_top_15]
        return llm_rerank(query, cohere_docs, top_k=5, model="gpt-4o")
    else:
        # Solo Cohere para queries normales
        return cohere_top_15[:5]

Resumen y siguiente paso

Lo que aprendiste:

• Las tres técnicas (cross-encoder, Cohere, LLM) cubren el spectrum calidad-costo-latencia. Ninguna es universalmente mejor.
• Decision framework de 6 preguntas resuelve el 80% de los casos en menos de 10 minutos.
• Tres patrones de pipeline: sin rerank (MVP), single-stage (default), cascada (casos críticos).
• Migrar entre rerankers tiene costo de ingeniería real — no migrar sin medir mejora.
• Vendor lock-in se mitiga abstrayendo la interfaz de re-ranking. Tener al menos un plan B.
• Cross-encoder MS MARCO solo para inglés. Para multilingüe, usar versión multilingual o Cohere.

Checkpoint: antes de avanzar, deberías poder:

• Aplicar el framework de 6 preguntas a un proyecto nuevo y elegir reranker en <10 min.
• Diseñar pipeline cascada para un caso crítico justificándolo con costo/precision.
• Identificar señales para migrar entre rerankers (incluyendo downgrades).

Siguiente cápsula: 08 — Proyecto Re-ranking System.

Cierre del módulo: vas a construir un sistema de re-ranking real con A/B testing entre dos técnicas, sobre un dataset propio. Aplicas todo lo aprendido en las cápsulas 02-07: implementación correcta, optimizaciones, decision framework, validación con eval set. Es el proyecto que va al portfolio.

Recursos

1. BEIR Benchmark Leaderboard — Comparaciones reproducibles de rerankers sobre múltiples datasets
2. Pinecone — Choosing a Reranker — Decision guide visual
3. LlamaIndex — Reranker Comparisons — Implementaciones lado a lado
4. Cohere vs Cross-Encoder Benchmarks — Caso de uso multilingüe
5. Reciprocal Rank Fusion Paper — Para combinar resultados de múltiples rerankers
6. The Cost-Quality Frontier in Retrieval (Anthropic) — Análisis de Pareto para decisiones de retrieval

Tiempo estimado: 30-35 minutos Siguiente: 08-project-reranking-system.md