ES ▾
Obtener clave de API

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

Dos matraces de vidrio vertiendo luz sobre balanzas iguales para ilustrar la comparación de salidas de proveedores antiguos y nuevos

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ódigo rate_limited si superas el límite por minuto.
  • Sobrecarga temporal. Un 429 con Retry-After: 5 debe 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ñalEjemplo de activación
Comprobaciones fallidas en el tráfico en vivoMás de tu parte acordada falla en las comprobaciones de reglas
Tasa de HTTP 429 o 5xxSostenido por encima de la línea de base de la ruta antigua
Latencia p95Por encima del presupuesto de tiempo de espera de tu producto
Coste por peticiónPor encima de la estimación con un margen establecido
Informes de usuariosUn 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.

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.

Obtener clave de API