Ir al contenido principal
Español— Elegir un idioma
Menú

Rendimiento en producción

Lección 11 de 14 Actualizado el 29 de julio de 2026 Avanzado
En esta página
  1. Más allá de la caché: rendimiento global
  2. Streaming: ahorrar tiempo sin ahorrar tiempo realmente
  3. Elección del modelo según la latencia
  4. Gestión de errores sin empeorar las cosas
  5. Tiempos de espera y resiliencia
  6. Qué instrumentar
  7. Puntos clave

Más allá de la caché: rendimiento global

La caché reduce costes, pero la integración en producción depende de algo más que la factura: la latencia percibida por el usuario, el rendimiento sostenido, la fiabilidad frente a errores transitorios y la capacidad de diagnosticar degradaciones. Una aplicación que cuesta poco pero responde en 12 segundos o falla una de cada 50 veces no es eficiente. Esta lección aborda las cuatro dimensiones que importan una vez que has dominado el coste.

Streaming: ahorrar tiempo sin ahorrar tiempo realmente

Para cualquier interfaz donde un humano espera una respuesta, el streaming mediante SSE (Eventos Enviados por el Servidor) cambia radicalmente la percepción. Sin él, el usuario mira el cursor mientras el modelo genera 500 tokens; con él, las primeras palabras aparecen tras unos pocos cientos de milisegundos y la lectura comienza durante la generación. El tiempo total es el mismo, pero el tiempo percibido se reduce en un factor de varios.

import requests
import json

def llamada_streaming(mensajes, model="grok-4.20"):
    respuesta = requests.post(
        "https://api.x.ai/v1/chat/completions",
        headers={
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        },
        json={
            "model": model,
            "messages": mensajes,
            "stream": True
        },
        stream=True
    )

    for linea in respuesta.iter_lines():
        if linea and linea.startswith(b"data: "):
            datos = linea[6:]
            if datos == b"[DONE]":
                break
            trozo = json.loads(datos)
            token = trozo["choices"][0]["delta"].get("content", "")
            yield token

El parámetro stream: True no cambia ni el número de tokens facturados ni su tarifa. Lo que mejoras es el TTFT (time to first token, tiempo hasta el primer token). Ten en cuenta que la función es un generador: cede el control token a token, lo que te permite escribir directamente en la respuesta HTTP de tu servidor sin mantener toda la generación en memoria.

Elección del modelo según la latencia

La segunda palanca de latencia es la elección del modelo, y depende principalmente del esfuerzo de razonamiento. Un modelo de razonamiento produce tokens de razonamiento invisibles antes de redactar su respuesta: la calidad sube, pero el retraso también. En los extremos, grok-build-0.1 es el más rápido del catálogo, lo que lo hace adecuado para usos en tiempo real como clasificación sobre la marcha o autocompletado; grok-4.20-0309 en su variante sin razonamiento y grok-4.3 ofrecen un compromiso razonable entre calidad y velocidad; grok-4.5 con razonamiento profundo se sitúa en el otro extremo, reservado para tareas que realmente lo requieran.

La consecuencia práctica es que no eliges un modelo para una aplicación, sino para un paso. Un patrón común consiste en realizar una llamada inicial rápida que decida: ¿es esta solicitud trivial, ambigua o compleja? y enviar solo la fracción de casos que lo justifiquen a un modelo de razonamiento. Divides tanto la latencia media como el coste medio sin degradar los casos difíciles.

Gestión de errores sin empeorar las cosas

El código 429 tratado en la Lección 3 no es el único que encontrarás. La distinción clave reside entre los errores que merecen un reintento y aquellos donde reintentar solo añade tráfico innecesario.

CódigoNaturalezaAcción
429 Too Many RequestsRecuperableRetroceso exponencial (Lección 3)
500 Internal Server ErrorRecuperableReintentar con retroceso; el error es del servidor
502 / 503 Service UnavailableRecuperableReintentar tras unos segundos
400 Bad RequestFinalSolicitud mal formada; corrige la carga útil
401 UnauthorizedFinalClave de API no válida o caducada
413 Payload Too LargeFinalEl prompt supera el límite de contexto

Puedes codificar esta regla en tres líneas, y merece la pena aislarla en una función en lugar de dispersar sentencias if por todas partes:

def clasificador_error(codigo_estado):
    recuperables = {429, 500, 502, 503}
    return codigo_estado in recuperables

Tiempos de espera y resiliencia

Un tiempo de espera mal configurado crea dos problemas opuestos: si es demasiado corto, abandona solicitudes que habrían tenido éxito; si es demasiado largo, bloquea tus trabajadores mientras la cola crece. Configura tres por separado. La conexión debe establecerse en 10 segundos; más allá de eso, el problema es de red. La lectura en modo no streaming escala con el modelo: 120 segundos para un modelo de razonamiento, 60 segundos para grok-build-0.1. En streaming, el umbral relevante no es la duración total, sino el intervalo entre trozos, fijado alrededor de 30 segundos.

Un punto merece verdadera precaución: cuando expira un tiempo de espera en una generación larga, no reinicies automáticamente. El modelo puede haber consumido ya tokens de razonamiento por los que pagarás una segunda vez, y nada garantiza que la primera solicitud no haya tenido éxito en el servidor. Un mecanismo de idempotencia —una clave de solicitud que conservas para reconocer un duplicado— o una reanudación explícita funcionan mejor que un reintento ciego.

Qué instrumentar

Cuatro familias de métricas bastan para diagnosticar la mayoría de incidentes.

MétricaQué revelaObjetivo
TTFTLatencia inicial percibidaMonitorizar por modelo
Tasa de éxitoFiabilidad de la integraciónMayor del 99,5 %
Tasa de cachéCalidad de la estructura del promptMayor del 50 %
Coste por solicitudDesviación presupuestaria, media móvilEstable en el tiempo

Añade la latencia en el percentil 95. La media siempre oculta los casos extremos, y esos son los que desencadenan tickets de soporte: un P95 de 8 segundos significa que uno de cada 20 usuarios espera 8 segundos, algo que ninguna media de 1,2 segundos revelaría.

Puntos clave

  • El streaming SSE reduce la latencia percibida sin afectar al coste
  • Elige un modelo rápido para tiempo real y un modelo de razonamiento para calidad
  • Distingue entre errores recuperables (429, 500, 502/503) y errores finales (400, 401)
  • Configura tiempos de espera adecuados al modelo en uso
  • Monitoriza el TTFT, la tasa de éxito, la tasa de caché y el coste medio por solicitud