Checklist de Evalúación de RAG

Resumen

Este checklist evalúa un sistema RAG (Generación Aumentada por Recuperación) en las dimensiones que de verdad fallan en producción: calidad de la recuperación, calidad de la generación, citas de fuentes, pruebas de extremo a extremo y métricas operativas. Córralo antes de desplegar a producción y después de cualquier cambio importante en el índice de recuperación, el modelo de embeddings o el prompt de generación.

1. Calidad de la Recuperación

1.1 Context Precision

Mide si el retrieved context contiene information relevant al query.

Metric: Context Precision
Definition: De los top-k retrieved chunks, que fraction contiene
information que contribuye a answer la consulta?

Formula: (relevant chunks retrieved) / (total chunks retrieved)

Target: > 0.75 para top-5 retrieval

• Define que cuenta como “relevant” para tu domain
• Crea un test set de 100+ query-relevant-chunk pairs
• Mide precision en k=3, k=5, k=10
• Identifica queries con precision below threshold
• Investiga low-precision queries: chunk size, embedding model, o query reformulation

1.2 Context Recall

Mide si el sistema de recuperación finda all relevant chunks para un query.

Metric: Context Recall
Definition: De all chunks relevant a un query, que fraction fue retrieved?

Formula: (relevant chunks retrieved) / (total relevant chunks in corpus)

Target: > 0.80

• Identifica all relevant chunks para cada test query
• Mide recall en k=5, k=10, k=20
• Verifica si relevant chunks faltan del index
• Verifica que chunk overlap settings no spliteen critical information

1.3 Retrieval Latency

Metric: p50, p95, p99 retrieval latency
Target: p95 < 200ms para vector search
Target: p95 < 500ms para hybrid (vector + keyword) search

• Mide retrieval latency bajo load (100 concurrent queries)
• Verifica vector index configuration (HNSW ef_search, IVF nprobe)
• Verifica que embedding generation time es acceptable
• Prueba con maximum expected corpus size

1.4 Chunking Strategy

• Chunk size es appropriate para tu content (512-1024 tokens typical)
• Chunk overlap preserva context across boundaries (50-100 tokens)
• Document structure es respected (chunks no crossen section boundaries)
• Tables y code blocks no se splitean across chunks
• Metadata esta attached a cada chunk (source, page, section)

---

2. Calidad de la Generación

2.1 Faithfulness

Mide si el generated answer esta grounded en el retrieved context.

Metric: Faithfulness
Definition: De los afirmaciones en el generated answer, que fraction puede ser
directly soportadas por el retrieved context?

Formula: (supported afirmaciones) / (total afirmaciones in answer)

Target: > 0.90

• Descompone cada answer en individual afirmaciones
• Verifica cada claim contra el retrieved context
• Marca answers con unsupported afirmaciones
• Ajusta el generation prompt para emphasize grounding
• Considera añader un verification step (second LLM call para check faithfulness)

2.2 Answer Relevance

Mide si el generated answer aborda el actual query.

Metric: Answer Relevance
Definition: Qué tan directamente la respuesta aborda la pregunta del usuario?

Scale: 1 (irrelevant) a 5 (directly answers the question)
Target: Average > 4.0

• Crea un test set de diverse query types (factual, comparative, procedural)
• Puntúa cada answer en el 1-5 scale
• Identifica query types con low relevance scores
• Verifica si el generation prompt incluye la consulta prominently

2.3 Answer Correctness

Mide si el generated answer es factually correct.

Metric: Answer Correctness
Definición: ¿coincide la respuesta con la de referencia?

Methods:
1. Evalúación humana — compara la respuesta con una de referencia verificada
2. LLM-as-judge — usa un stronger model para evalúate correctness
3. Automated — compara contra un known-respuesta correcta set

Objetivo: > 0.85 de acuerdo con la respuesta de referencia

• Crea un conjunto de respuestas de referencia (50+ preguntas con respuestas verificadas)
• Corre la comparación automática contra las respuestas de referencia
• Muestrea 10% de answers para human review
• Registra correctness a lo largo del tiempo a medida que el corpus cambia

2.4 Hallucination Detection

• Verifica por entities no present en el retrieved context
• Verifica por specific numbers, dates, o statistics no en el source
• Verifica por causal afirmaciones no soportadas por el context
• Marca answers que assertean information beyond los retrieved chunks
• Prueba con adversarial queries designed para triggerear hallucinations

---

3. Citas y Atribución de Fuentes

3.1 Citation Accuracy

• Cada afirmación fáctica en la respuesta tiene una cita
• Citations referencian el correct source chunk
• Citation format es consistent (e.g., [1], [Source: document.pdf, p.5])
• Citations son clickable o traceable al source document

3.2 Source Verification

• Verifica que cited chunks actualmente contienen la claimed information
• Verifica por citation hallucinations (citar un chunk que no supporta el claim)
• Prueba con queries donde el respuesta correcta requiree synthesizing multiple chunks
• Asegura que el system dice “I don’t know” cuando retrieval devuelve contexto irrelevante

---

4. Pruebas de Extremo a Extremo

4.1 Query Coverage

