Cómo evaluar un sistema RAG con RAGAS

Uno de los problemas más comunes con los sistemas RAG en producción es que "parece que funciona" durante las pruebas manuales, pero hay problemas latentes difíciles de detectar a ojo: el sistema recupera documentos que no responden la pregunta, genera respuestas que suenan correctas pero no están respaldadas por los documentos, o falla sistemáticamente con ciertos tipos de preguntas.

RAGAS (Retrieval Augmented Generation Assessment) es el framework de evaluación más usado para medir estas dimensiones de forma objetiva.

Las 4 métricas principales de RAGAS

1. Faithfulness (Fidelidad)

¿La respuesta generada está respaldada por los documentos recuperados?

Mide si cada afirmación de la respuesta puede inferirse del contexto proporcionado. Una puntuación baja indica que el modelo está "alucinando" — generando información que no está en los documentos.

Rango: 0 a 1. Objetivo: mayor de 0.8 en producción.

2. Answer Relevancy (Relevancia de la respuesta)

¿La respuesta es pertinente a la pregunta original?

Un sistema puede ser fiel (no alucinar) pero aún así responder a algo diferente a lo que se preguntó. Esta métrica detecta respuestas que son correctas pero no responden la pregunta real.

Rango: 0 a 1. Objetivo: mayor de 0.85.

3. Context Precision (Precisión del contexto)

¿Los documentos recuperados son realmente relevantes para responder la pregunta?

Si tu retriever devuelve 5 chunks y solo 2 son útiles, la context precision es 0.4. Una puntuación baja indica problemas en el retriever, no en la generación.

Rango: 0 a 1. Objetivo: mayor de 0.75.

4. Context Recall (Recall del contexto)

¿El retriever encuentra toda la información necesaria para responder?

Si la respuesta correcta requiere 3 fragmentos y el retriever solo encuentra 2, el recall es 0.67. Esta métrica requiere tener ground truth (respuestas de referencia).

Rango: 0 a 1. Objetivo: mayor de 0.75.

Instalación y configuración básica

pip install ragas langchain-openai

from ragas import evaluate
from ragas.metrics import (
    faithfulness,
    answer_relevancy,
    context_precision,
    context_recall,
)
from datasets import Dataset

Dataset de evaluación

RAGAS necesita un dataset con preguntas, contextos recuperados y respuestas generadas. Para usar context_recall también necesitas ground truth:

# Estructura del dataset
data = {
    "question": [
        "¿Cuál es el plazo de devolución de productos?",
        "¿Qué pasa si mi pedido llega dañado?",
        "¿Puedo cambiar mi pedido después de confirmarlo?",
    ],
    "answer": [
        # Respuestas generadas por tu sistema RAG
        "Los productos pueden devolverse en un plazo de 30 días desde la recepción.",
        "En caso de recibir un producto dañado, debe contactar con soporte en 48 horas con foto del daño.",
        "Los pedidos pueden modificarse hasta 2 horas después de la confirmación.",
    ],
    "contexts": [
        # Listas de chunks recuperados por tu sistema para cada pregunta
        ["Política de devoluciones: 30 días desde la entrega para todos los productos..."],
        ["Incidencias de envío: productos dañados deben reportarse en 48h adjuntando fotografía..."],
        ["Modificación de pedidos: posible hasta 2 horas post-confirmación llamando al servicio..."],
    ],
    "ground_truth": [
        # Respuestas de referencia (opcionales pero recomendadas)
        "El plazo de devolución es de 30 días desde la recepción del producto.",
        "Debes contactar con soporte en un máximo de 48 horas con foto del producto dañado.",
        "Los pedidos se pueden modificar dentro de las 2 primeras horas tras confirmar.",
    ]
}

dataset = Dataset.from_dict(data)

Ejecutar la evaluación

from ragas.llms import LangchainLLMWrapper
from ragas.embeddings import LangchainEmbeddingsWrapper
from langchain_openai import ChatOpenAI, OpenAIEmbeddings

# RAGAS usa LLMs para evaluar — necesitas una API key
evaluator_llm = LangchainLLMWrapper(ChatOpenAI(model="gpt-4o-mini"))
evaluator_embeddings = LangchainEmbeddingsWrapper(OpenAIEmbeddings())

