Pruebas de migración de API para aplicaciones LLM: un plan práctico
La prueba de migración de API para una app LLM es diferente a probar una API REST normal, porque el mismo prompt nunca devuelve el mismo texto dos veces. Tú pruebas propiedades de la respuesta, no cadenas exactas.
Última actualización

Resumen
- Construye un conjunto de referencia de 50 a 200 prompts reales con comprobaciones basadas en reglas, no con expectativas de coincidencia exacta.
- Fija la temperatura y la semilla para reducir el ruido, pero nunca esperes texto idéntico.
- Registra percentiles de latencia y costo por petición en la ruta antigua y la nueva.
- Escribe los disparadores de reversión antes de que comience el despliegue.
Qué estás probando realmente
Con una API clásica comparas las respuestas byte a byte. Con un modelo de lenguaje, falla inmediatamente. En su lugar, decide qué propiedades de una respuesta depende tu producto y pruébalas.
- Formato. JSON válido, claves obligatorias, una llamada a función con los argumentos correctos.
- Contenido. Menciona los hechos requeridos, sigue el formato y se mantiene en el rol.
- Seguridad del producto. Sin rechazo donde se espera una respuesta, sin fuga del prompt del sistema.
- Operaciones. Latencia, tasa de error, comportamiento del límite de peticiones, costo.
Si aún necesitas los pasos de cambio, el plan está en la guía de migración en este sitio, y los fallos que encuentres se cubren en errores comunes de integración LLM. Este artículo cubre la verificación.
Construye el conjunto de prompts de referencia
Extrae de 50 a 200 prompts reales de tus registros (elimina primero los datos personales). Cubre el flujo normal, los casos incómodos y los casos que fallaron antes. Almacena cada uno como un registro con sus mensajes, parámetros y las comprobaciones que debe pasar.
{
"id": "invoice-json-03",
"messages": [
{"role": "system", "content": "Extract fields. Reply with JSON only."},
{"role": "user", "content": "Invoice 4471 from Acme, total 1,250 EUR, due 2025-03-01"}
],
"json": true,
"required_keys": ["number", "vendor", "total"],
"must_contain": ["4471"]
}
Etiqueta los casos por riesgo: llamadas a funciones, contexto largo, streaming, no inglés, respuestas muy cortas y muy largas. Cuando aparezca un error en producción más tarde, añádelo al conjunto. El conjunto se convierte en tu conjunto de pruebas de regresión.
Escribe un marco que registre todo
Un script debe ejecutar todo el conjunto contra una ruta, aplicar las comprobaciones y guardar los números. Usa temperature=0 y un seed fijo para reducir la variación. Ambos se pasan por esta API, pero trátalos como reducción de ruido, no como garantía.
import json, time
from openai import OpenAI
client = OpenAI(base_url="https://api.apimigration.com/v1", api_key="YOUR_KEY")
PRICE_IN, PRICE_OUT = 0.15, 0.50 # USD per 1M tokens
def run(case):
t0 = time.perf_counter()
raw = client.chat.completions.with_raw_response.create(
model="uncensored",
messages=case["messages"],
temperature=0,
seed=42,
)
elapsed = time.perf_counter() - t0
resp = raw.parse()
text = resp.choices[0].message.content or ""
u = resp.usage
return {
"id": case["id"],
"text": text,
"seconds": elapsed,
"cost": (u.prompt_tokens * PRICE_IN + u.completion_tokens * PRICE_OUT) / 1e6,
"balance": raw.headers.get("X-Balance-USD"),
"request_id": raw.headers.get("X-Request-Id"),
}
Mantén el X-Request-Id para cada caso fallido. Es lo que citas cuando pides soporte sobre una petición específica.
Diferencia por reglas, no por cadenas
Aplica las comprobaciones de cada registro. Cualquier cosa que falle va a una lista corta para que un humano la lea.
def check(case, text):
problems = []
if case.get("json"):
try:
obj = json.loads(text)
except ValueError:
return ["invalid json"]
for key in case.get("required_keys", []):
if key not in obj:
problems.append("missing key " + key)
for needle in case.get("must_contain", []):
if needle.lower() not in text.lower():
problems.append("missing text " + needle)
if len(text.strip()) < case.get("min_chars", 1):
problems.append("answer too short")
return problems
Para respuestas de texto libre, añade un rango de longitud económico (por ejemplo, entre la mitad y el doble de la respuesta antigua) y una lista corta de frases de rechazo para marcar. Luego lee 20 salidas lado a lado a ojo. Las reglas detectan regresiones; la lectura detecta el tono. Haz ambos.
Para salidas JSON, establece response_format en {"type":"json_object"} y sigue validando, ya que las comprobaciones anteriores son baratas.
Prueba las rutas de fallo a propósito
Los prompts de flujo normal pasan en casi cualquier proveedor. Los fallos son donde las migraciones duelen, así que provócalos deliberadamente antes de que lo hagan los usuarios.
- Clave incorrecta. Envía una petición con una clave incorrecta y confirma que tu app muestra un mensaje sensato y no reintenta en bucle.
- Límites de velocidad. Dispara más de 8 peticiones a la vez con una clave completa (2 con una clave de prueba) y confirma que tu código maneja HTTP 429 con el código
concurrency, luego el códigorate_limitedsi superas el límite por minuto. - Sobrecarga temporal. Un 429 con
Retry-After: 5debe llevar a esperar cinco segundos, no a reintentar inmediatamente. - Entrada sobredimensionada. Envía un prompt cerca de la ventana de 100.000 tokens y uno más allá. Tu app debe recortar o resumir, no fallar.
- Cuerpos grandes. El límite es de 8 MB. Confirma que rechazas tú mismo los payloads más grandes.
- Streams caídos. Mata la conexión a mitad del stream y confirma que la ranura de concurrencia vuelve.
Cada uno de estos debe tener una prueba automatizada que se ejecute en CI contra un servidor falso, más una pasada manual contra el real.
Comprueba streaming y llamadas a funciones
El streaming y las herramientas cambian la forma de la respuesta, por lo que un conjunto de referencia construido en texto plano los omite. Añade un caso para cada uno.
tools = [{
"type": "function",
"function": {
"name": "get_order_status",
"description": "Look up an order by id",
"parameters": {
"type": "object",
"properties": {"order_id": {"type": "string"}},
"required": ["order_id"],
},
},
}]
r = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Where is order A-1042?"}],
tools=tools,
tool_choice="auto",
)
calls = r.choices[0].message.tool_calls or []
assert calls and calls[0].function.name == "get_order_status"
print(calls[0].function.arguments)
La comprobación verifica que la llamada existe y que los argumentos se analizan como el JSON que esperas. Añade una comprobación de que la segunda vuelta, con el resultado enviado como un mensaje con role: "tool", produce una respuesta normal. Para streaming, afirma que los fragmentos llegan, que el uso final aparece y que tu código deja de leer al final del streaming.
Rastrea latencia y costo por ruta
Ejecuta el conjunto en las rutas antigua y nueva y compara las mismas columnas: segundos de mediana y percentil 95, conteo de errores, tokens y costo. Este artículo no proporciona números de latencia para ningún proveedor, porque los tuyos dependerán de tus prompts y de tu red. Mide los tuyos.
El coste para la nueva ruta es el recuento de tokens multiplicado por las tarifas, $0,15 por 1M de entrada y $0,50 por 1M de salida. Ejemplo: 200 prompts dorados que promedian 1.200 tokens de entrada y 300 de salida.
- Entrada: 240.000 tokens x $0,15 / 1.000.000 = $0,036.
- Salida: 60.000 tokens x $0,50 / 1.000.000 = $0,03.
- Una ejecución completa: $0.066.
El crédito de prueba de $0.50 cubre unas siete ejecuciones de este tipo. Una clave de prueba permite 2 peticiones simultáneas y 60 por minuto, por lo que 200 prompts tardan al menos tres minutos y medio. Las peticiones fallidas o rechazadas no se cobran. También puedes leer el saldo desde la cabecera X-Balance-USD después de cada llamada para confirmar tu propia aritmética.
Tráfico sombra y lanzamiento por etapas
Una vez que el conjunto de referencia pase, copia las peticiones reales a la nueva ruta sin mostrar las respuestas. Registra los resultados y compáralos con las respuestas en vivo usando las mismas comprobaciones. Las ejecuciones sombra necesitan un límite de concurrencia: una clave completa permite 8 peticiones a la vez, por lo que encola las llamadas duplicadas en lugar de enviarlas todas a la vez.
Luego mueve a los usuarios reales por pasos, como 5 %, 25 %, 50 % y 100 %. Mantén cada paso hasta que la tasa de errores, las comprobaciones fallidas y las quejas se mantengan estables.
Define las reglas de reversión por anticipado
Escribe los umbrales antes de mover al primer usuario, para que la decisión en el momento sea mecánica.
| Señal | Ejemplo de activación |
|---|---|
| Comprobaciones fallidas en el tráfico en vivo | Más de tu parte acordada falla en las comprobaciones de reglas |
| Tasa de HTTP 429 o 5xx | Sostenido por encima de la línea de base de la ruta antigua |
| Latencia p95 | Por encima del presupuesto de tiempo de espera de tu producto |
| Coste por petición | Por encima de la estimación con un margen establecido |
| Informes de usuarios | Un clúster sobre el mismo comportamiento |
La reversión debe ser un cambio de configuración, no un despliegue. Mantén la ruta antigua financiada y configurada durante al menos unos días después del 100 %. Cuando estés listo para ejecutar las pruebas, obtén una clave de API y reclama la prueba, consulta los precios para ejecuciones más grandes y usa la documentación para los detalles del endpoint.
Más guías
Preguntas frecuentes
¿Cuántos prompts de referencia necesito?
Cincuenta a doscientos prompts reales cubren la mayoría de las aplicaciones. La calidad importa más que la cantidad, así que incluye los casos difíciles y los que antes fallaban.
¿Puedo comparar las salidas con una comparación exacta?
No de forma fiable. Incluso con temperature 0 y una semilla fija, trata las salidas como variables y prueba reglas como JSON válido, hechos requeridos y longitud.
¿Cómo rastrear el costo durante las pruebas?
Multiplica los tokens de uso por $0,15 por 1M de entrada y $0,50 por 1M de salida, y vigila la cabecera X-Balance-USD para el saldo real.
¿Qué debe desencadenar una reversión?
Define los umbrales primero: comprobaciones fallidas, tasas de 429 o 5xx, latencia contra tu tiempo de espera y costo contra la estimación.
Obtén tu clave de API
Regístrate, copia la clave, actualiza la URL base. La configuración está completa.