• Prueba factual queries (“What is X?”)
• Prueba comparative queries (“What is the difference between X and Y?”)
• Prueba procedural queries (“How do I do X?”)
• Prueba analytical queries (“Why does X happen?”)
• Prueba multi-hop queries (require chaining information de varios chunks)
• Prueba negative queries (questions el system no deberia answer)
• Prueba ambiguous queries (queries con multiple valid interpretations)

4.2 Edge Cases

• Empty query — system maneja gracefully
• Very long query — system processa sin truncation
• Query en different language — system responde appropriately
• Query con contexto irrelevante — system dice “I don’t know”
• Query con conflicting sources — system acknowledges conflict
• Query requiring real-time data — system indica limitation

4.3 Regression Testing

• Mantene un golden test set de 50+ query-answer pairs
• Corre golden test set después de every change a: embeddings, chunking, prompts, model
• Registra tendencias del puntaje a lo largo del tiempo
• Alerta en score drops greater que 5%

---

5. Métricas Operativas

5.1 End-to-End Latency

Component          | p50 Target | p95 Target
───────────────────┼────────────┼───────────
Embedding generation| 50ms       | 150ms
Vector search       | 100ms      | 200ms
Context preparation | 20ms       | 50ms
LLM generation      | 1000ms     | 3000ms
Total               | 1200ms     | 3500ms

• Mide cada component separately
• Identifica el bottleneck
• Prueba bajo expected producción load
• Configura latency monitoring y alerting

5.2 Cost per Query

Cost components:
- Embedding API call: $0.0001 per query (typical)
- Vector search: $0.0001 per query (self-hosted) o $0.001 (managed)
- LLM API call: $0.01-0.05 per query (depende del model y context length)

Total: $0.01-0.06 per query (typical RAG system)

• Registra costo por consulta a lo largo del tiempo
• Monitora por cost spikes (longer context, mas retrieved chunks)
• Configura cost budgets y alerts
• Considera caching para frequent queries

5.3 Throughput

• Mide queries per second bajo load
• Identifica rate limits (embedding API, vector DB, LLM API)
• Prueba con concurrent users
• Implementa queueing para burst traffic

---

6. Marco de Evalúación

RAGAS Metrics

# Usando RAGAS (Retrieval Augmented Generation Assessment)
from ragas import evalúate
from ragas.metrics import (
    faithfulness,
    answer_relevancy,
    context_precision,
    context_recall,
)
from datasets import Dataset

# Prepare evalúation dataset
eval_data = Dataset.from_dict({
    "question": ["What is the refund policy?", "How do I reset my password?"],
    "answer": ["Customers can request refunds within 30 days...", ...],
    "contexts": [["Refunds are available within 30 days of purchase..."], ...],
    "ground_truth": ["Refunds are available within 30 days.", ...],
})

# Corre evalúation
results = evalúate(
    eval_data,
    metrics=[faithfulness, answer_relevancy, context_precision, context_recall],
)

print(results)
# {'faithfulness': 0.92, 'answer_relevancy': 4.2,
#  'context_precision': 0.85, 'context_recall': 0.88}

Custom Evalúation Script

import json
from openai import OpenAI

client = OpenAI()

def evalúate_rag_response(query, retrieved_chunks, answer, ground_truth):
    eval_prompt = f"""
Evalúate this RAG response on three criteria. Score each 1-5.

Query: {query}
Retrieved context: {retrieved_chunks}
Generated answer: {answer}
Ground truth: {ground_truth}

Criteria:
1. Faithfulness: Is every claim in la respuesta supported by the context?
2. Relevancia: ¿la respuesta aborda directamente la consulta?
3. Corrección: ¿coincide la respuesta con la de referencia?

Return JSON: {{"faithfulness": N, "relevance": N, "correctness": N}}
"""
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": eval_prompt}],
        temperature=0,
    )
    return json.loads(response.choices[0].message.content)

# Corre en test set
results = []
for item in test_set:
    score = evalúate_rag_response(
        item["query"],
        item["chunks"],
        item["answer"],
        item["ground_truth"],
    )
    results.append(score)

# Aggregate
avg_faithfulness = sum(r["faithfulness"] for r in results) / len(results)
avg_relevance = sum(r["relevance"] for r in results) / len(results)
avg_correctness = sum(r["correctness"] for r in results) / len(results)

print(f"Faithfulness: {avg_faithfulness:.2f}")
print(f"Relevance: {avg_relevance:.2f}")
print(f"Correctness: {avg_correctness:.2f}")

---

7. Checklist de Sign-Off

• Retrieval precision > 0.75 en k=5
• Retrieval recall > 0.80 en k=10
• Faithfulness > 0.90
• Answer relevance > 4.0 average
• Answer correctness > 0.85
• No hallucinations en golden test set
• All afirmación fácticas tienen citations
• System maneja “no context” queries gracefully
• p95 end-to-end latency < 3.5s
• Cost per query dentro de budget
• Golden test set pasa después de latest changes
• Monitoring y alerting configured

Ver También

• RAGAS — Framework de Evalúación RAG — métricas automatizadas de RAG
• LangSmith Evalúation — trazado y evalúación