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

Medir y analizar la latencia

Lección 1 de 20 Actualizado el 28 de julio de 2026 Avanzado
En esta página
  1. Por qué la latencia es tu métrica número uno
  2. Componentes de la latencia
  3. Diagnóstico de cuellos de botella
  4. Puntos clave

Por qué la latencia es tu métrica número uno

Cuando despliegas una aplicación impulsada por un LLM en producción, la latencia que perciben tus usuarios determina directamente la adopción. Una respuesta que tarda 8 segundos en aparecer ahuyenta al 70 % de los usuarios: cierran la pestaña, reintentan la solicitud o concluyen que la herramienta no funciona. Ninguna mejora en la calidad puede compensar esta pérdida, porque ocurre antes de que el usuario llegue siquiera a leer la respuesta.

El desafío en producción es que «va lento» no es un diagnóstico. Esa misma duración de ocho segundos podría deberse a un prompt de sistema sobredimensionado, una configuración de razonamiento demasiado ambiciosa, un servidor de aplicación mal ubicado o un posprocesamiento que espera a recibir la respuesta completa antes de mostrar nada. Cada causa requiere una solución distinta, y arreglar la incorrecta no cambia nada. Esta lección te enseña a medir, descomponer y diagnosticar la latencia de extremo a extremo para convertir una queja en un número sobre el que actuar.

Componentes de la latencia

La latencia total de una llamada a la API se descompone en cuatro segmentos que debes separar. La latencia de red es el tiempo de tránsito entre tu servidor y la API de OpenAI; es invisible en los registros de tu aplicación, pero puede superar los 100 milisegundos si tu servidor está lejos del punto de conexión. El tiempo hasta el primer token (TTFT) mide el retraso antes de que se genere el primer token: este es el segmento que los usuarios perciben como «espera», ya que la pantalla permanece en blanco hasta que se completa. El tiempo por token de salida (TPOT) describe entonces la velocidad de generación de cada token subsiguiente; multiplicado por la longitud de la respuesta, ofrece la duración del desplazamiento del texto. Por último, la latencia de aplicación cubre todo lo que hace tu propio servidor antes y después de la llamada: obtener documentos, ensamblar el prompt, validar el JSON de salida y escribir en la base de datos.

Esta descomposición no es académica. Un equipo que descubre que su TTFT es correcto pero que su latencia de aplicación añade dos segundos no cambiará de modelo: examinará su consulta SQL de obtención de contexto.

Medición con Python

Así es como puedes instrumentar una llamada a la API de Responses para capturar cada segmento:

import time
import openai

client = openai.OpenAI()

def measure_latency(prompt: str, model: str = "gpt-5.6-terra") -> dict:
    """Mide la latencia descompuesta de una llamada a la API."""
    metrics = {}

    start_total = time.perf_counter()

    # Transmite la llamada para medir el TTFT
    stream = client.responses.create(
        model=model,
        input=prompt,
        stream=True,
    )

    first_token = True
    output_tokens = 0

    for event in stream:
        if event.type == "response.output_text.delta":
            if first_token:
                metrics["ttft"] = time.perf_counter() - start_total
                start_generation = time.perf_counter()
                first_token = False
            output_tokens += 1

    metrics["total_duration"] = time.perf_counter() - start_total
    metrics["output_tokens"] = output_tokens
    if output_tokens > 1:
        metrics["tpot"] = (
            (metrics["total_duration"] - metrics["ttft"]) / (output_tokens - 1)
        )

    return metrics

result = measure_latency("Explica el teorema de Bayes en 3 frases.")
for key, value in result.items():
    print(f"{key}: {value:.4f}" if isinstance(value, float) else f"{key}: {value}")

La clave de este código es el uso de stream=True. Sin transmisión, no puedes aislar el TTFT: la API solo devuelve la respuesta una vez completada, por lo que solo medirías un total. El temporizador arranca antes de la llamada, se detiene en el primer delta de texto y la duración restante dividida por el número de tokens restantes proporciona el TPOT. Ejecuta el mismo prompt contra dos modelos o dos configuraciones de razonamiento y, en cuestión de minutos, tendrás la comparación cuantitativa que sustituye las suposiciones de tu equipo.

Diagnóstico de cuellos de botella

Un TTFT alto, superior a dos segundos, apunta a tres causas. La más común es un prompt de sistema excesivamente largo que no está en caché: el modelo debe ingerir varios miles de tokens antes de empezar a escribir, en cada llamada. La siguiente es una configuración de razonamiento elevada —high, xhigh o max en GPT-5.6—, que hace que el modelo «piense» deliberadamente antes de producir cualquier salida visible; esto no es un error, es el comportamiento esperado, pero debe ser una elección consciente, no una configuración heredada de un prototipo. Por último, podría haber un pico de carga del lado de OpenAI, que no puedes controlar: precisamente por eso necesitas una medición continua en lugar de una comprobación puntual, para distinguirlo de las otras dos causas.

Un TPOT alto, superior a 50 ms por token, se interpreta de forma distinta. Un max_output_tokens muy elevado empuja al modelo a producir secuencias largas, y la duración total aumenta mecánicamente aunque cada token llegue a velocidad normal. El uso de llamadas a funciones complejas con muchas herramientas declaradas también sobrecarga la generación. En concreto, un equipo que dejó quince herramientas en su esquema cuando la mitad ya no se usan pagará esa sobrecarga en cada llamada.

Herramientas de monitorización

Medir una vez no es suficiente: debes rastrear la distribución a lo largo del tiempo, porque la cola de la distribución genera tickets de soporte. Para la monitorización continua en producción, integra estas métricas en tu pila de observabilidad:

import logging
from dataclasses import dataclass, field

@dataclass
class LatencyMetrics:
    """Agrega métricas de latencia en una ventana deslizante."""
    measurements: list[dict] = field(default_factory=list)

    def add(self, measurement: dict) -> None:
        self.measurements.append(measurement)
        if len(self.measurements) > 1000:
            self.measurements = self.measurements[-1000:]

    @property
    def ttft_p50(self) -> float:
        values = sorted(m["ttft"] for m in self.measurements if "ttft" in m)
        if not values:
            return 0.0
        return values[len(values) // 2]

    @property
    def ttft_p99(self) -> float:
        values = sorted(m["ttft"] for m in self.measurements if "ttft" in m)
        if not values:
            return 0.0
        idx = int(len(values) * 0.99)
        return values[min(idx, len(values) - 1)]

    def report(self) -> str:
        return (
            f"TTFT p50={self.ttft_p50:.3f}s p99={self.ttft_p99:.3f}s | "
            f"Muestras: {len(self.measurements)}"
        )

La ventana deslizante de mil mediciones evita el crecimiento ilimitado de la memoria mientras mantiene una muestra representativa del tráfico reciente. Es crucial que esta clase exponga dos percentiles, no una media: un p50 de 700 ms con un p99 de 6 segundos describe un servicio que la mayoría de los usuarios encuentra rápido y una minoría inutilizable. Una media habría enmascarado ambas realidades. Conecta report() a tu herramienta de métricas y establece un umbral de alerta en el p99 antes de tocar el resto del sistema.

Puntos clave

  • La latencia se descompone en TTFT + generación (TPOT × tokens) + red
  • Mide siempre con transmisión para obtener el TTFT real
  • Rastrea los percentiles p50 y p99, no solo la media
  • La elección del modelo y las configuraciones de razonamiento impactan directamente en la latencia: GPT-5.6 Terra con razonamiento bajo responde más rápido que GPT-5.6 Sol con razonamiento alto