LLM evals: como medir se seu modelo presta

def eval_contains(response, expected_terms):
    """Verifica se termos esperados estão na resposta."""
    score = sum(1 for term in expected_terms if term.lower() in response.lower())
    return score / len(expected_terms)

# Exemplo
resposta = "Use kubectl delete namespace meu-ns para remover o namespace"
esperado = ["kubectl", "delete", "namespace"]
score = eval_contains(resposta, esperado)  # 1.0 (contém tudo)

from openai import AzureOpenAI
import numpy as np

def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

def eval_similarity(response, reference, client):
    """Compara semântica da resposta com referência."""
    resp_embedding = client.embeddings.create(
        input=response, model="text-embedding-3-small"
    ).data[0].embedding
    
    ref_embedding = client.embeddings.create(
        input=reference, model="text-embedding-3-small"
    ).data[0].embedding
    
    return cosine_similarity(resp_embedding, ref_embedding)

import json

def eval_llm_judge(question, response, reference, client):
    """Usa GPT-4o como juiz de qualidade."""
    
    judge_prompt = """Avalie a resposta do assistente comparando com a referência.
    
Critérios (0-5 cada):
- Correção factual: informações estão corretas?
- Completude: respondeu tudo que foi perguntado?
- Clareza: fácil de entender e aplicar?
- Segurança: não sugere ações perigosas sem avisos?

Retorne JSON: {"correção": N, "completude": N, "clareza": N, "segurança": N, "nota_final": N, "justificativa": "..."}
"""
    
    result = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": judge_prompt},
            {"role": "user", "content": f"""
Pergunta: {question}
Resposta do assistente: {response}
Resposta de referência: {reference}
"""}
        ],
        response_format={"type": "json_object"},
        temperature=0
    )
    
    return json.loads(result.choices[0].message.content)

{
  "id": "eval-001",
  "question": "Como verificar se a replicação do PostgreSQL está saudável?",
  "expected_answer": "Executar SELECT * FROM pg_stat_replication no primário. Verificar que sent_lsn e replay_lsn estão próximos (lag < 1MB). Se replay_lsn estiver muito atrás, verificar network e I/O no standby.",
  "expected_terms": ["pg_stat_replication", "sent_lsn", "replay_lsn"],
  "category": "database",
  "difficulty": "medium"
}

import json
from datetime import datetime

def run_eval_suite(eval_dataset, rag_pipeline, client, output_file):
    """Roda suite de evals e salva resultados."""
    results = []
    
    for item in eval_dataset:
        # Gerar resposta do sistema
        response = rag_pipeline.query(item["question"])
        
        # Avaliar
        contains_score = eval_contains(response, item["expected_terms"])
        judge_result = eval_llm_judge(
            item["question"], response, item["expected_answer"], client
        )
        
        results.append({
            "id": item["id"],
            "category": item["category"],
            "contains_score": contains_score,
            "judge_scores": judge_result,
            "response": response,
            "timestamp": datetime.now().isoformat()
        })
    
    # Salvar resultados
    with open(output_file, "w", encoding="utf-8") as f:
        json.dump(results, f, indent=2)
    
    # Calcular agregados
    avg_score = sum(r["judge_scores"]["nota_final"] for r in results) / len(results)
    print(f"Score médio: {avg_score:.2f}/5.0")
    print(f"Contains score: {sum(r['contains_score'] for r in results)/len(results):.2%}")
    
    return results

# .github/workflows/eval.yml
name: LLM Eval Suite
on:
  pull_request:
    paths:
      - 'prompts/**'
      - 'rag/**'
      - 'config/**'

jobs:
  eval:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Run eval suite
        env:
          AZURE_OPENAI_KEY: ${{ secrets.AZURE_OPENAI_KEY }}
          AZURE_OPENAI_ENDPOINT: ${{ secrets.AZURE_OPENAI_ENDPOINT }}
        run: |
          python -m pip install -r requirements.txt
          python run_evals.py --dataset evals/golden.json --output results.json
      
      - name: Check regression
        run: |
          python check_regression.py \
            --current results.json \
            --baseline evals/baseline.json \
            --threshold 0.05
          # Falha se score caiu mais que 5% vs baseline

def eval_rag_faithfulness(response, context_chunks, client):
    """Avalia se a resposta é fiel ao contexto fornecido."""
    
    prompt = f"""Analise se CADA afirmação na resposta é suportada pelo contexto.

Contexto fornecido:
{chr(10).join(context_chunks)}

Resposta do assistente:
{response}

Para cada afirmação na resposta, indique:
- SUPORTADA: está no contexto
- NÃO SUPORTADA: não está no contexto (possível alucinação)
- PARCIAL: parcialmente suportada

Retorne JSON: {{"afirmacoes": [...], "score_faithfulness": 0.0-1.0}}
"""
    
    result = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}],
        response_format={"type": "json_object"},
        temperature=0
    )
    
    return json.loads(result.choices[0].message.content)

# promptfoo: exemplo de eval via CLI
npm install -g promptfoo

# Configurar eval
cat > promptfooconfig.yaml << 'EOF'
providers:
  - id: azure-gpt-4o
    provider: azure-openai
    apiKey: $AZURE_OPENAI_API_KEY
    apiHost: https://meu-endpoint.openai.azure.com
    deployment: gpt-4o
    apiVersion: "2024-06-01"
    model: gpt-4o

prompts:
  - file://prompts/system-v1.txt
  - file://prompts/system-v2.txt

tests:
  - vars:
      question: "Como verificar replicação PostgreSQL?"
    assert:
      - type: contains
        value: "pg_stat_replication"
      - type: llm-rubric
        value: "A resposta inclui comandos SQL específicos e explica o que verificar"
  - vars:
      question: "Qual o procedimento de failover?"
    assert:
      - type: contains
        value: "DR-003"
      - type: llm-rubric
        value: "Menciona pré-requisitos e tem passos claros"
EOF

# Rodar
promptfoo eval
promptfoo view  # abre dashboard com resultados