resultado = evaluate(
    dataset=dataset,
    metrics=[faithfulness, answer_relevancy, context_precision, context_recall],
    llm=evaluator_llm,
    embeddings=evaluator_embeddings,
)

print(resultado)
# Salida:
# {'faithfulness': 0.87, 'answer_relevancy': 0.91, 'context_precision': 0.73, 'context_recall': 0.82}

df = resultado.to_pandas()
print(df[["question", "faithfulness", "answer_relevancy", "context_precision"]])

Interpretación de resultados

Casos de diagnóstico

Faithfulness baja, context_precision alta: El retriever encuentra los documentos correctos pero el LLM genera información adicional no respaldada. Solución: reforzar las instrucciones del sistema para que solo use el contexto proporcionado.

Context_precision baja, faithfulness alta: El retriever devuelve documentos irrelevantes pero el LLM solo usa los que son pertinentes. El problema está en el retriever — revisar la estrategia de chunking o el modelo de embeddings.

Context_recall baja: El retriever no encuentra toda la información necesaria. Puede indicar que los chunks son demasiado pequeños, que el modelo de embeddings no captura bien el dominio, o que las queries necesitan expansión.

Answer_relevancy baja: El sistema responde preguntas que no son las que se hicieron. Revisar el system prompt para que el modelo sea más directo en responder la pregunta exacta.

Automatizar la evaluación en CI/CD

import json
from pathlib import Path

def evaluar_y_guardar(dataset, umbral_faithfulness=0.75):
    resultado = evaluate(
        dataset=dataset,
        metrics=[faithfulness, answer_relevancy, context_precision],
        llm=evaluator_llm,
        embeddings=evaluator_embeddings,
    )
    
    scores = {
        "faithfulness": resultado["faithfulness"],
        "answer_relevancy": resultado["answer_relevancy"],
        "context_precision": resultado["context_precision"],
    }
    
    # Guardar resultados
    Path("eval_results.json").write_text(json.dumps(scores, indent=2))
    
    # Fallo en CI si faithfulness cae por debajo del umbral
    if scores["faithfulness"] < umbral_faithfulness:
        raise ValueError(
            f"Faithfulness {scores['faithfulness']:.2f} por debajo del umbral {umbral_faithfulness}"
        )
    
    return scores

Construir el dataset de evaluación

El mayor esfuerzo de RAGAS no es técnico — es construir un dataset de preguntas representativas con ground truth. Estrategias:

Manual (alta calidad): expertos del dominio escriben preguntas y respuestas correctas. Caro pero el más fiable.

Semi-automático: usa el LLM para generar preguntas a partir de tus documentos, luego revisa manualmente las respuestas de referencia.

# Generar preguntas automáticamente con RAGAS
from ragas.testset.generator import TestsetGenerator
from ragas.testset.evolutions import simple, reasoning, multi_context

generator = TestsetGenerator.with_openai()

# Genera preguntas a partir de tus documentos
testset = generator.generate_with_langchain_docs(
    documents=tus_documentos,
    test_size=50,
    distributions={simple: 0.5, reasoning: 0.3, multi_context: 0.2}
)

df = testset.to_pandas()

Revisa siempre las preguntas y respuestas generadas antes de usarlas — el LLM puede generar preguntas que no tienen respuesta clara en los documentos.

Frecuencia de evaluación recomendada

| Evento | Acción | |--------|--------| | Cambio en la estrategia de chunking | Evaluación completa | | Cambio de modelo de embeddings | Evaluación completa | | Cambio en el system prompt de generación | Evaluar faithfulness y answer_relevancy | | Nuevo conjunto de documentos añadido | Evaluar context_precision y recall | | Cada semana en producción | Evaluación ligera (10-20 preguntas) |

Alternativas a RAGAS

• TruLens: similar a RAGAS, con más énfasis en trazabilidad de la cadena completa
• DeepEval: más flexible, permite métricas custom
• LangSmith: evaluación integrada en el ecosistema LangChain con logging detallado

Para la mayoría de equipos que empiezan, RAGAS es la mejor opción por su documentación y facilidad de uso.