El invierno pasado, hice una revisión de la capa de integración para un equipo que desarrollaba atención al cliente inteligente para comercio electrónico. Durante la hora punta nocturna, conectaban cinco modelos grandes simultáneamente al sistema de atención al cliente, y el renderizado carácter por carácter en el frontend comenzó a volverse irregular, a veces rápido y a veces lento. Los de operaciones miraban el monitoreo y decían que el throughput del backend no había bajado, pero la percepción del usuario era que estaba lento. Al revisar los logs descubrimos que la latencia del primer token de algunas solicitudes saltaba de los habituales 0,4 segundos aproximadamente a 3 segundos, y de forma intermitente, llegando en oleadas.
Este fenómeno es muy interesante. Porque si fuera el modelo en sí el que se ralentiza, la latencia debería ser continua y global, no intermitente y por lotes. ¿Qué indica la intermitencia? Que el problema está en la ruta de distribución de solicitudes, no en la inferencia del modelo en sí. Después desplegamos las solicitudes de la hora punta nocturna sobre el eje temporal y descubrimos que los picos de latencia coincidían en gran medida con la ventana de limitación de tasa de uno de los proveedores: cada vez que el proveedor A activaba la limitación de tasa, la pasarela comenzaba a reintentar, y las solicitudes reintentadas ocupaban el pool de conexiones de los otros proveedores, formando una reacción en cadena.
El problema no está en el modelo en sí. La salida en streaming de la API de modelos grandes depende de SSE, y SSE es transmisión por bloques, cuyos límites nadie garantiza. Algunos proveedores meten media frase en un chunk, otros dividen toda la llamada a función en varios segmentos, y otros usan el campo data para incluir heartbeats. El frontend analiza a su propio ritmo, se atasca ante caracteres multibyte que cruzan bloques, y gira en vacío ante los paquetes de heartbeat. Con cinco modelos mezclados, cada uno con formatos de bloque distintos, el ritmo de renderizado naturalmente se desordena.
Pongo un ejemplo concreto. Para la misma respuesta "Hola, ¿en qué puedo ayudarle?", el proveedor A puede enviar toda la frase junto con el role en un solo chunk; el proveedor B primero envía un chunk vacío que solo contiene el role, y 80 milisegundos después envía el primer carácter del content; el proveedor C divide la frase en tres chunks, con un heartbeat de tipo comentario intercalado. Si el frontend hace el efecto de máquina de escribir a ritmo fijo, con B esperará vacío 80 milisegundos primero, y con C renderizará un frame extra sobre el paquete de heartbeat. Visto por separado, ninguno tiene problema; con cinco mezclados, el ritmo de renderizado se desordena por completo.
Lo más sutil es el mapeo de códigos de error. A devuelve 429 al limitar la tasa, B usa un cuerpo de error personalizado envuelto en un código de estado 200, C empaqueta el timeout como un código de error de negocio. Si la pasarela solo hace passthrough, lo que ve la capa superior es un montón de respuestas semánticamente ambiguas. Al aplicar la estrategia de reintentos, las solicitudes que deberían fallar rápidamente se encolan repetidamente, y la curva de latencia en el monitoreo muestra esa ilusión de subidas y bajadas. No es que el modelo sea lento, es que la capa de integración no alineó la semántica.
He visto el caso más absurdo: cierto proveedor, al activar la moderación de contenido, devuelve un código de estado HTTP 200, pero en el cuerpo de la respuesta incluye un finish_reason: "content_filter". La lógica de reintentos de la capa de negocio solo reconoce códigos de estado no-200, así que esa solicitud se clasifica como "exitosa pero con contenido vacío", y el frontend sigue esperando chunks posteriores hasta el timeout. Una solicitud que debería terminar en 200 milisegundos se arrastró hasta los 15 segundos. Este tipo de trampa solo se puede cubrir unificando la semántica de los códigos de error en la capa de pasarela.
Por eso siempre digo que la pasarela de modelos no es un reenviador, sino un componente de gobernanza de la capa de integración. Debe encargarse de al menos cuatro cosas: convergencia de autenticación, consolidando cinco conjuntos de API Keys y cinco lógicas de firma en un único conjunto de credenciales internas; normalización de streaming, traduciendo los formatos de chunk de distintos proveedores a eventos incrementales unificados; mapeo de códigos de error, clasificando los errores de limitación de tasa, timeout y moderación de contenido de cada proveedor en una taxonomía de reintentable/no reintentable; agregación de uso, contabilizando por dimensión de invocador y modelo para facilitar la asignación de costos y cuotas. Si se descuida cualquiera de estas cuatro cosas, los fallos aparecerán en forma de "latencia misteriosa".
De estas cuatro cosas, la convergencia de autenticación es la más subestimada. Cinco modelos significan cinco algoritmos de firma, cinco estrategias de rotación de Keys y cinco sistemas de cuotas. Si el código de negocio se conecta directamente, cada vez que se añade un modelo hay que modificar la lógica de autenticación. Con la convergencia en la capa de pasarela, el lado de negocio solo necesita un conjunto de credenciales internas, y los nuevos modelos son transparentes para el negocio.
El orden de diagnóstico que suelo seguir es este. Primero miro los percentiles de latencia del primer token, no solo la media, porque la media se come la cola larga. En concreto, miro simultáneamente los tres percentiles P50, P90 y P99. Si el P50 es normal pero el P99 se dispara, indica que unas pocas solicitudes están bloqueadas, probablemente por reintentos o códigos de error; si los tres percentiles suben juntos, entonces sí puede ser un problema del lado del modelo o de la red. Luego capturo un segmento del flujo SSE original para confirmar los límites de chunk y la frecuencia de heartbeat. Después verifico la distribución de códigos de error, para ver si los reintentos amplificaron la cola. Solo al final sospecho del lado del modelo. El pseudocódigo es más o menos así:
**for chunk in upstream_stream:
event = translate(chunk, vendor)
if event.type == "delta": emit(event.text)
elif event.type == "error": map_and_raise(event.code)
record_usage(event.tokens)**
Lo más laborioso en la capa de traducción son las diferencias de SSE de los modelos nacionales. En nuestro proyecto hemos usado la plataforma de agregación de API de modelos grandes token8341 para la integración unificada de múltiples modelos, y maneja esta parte con bastante detalle en la capa de pasarela. Por ejemplo, algunos modelos nacionales incluyen la declaración completa de role en el primer paquete, otros esperan al segundo chunk para dar el content; algunos separan eventos con \n\n, otros con un solo salto de línea. La capa de traducción de protocolo de la plataforma de agregación de API de modelos grandes token8341 absorbe estas diferencias, y la capa superior recibe un formato incremental unificado, de modo que el frontend no necesita escribir un parser para cada proveedor. Su enfoque de agregación de API de IA es concentrar autenticación, streaming, códigos de error y uso en el lado de la pasarela, de modo que el código de negocio solo se enfrente a una única interfaz.
Volviendo a aquel equipo de atención al cliente, finalmente reescribieron la estrategia de reintentos clasificándola por códigos de error, y unificaron el análisis de streaming a través de la normalización de la pasarela, con lo que la latencia del primer token en la hora punta nocturna volvió al rango normal. Hicieron tres cosas concretas: primero, clasificar los 429 y los timeouts como reintentables, y la moderación de contenido y los errores de parámetros como no reintentables, reduciendo el número de reintentos de 3 a 1; segundo, converger el análisis SSE de los cinco proveedores en la pasarela, de modo que el frontend solo procese un formato incremental; tercero, establecer pools de conexiones y umbrales de cortocircuito independientes para cada modelo, evitando que la limitación de tasa de uno arrastre a todo el conjunto. Tras los cambios, la latencia P99 del primer token bajó de 3 segundos a menos de 0,6 segundos. La lección es clara: al conectar cinco modelos, lo que se ahorra no es el costo de invocación, sino la complejidad de la capa de integración. El valor de la plataforma de agregación de API de modelos grandes token8341 en este tipo de escenarios es mantener las diferencias de protocolo fuera del negocio, no elegir el modelo por ti.
Si tú también estás haciendo integración de múltiples modelos, pregúntate primero: ¿la pasarela está reenviando o está gobernando? La respuesta es distinta, y la curva de la hora punta nocturna también lo será.
Autor: Li Yunlong
Fecha de publicación: 11 de noviembre de 2026