Concepto clave

La evaluación sistemática de prompts es el proceso de medir objetivamente la calidad y consistencia de tus prompts en producción. Piensa en esto como el control de calidad en una fábrica: no basta con que un producto funcione una vez, debe funcionar bien cada vez, bajo diferentes condiciones, y cumplir especificaciones precisas.

En el desarrollo full stack, esto significa que tus prompts deben ser evaluados no solo por su precisión técnica, sino por su robustez (cómo manejan entradas inesperadas), eficiencia (costo y tiempo de respuesta) y alineación con el negocio (¿resuelven realmente el problema del usuario?). Un prompt mal evaluado es como un puente sin pruebas de carga: puede colapsar cuando más lo necesitas.

Cómo funciona en la práctica

Imagina que desarrollas un asistente para un e-commerce que genera descripciones de productos. La evaluación sistemática implica:

Definir métricas claras: Precisión (¿la descripción coincide con las especificaciones?), relevancia (¿incluye características clave?), tono (¿es consistente con la marca?).
Crear un conjunto de pruebas: 50-100 productos representativos con entradas variadas (datos completos, incompletos, con errores).
Automatizar la evaluación: Scripts que envían cada caso a la API, capturan la respuesta y la comparan con resultados esperados.
Analizar resultados: Identificar patrones de error (ejemplo: el prompt falla con productos de alta gama) y refinar iterativamente.

Código en acción

Evaluador básico para prompts de GPT:

import openai
import json

class PromptEvaluator:
    def __init__(self, api_key):
        self.client = openai.OpenAI(api_key=api_key)
        
    def evaluate_prompt(self, prompt_template, test_cases, expected_criteria):
        results = []
        for case in test_cases:
            # Construir prompt final
            full_prompt = prompt_template.format(**case["input"])
            
            # Llamar a la API
            response = self.client.chat.completions.create(
                model="gpt-4",
                messages=[{"role": "user", "content": full_prompt}],
                temperature=0.7
            )
            
            output = response.choices[0].message.content
            
            # Evaluar contra criterios
            score = self._score_output(output, case["expected"], expected_criteria)
            results.append({
                "input": case["input"],
                "output": output,
                "score": score,
                "passed": score >= 0.8  # Umbral del 80%
            })
        return results
    
    def _score_output(self, actual, expected, criteria):
        # Lógica de puntuación según tus criterios
        score = 0
        if "keywords" in criteria:
            # Verificar palabras clave esperadas
            matches = sum(1 for kw in expected["keywords"] if kw in actual.lower())
            score += (matches / len(expected["keywords"])) * 0.4
        if "length" in criteria:
            # Verificar longitud apropiada
            ideal_length = expected.get("length", 100)
            length_diff = abs(len(actual) - ideal_length)
            score += max(0, 1 - (length_diff / ideal_length)) * 0.3
        # Agregar más criterios según necesidad
        return min(score, 1.0)

# Uso
evaluator = PromptEvaluator("tu-api-key")
test_cases = [
    {
        "input": {"product": "Laptop Gaming", "features": "RTX 4070, 32GB RAM"},
        "expected": {"keywords": ["gaming", "rtx", "ram"], "length": 120}
    }
]
results = evaluator.evaluate_prompt(
    "Genera una descripción atractiva para {product} con estas características: {features}",
    test_cases,
    ["keywords", "length"]
)
print(json.dumps(results, indent=2))

Refactorización para evaluar múltiples modelos (antes y después):

Antes (solo GPT):

response = openai.ChatCompletion.create(
    model="gpt-4",
    messages=[{"role": "user", "content": prompt}]
)

Después (multi-modelo):

class MultiModelEvaluator:
    def __init__(self, gpt_key, claude_key):
        self.gpt_client = openai.OpenAI(api_key=gpt_key)
        self.claude_client = anthropic.Anthropic(api_key=claude_key)
    
    def evaluate_on_model(self, model, prompt):
        if model == "gpt-4":
            response = self.gpt_client.chat.completions.create(
                model=model,
                messages=[{"role": "user", "content": prompt}]
            )
            return response.choices[0].message.content
        elif model == "claude-3":
            response = self.claude_client.messages.create(
                model="claude-3-opus-20240229",
                max_tokens=1000,
                messages=[{"role": "user", "content": prompt}]
            )
            return response.content[0].text
        else:
            raise ValueError(f"Modelo no soportado: {model}")

Errores comunes

Evaluar solo con casos ideales: Usar solo entradas perfectas da una falsa sensación de éxito. Incluye casos límite (datos incompletos, ambiguos, con errores tipográficos).
Ignorar el costo: No medir tokens consumidos por evaluación. Un prompt preciso pero que cuesta 10 veces más no es viable en producción.
Falta de criterios cuantificables:"Suena bien" no es una métrica. Define criterios medibles como: "Incluye al menos 3 características específicas", "Longitud entre 80-150 palabras".
No versionar los prompts: Cambias un prompt y pierdes la capacidad de comparar con versiones anteriores. Usa Git para prompts como lo harías con código.
Olvidar el contexto de integración: Evaluar el prompt aislado, no dentro del flujo completo de la aplicación. El mismo prompt puede comportarse diferente según cómo se integre.

Checklist de dominio

¿Tienes un conjunto de pruebas con al menos 50 casos representativos de tu dominio?
¿Has definido 3-5 métricas cuantificables para evaluar la calidad de los outputs?
¿Tu sistema de evaluación puede ejecutarse automáticamente (CI/CD) ante cambios en prompts?
¿Estás monitoreando el costo por evaluación y tienes alertas para picos inesperados?
¿Comparas el rendimiento de diferentes modelos (GPT vs Claude) para el mismo uso caso?
¿Documentas cada iteración de prompt con sus resultados de evaluación?
¿Has probado tus prompts con usuarios reales, no solo con evaluación automática?

Implementa un sistema de evaluación para prompts de recomendación de productos

Desarrolla un evaluador de prompts para un sistema que recomienda productos complementarios en un e-commerce.

Configura el entorno: Crea un proyecto Python con virtualenv. Instala las librerías necesarias: openai, anthropic, pytest.
Diseña los casos de prueba: Crea un archivo test_cases.json con 10 productos diferentes. Cada caso debe incluir:
- Producto principal (ej: "cafetera espresso")
- Categoría (ej: "electrodomésticos")
- Precio (ej: 299.99)
- Resultado esperado: lista de 3-5 productos complementarios relevantes
Implementa el evaluador:
- Crea una clase RecommendationEvaluator que tome un prompt template y los casos de prueba.
- Implementa el método evaluate() que envíe cada caso a GPT-4 y Claude-3.
- Define métricas: relevancia (¿los productos recomendados son lógicos?), diversidad (¿no se repiten?), especificidad (¿menciona productos concretos o solo categorías?).
Ejecuta y analiza:
- Ejecuta la evaluación con dos versiones de prompt: una básica ("Recomienda productos complementarios para {product}") y una avanzada (que incluya categoría y precio).
- Genera un reporte comparativo: precisión por modelo, costo por evaluación, tiempo de respuesta.
- Identifica en qué casos falla cada prompt y propone mejoras.
Integración básica: Crea un endpoint REST simple (/evaluate) que reciba un prompt y devuelva los resultados de evaluación.

Pistas

Usa el parámetro temperature=0 para evaluaciones más consistentes
Considera usar embeddings para medir similitud semántica entre productos recomendados y esperados
No olvides manejar errores de API (timeouts, rate limits) en tu evaluador

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.

Evaluación final del proyecto integrador

Quiz Interactivo