CI/CD para IA: Evaluaciones automatizadas
En esta página
Lección actualizada el 3 de noviembre de 2026 según la documentación de OpenAI:
temperatureytop_psolo se aceptan con un esfuerzo de razonamiento denone, mientras que los modelos GPT-5.6 razonan por defecto (medium). Por tanto, las llamadas que establezcan estos parámetros deben especificarreasoning={"effort": "none"}(API de Responses) oreasoning_effort="none"(Chat Completions). Fuentes: Uso de GPT-6 · GPT-5.6 Terra.
Integración de evaluaciones en tu pipeline de CI/CD
Desplegar un cambio en un prompt a producción sin evaluación es como desplegar código sin pruebas. La comparación es más acertada de lo que parece: en ambos casos, el cambio parece trivial, se ha verificado manualmente en uno o dos ejemplos y el efecto secundario aparece tres días después para un usuario que no te lo comunicará. La diferencia es que una regresión en un prompt no lanza una excepción; la aplicación sigue respondiendo, solo que peor.
El objetivo es convertir la evaluación automatizada en una puerta obligatoria en tu proceso de despliegue, garantizando que cada cambio mantenga o mejore la calidad. Eso es exactamente lo que veremos a continuación.
El principio: una puerta, no un informe
El pipeline de evaluación se integra en tu flujo de despliegue mediante un mecanismo familiar. Un desarrollador modifica un prompt o un parámetro, el commit activa el pipeline de CI y las evaluaciones se ejecutan automáticamente contra el conjunto de datos de referencia. Si las puntuaciones cumplen los umbrales, el despliegue continúa; de lo contrario, se bloquea, generando un informe detallado que indica qué evaluación ha fallado y en qué medida.
El punto crítico es ese comportamiento de bloqueo. Un CI que produce un informe bonito sin detener el pipeline se convierte en un artefacto que nadie consulta pasadas dos semanas. Solo un código de salida distinto de cero convierte la medición en una barrera de seguridad.
El siguiente script lee una configuración, carga cada conjunto de datos, ejecuta los casos y compara la puntuación media con el umbral declarado. El método de puntuación —inclusión simple de palabras clave— es intencionadamente rudimentario: una comprobación de CI debe ser rápida, determinista e independiente de un juez cuya puntuación podría variar de una ejecución a otra.
import json
import sys
import openai
from pathlib import Path
client = openai.OpenAI()
def load_eval_config(path: str = "evals/config.json") -> dict:
"""Carga la configuración de evaluación."""
with open(path) as f:
return json.load(f)
def load_dataset(path: str) -> list[dict]:
"""Carga un conjunto de datos JSONL."""
cases = []
with open(path) as f:
for line in f:
cases.append(json.loads(line))
return cases
def run_ci_evals(config: dict) -> dict:
"""Ejecuta evaluaciones para CI."""
results = {}
for eval_config in config["evaluations"]:
name = eval_config["name"]
dataset = load_dataset(eval_config["dataset"])
threshold = eval_config["min_threshold"]
model = eval_config["model"]
prompt = Path(eval_config["prompt_file"]).read_text()
scores = []
for case in dataset:
response = client.responses.create(
model=model,
reasoning={"effort": "none"}, # temperature requiere effort none
instructions=prompt,
input=case["input"],
temperature=0.0,
)
# Evaluación simple por inclusión de palabras clave
if "keywords" in case:
response_lower = response.output_text.lower()
found = sum(
1 for word in case["keywords"]
if word.lower() in response_lower
)
score = found / len(case["keywords"])
else:
score = 1.0 # Sin criterio específico
scores.append(score)
avg_score = sum(scores) / len(scores)
passed = avg_score >= threshold
results[name] = {
"score": avg_score,
"threshold": threshold,
"passed": passed,
"num_cases": len(dataset),
}
return results
def ci_report(results: dict) -> tuple[str, bool]:
"""Genera un informe para CI e indica si todo está correcto."""
lines = ["# Informe de evaluación de IA\n"]
all_pass = True
for name, r in results.items():
status = "PASS" if r["passed"] else "FAIL"
if not r["passed"]:
all_pass = False
lines.append(
f"- [{status}] {name}: {r['score']:.2%} "
f"(umbral: {r['threshold']:.0%}, {r['num_cases']} casos)"
)
report = "\n".join(lines)
return report, all_pass
Observa que el prompt se lee desde un archivo en lugar de escribirse directamente en el script. Esto es lo que hace posible el desencadenante: un prompt versionado en el repositorio produce un diff, y un diff puede activar una evaluación. Mientras tus prompts vivan como literales de cadena dispersos por el código de tu aplicación, la automatización adecuada no será posible.
La configuración declara una evaluación por tarea, cada una con su propio umbral.
{
"evaluations": [
{
"name": "ticket-classification",
"dataset": "evals/datasets/classification.jsonl",
"prompt_file": "prompts/classification.txt",
"model": "gpt-5.6-terra",
"min_threshold": 0.90
},
{
"name": "resume-generation",
"dataset": "evals/datasets/resumes.jsonl",
"prompt_file": "prompts/resume.txt",
"model": "gpt-5.6-terra",
"min_threshold": 0.75
}
]
}
La brecha entre estos dos umbrales es el corazón del método. La clasificación de tickets es una tarea cerrada: por debajo de 0,90, la función no ofrece el servicio esperado. La generación de resúmenes es una tarea abierta, juzgada por palabras clave que un buen texto podría legítimamente formular de manera diferente; exigir 0,90 bloquearía cada despliegue y llevaría rápidamente a desactivar la comprobación. Calibra cada umbral basándote en las puntuaciones observadas en producción, no en un número redondo que resulte tranquilizador.
Conexión de todo en GitHub Actions
El flujo de trabajo se activa solo en rutas relevantes —prompts, evaluaciones, código de integración de IA—, de modo que un cambio en una hoja de estilos no consuma llamadas a la API.
# .github/workflows/eval-ai.yml
name: AI Evaluation
on:
pull_request:
paths:
- "prompts/**"
- "evals/**"
- "src/ai/**"
jobs:
evaluate:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: "3.12"
- run: pip install openai
- name: Run evals
env:
OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
run: python evals/run_ci.py
- name: Publish report
if: always()
uses: actions/upload-artifact@v4
with:
name: eval-report
path: evals/report.md
Dos detalles merecen atención. La clave de la API se pasa a través de los secretos del repositorio, nunca a través del archivo de flujo de trabajo, que es legible por cualquiera con acceso al código. Y la publicación del informe usa if: always(), de lo contrario el artefacto no se produciría cuando las evaluaciones fallan, que es precisamente el único caso en el que necesitas leerlo.
El script de entrada une todo: escribe el informe en el disco para el artefacto, lo imprime en los registros y establece el código de salida que permite o bloquea el resto del pipeline.
#!/usr/bin/env python3
"""Script de evaluación para CI — evals/run_ci.py"""
import sys
from pathlib import Path
def main():
config = load_eval_config("evals/config.json")
results = run_ci_evals(config)
report, all_pass = ci_report(results)
# Escribir el informe
Path("evals/report.md").write_text(report)
print(report)
# Código de salida para CI
if not all_pass:
print("\nAlgunas evaluaciones han fallado. Despliegue bloqueado.")
sys.exit(1)
else:
print("\nTodas las evaluaciones han pasado.")
sys.exit(0)
if __name__ == "__main__":
main()
Comparar en lugar de juzgar en términos absolutos
Un umbral fijo responde a la pregunta «¿Es esto suficientemente bueno?». No responde a «¿Es esto mejor que antes?», que a menudo es la pregunta real. Un prompt reescrito puede mantenerse por encima del umbral mientras pierde tres puntos respecto a la versión anterior: el CI se pone en verde y la degradación entra en producción sin que nadie lo note.
La prueba de regresión ejecuta, por tanto, ambas versiones sobre el mismo conjunto de datos, en la misma campaña, y compara las medias. Una tolerancia del 5 % absorbe el ruido inherente a las salidas generativas; más allá de eso, el veredicto es explícito.
def prompt_regression_test(
current_prompt: str,
previous_prompt: str,
dataset: list[dict],
model: str,
degradation_threshold: float = 0.05,
) -> dict:
"""Verifica que un nuevo prompt no degrade el rendimiento."""
scores_current = []
scores_previous = []
for case in dataset:
# Evaluar con el prompt actual
r1 = client.responses.create(
model=model, instructions=current_prompt,
reasoning={"effort": "none"}, # temperature requiere effort none
input=case["input"], temperature=0.0,
)
# Evaluar con el prompt anterior
r2 = client.responses.create(
model=model, instructions=previous_prompt,
reasoning={"effort": "none"}, # temperature requiere effort none
input=case["input"], temperature=0.0,
)
s1 = evaluate_response(r1.output_text, case)
s2 = evaluate_response(r2.output_text, case)
scores_current.append(s1)
scores_previous.append(s2)
avg_current = sum(scores_current) / len(scores_current)
avg_previous = sum(scores_previous) / len(scores_previous)
delta = avg_current - avg_previous
return {
"current_score": avg_current,
"previous_score": avg_previous,
"delta": delta,
"regression": delta < -degradation_threshold,
"verdict": "OK" if delta >= -degradation_threshold else "REGRESSION",
}
Esta prueba duplica el número de llamadas y, por tanto, el coste y la duración. Resérvala para cambios en los prompts, manteniéndola fuera de la ruta de los commits ordinarios, y ejecútala sobre un subconjunto representativo en lugar de sobre todo tu conjunto de datos de referencia.
Puntos clave
- Integra las evaluaciones en tu pipeline de CI/CD como si fueran pruebas unitarias.
- Versiona los prompts en archivos: sin un diff, no es posible ningún desencadenante.
- Define umbrales mínimos por tipo de evaluación, calibrados con datos de producción.
- Bloquea los despliegues mediante el código de salida cuando las puntuaciones caigan por debajo de los umbrales.
- Prueba las regresiones comparando los prompts nuevos y antiguos sobre el mismo conjunto de datos.