04-05-02 — RAGAS, DeepEval e frameworks de avaliação

O problema de avaliar RAG manualmente

Um pipeline RAG tem dois subsistemas para avaliar: o retriever (buscou os chunks certos?) e o generator (gerou uma resposta fiel ao que foi recuperado?). Fazer isso manualmente não escala — cada mudança de chunking, embedding ou prompt requer nova rodada de avaliação.

A solução é LLM-as-judge: usar um modelo (geralmente GPT-4o) para avaliar automaticamente a saída de outro modelo, calculando métricas objetivas a partir de prompts calibrados.

RAGAS — Reference-free Automated Evaluation

RAGAS (github.com/explodinggradients/ragas) é open-source e calcula quatro métricas core sem precisar de ground-truth manual para todas elas:

Exemplo Python com RAGAS

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

# Dataset no formato esperado pelo RAGAS
data = {
    "question": [
        "Qual é o prazo de entrega padrão?",
        "Como cancelar um pedido?",
    ],
    "answer": [
        "O prazo padrão é de 5 a 7 dias úteis.",
        "Pedidos podem ser cancelados em até 24 horas após a confirmação.",
    ],
    "contexts": [
        ["Nossos pedidos têm prazo de entrega de 5 a 7 dias úteis para todo o Brasil."],
        ["Cancelamentos são aceitos até 24 horas após a confirmação do pedido via e-mail."],
    ],
    "ground_truth": [
        "5 a 7 dias úteis",
        "Até 24 horas após a confirmação",
    ],
}

dataset = Dataset.from_dict(data)

# Avaliação (usa OpenAI por padrão como LLM juiz)
result = evaluate(
    dataset=dataset,
    metrics=[faithfulness, answer_relevancy, context_precision, context_recall],
)

print(result)
# {'faithfulness': 0.96, 'answer_relevancy': 0.91,
#  'context_precision': 0.88, 'context_recall': 0.85}

# Exportar para análise
df = result.to_pandas()
df.to_csv("ragas_results.csv", index=False)

DeepEval — Framework para CI/CD

DeepEval (github.com/confident-ai/deepeval) posiciona RAG evaluation como parte do ciclo de desenvolvimento, integrando com pytest e pipelines de CI.

Conceitos chave do DeepEval

• LLMTestCase: unidade atômica de teste — input, actual output, retrieval context
• Metrics: GEval, AnswerRelevancyMetric, FaithfulnessMetric, ContextualPrecisionMetric, HallucinationMetric e outros
• assert_test(): integra com pytest — falha o build se métricas caírem abaixo do threshold
• Confident AI: dashboard SaaS para tracking de métricas ao longo do tempo

from deepeval import assert_test
from deepeval.test_case import LLMTestCase
from deepeval.metrics import (
    AnswerRelevancyMetric,
    FaithfulnessMetric,
    ContextualRecallMetric,
)

# Definir métricas com threshold mínimo
answer_relevancy = AnswerRelevancyMetric(threshold=0.7, model="gpt-4o-mini")
faithfulness = FaithfulnessMetric(threshold=0.8, model="gpt-4o-mini")
contextual_recall = ContextualRecallMetric(threshold=0.75, model="gpt-4o-mini")

# Criar test case
test_case = LLMTestCase(
    input="Quais documentos são necessários para abrir uma conta?",
    actual_output="Para abrir uma conta você precisa de RG, CPF e comprovante de residência.",
    expected_output="RG, CPF e comprovante de residência atualizado (últimos 3 meses).",
    retrieval_context=[
        "Documentos necessários: RG ou CNH, CPF e comprovante de residência dos últimos 3 meses.",
        "Menores de 18 anos precisam também de autorização dos responsáveis.",
    ],
)

# Em teste pytest: falha o CI se qualquer métrica estiver abaixo do threshold
assert_test(test_case, [answer_relevancy, faithfulness, contextual_recall])

# pytest - rodar avaliação de regressão completa
# pytest test_rag_pipeline.py -v

# Integração com GitHub Actions
# .github/workflows/rag-eval.yml:
# - run: pip install deepeval
# - run: deepeval test run test_rag_pipeline.py

Azure AI Evaluations

Para quem já está no Azure AI Foundry, a Microsoft oferece avaliação gerenciada via SDK e interface visual. As métricas disponíveis para RAG incluem: groundedness (equivalente ao faithfulness), relevance, coherence e fluency.

import os
from azure.ai.evaluation import (
    evaluate,
    GroundednessEvaluator,
    RelevanceEvaluator,
    CoherenceEvaluator,
)
from azure.ai.evaluation import AzureOpenAIModelConfiguration

# Configuração do modelo juiz
model_config = AzureOpenAIModelConfiguration(
    azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
    api_key=os.environ["AZURE_OPENAI_API_KEY"],
    azure_deployment="gpt-4o",
    api_version="2024-08-01-preview",
)

# Inicializar avaliadores
groundedness_eval = GroundednessEvaluator(model_config=model_config)
relevance_eval = RelevanceEvaluator(model_config=model_config)

# Dataset de teste (JSONL ou dict)
eval_data = "rag_test_data.jsonl"  # {query, response, context}

# Executar avaliação com log no Azure AI Foundry
result = evaluate(
    data=eval_data,
    evaluators={
        "groundedness": groundedness_eval,
        "relevance": relevance_eval,
    },
    azure_ai_project={
        "subscription_id": os.environ["AZURE_SUBSCRIPTION_ID"],
        "resource_group_name": "rg-ai",
        "project_name": "meu-projeto-ai",
    },
    output_path="./eval_results.json",
)

print(f"Groundedness médio: {result['metrics']['groundedness.groundedness']:.2f}")
print(f"Relevance médio: {result['metrics']['relevance.relevance']:.2f}")

Quando usar cada framework