BroadRouter

Latencia de LLM: TTFT, tokens por segundo y latencia total

Por el equipo de BroadNet Inference · 4 min de lectura · Publicado · Actualizado

El tiempo hasta el primer token (TTFT) es la espera hasta el primer token de salida. Los tokens por segundo miden la rapidez con que llega la respuesta. La latencia total: TTFT + tiempo de generación (≈ salida ÷ velocidad). El TTFT depende de la longitud del prompt y las colas; la velocidad, del tamaño del modelo y la carga; el total, de la longitud de la respuesta. Mida las tres en p50 y p95.

“La API va lenta” puede significar tres cosas distintas, y cada una se corrige de forma diferente. El usuario de un chat espera la primera palabra. Un agente espera la llamada a herramienta completa. Un trabajo por lotes se fija en los tokens por hora. Este artículo define las tres cifras, muestra cómo medirlas desde su propio código y relaciona cada ajuste con la cifra que realmente mejora.

¿Qué son el TTFT, los tokens por segundo y la latencia de extremo a extremo?

La guía de benchmarking de NVIDIA ofrece definiciones claras, y coinciden con lo que se puede observar desde un cliente:

Métrica Qué mide Quién la nota Depende de
Tiempo hasta el primer token (TTFT) Solicitud enviada → primer token recibido Usuarios de chat Red, colas, longitud del prompt (prefill), aciertos de caché
Latencia entre tokens (ITL) Intervalo medio entre tokens Quien lee una respuesta en streaming Tamaño del modelo, hardware, carga del servidor
Tokens por segundo por usuario Tokens de salida después del primero ÷ tiempo de generación (del primer token al último); equivale a 1 ÷ ITL media Lectores, agentes Lo mismo que la ITL
Latencia de extremo a extremo Solicitud enviada → último token recibido Agentes, APIs, lotes TTFT + tiempo de generación

La fórmula que las relaciona:

extremo a extremo ≈ TTFT + (tokens de salida − 1) × ITL ≈ TTFT + tokens de salida ÷ tokens por segundo por usuario

La velocidad por usuario no es lo mismo que el throughput del servidor, es decir, el total de tokens que produce para todos los usuarios; un proveedor puede aumentar uno mientras el otro baja.

Tome la velocidad típica que BroadNet publica para el modelo de sus planes, unos 100 tokens por segundo. El tiempo de generación crece con la longitud de la respuesta: un archivo de código de 4,000 tokens tarda unas ochenta veces más en generarse que una clasificación de 50 tokens, mientras que ambos esperan el mismo TTFT. En respuestas cortas, el TTFT es casi toda la espera; en las largas, lo son la velocidad y la longitud.

¿Por qué los modelos de razonamiento necesitan una cuarta cifra?

Los modelos de razonamiento como DeepSeek V4.1 Flash piensan antes de responder, y ese razonamiento también son tokens de salida. Si el modelo dedica 800 tokens a razonar a unos 100 tokens por segundo, el usuario espera a que se generen los 800 antes de ver la primera palabra, aunque el TTFT en la red parezca rápido. Por eso conviene medir aparte el tiempo hasta el primer token de contenido. En BroadNet Inference, reasoning_effort: "low" acorta el razonamiento en pasos sencillos; la guía de razonamiento explica la contrapartida.

¿Cómo se mide la latencia desde el cliente?

Mida donde están sus usuarios, con el streaming activado. Los temporizadores del lado del servidor no ven la red ni ningún proxy.

import os, time, statistics
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])

def timed(model, messages, max_tokens=1500):
    t0 = time.perf_counter()
    first = first_content = None
    usage = None
    stream = client.chat.completions.create(
        model=model, messages=messages, max_tokens=max_tokens,
        stream=True, stream_options={"include_usage": True},
    )
    for chunk in stream:
        now = time.perf_counter()
        if chunk.choices:
            if first is None:
                first = now
            if chunk.choices[0].delta.content and first_content is None:
                first_content = now
        if chunk.usage:
            usage = chunk.usage
    end = time.perf_counter()
    out = usage.completion_tokens if usage else 0
    return {
        "ttft": first - t0,
        "ttfct": (first_content or end) - t0,
        "e2e": end - t0,
        "tps": (out - 1) / (end - first) if out > 1 and end > first else 0,
        "prompt_tokens": usage.prompt_tokens if usage else None,
    }

runs = [timed("broadnet/gemma-4-26b-a4b", [{"role": "user", "content": "Summarise SSE in 100 words."}]) for _ in range(50)]
for k in ("ttft", "ttfct", "e2e", "tps"):
    xs = sorted(r[k] for r in runs)
    print(k, "p50", round(statistics.median(xs), 3), "p95", round(xs[int(len(xs) * 0.95) - 1], 3))

Cinco reglas para un benchmark justo:

  1. Fije la longitud del prompt e indíquela. El TTFT con 500 tokens de prompt y con 200,000 son cifras distintas. El contador de tokens le dice cuánto mide un prompt de prueba antes de enviarlo.
  2. Fije la longitud de la salida con max_tokens y un prompt que la llene, para que los tokens por segundo sean comparables.
  3. Informe p50 y p95, no la media. La latencia de cola es lo que recuerdan los usuarios.
  4. Reparta las ejecuciones en el tiempo. La carga cambia a lo largo del día.
  5. Haga un calentamiento primero. La primera llamada paga el DNS, el TLS y el establecimiento de la conexión; reutilice un mismo cliente.

¿Qué mejora realmente cada cifra?

Para mejorar Haga esto Por qué
TTFT Acorte el prefijo del prompt o póngalo en caché El tiempo de prefill crece con la longitud del prompt; los prefijos en caché se ahorran trabajo
TTFT Mantenga las conexiones abiertas y use una región cercana Elimina el establecimiento de conexión y viajes de ida y vuelta
Tiempo hasta el primer token de contenido Baje el esfuerzo de razonamiento o use un modelo sin razonamiento en pasos sencillos Menos razonamiento oculto antes de la respuesta
Tokens por segundo Use un modelo más pequeño o más rápido para ese paso La velocidad de decodificación depende del tamaño del modelo y de cómo se sirve
Extremo a extremo Pida salidas más cortas (esquemas, límites de palabras) La longitud de la salida multiplica la ITL
Extremo a extremo con muchas llamadas Ejecute en paralelo las llamadas independientes dentro de su límite de concurrencia El tiempo real baja aunque cada llamada sea igual
Latencia percibida Transmita la respuesta al usuario en streaming Lee mientras el modelo escribe

La longitud de la salida es la palanca más infravalorada. Pedir “JSON con estos cuatro campos” en lugar de “explique su respuesta” puede reducir el tiempo de generación en un orden de magnitud sin tocar la infraestructura. La salida estructurada ayuda en esto.

La palanca de la caché se trata en estructura del prompt para la caché. La del paralelismo choca pronto con los límites de frecuencia; consulte cómo manejar los errores 429.

¿Cómo cambia el equilibrio la longitud del prompt?

El TTFT crece con el prompt porque el modelo debe procesar cada token de entrada antes de poder escribir. Ese es el costo oculto de los prompts muy largos y parte de la decisión entre contexto largo y RAG: un prompt de 1M de tokens responde preguntas que RAG no puede, pero empieza más lento. Si importa la velocidad interactiva, mantenga corto el camino crítico y envíe el contexto grande solo cuando la pregunta lo necesite.

Dónde encaja BroadNet Inference

BroadNet publica una velocidad típica de unos 100 tokens por segundo para el modelo de sus planes y transmite con el formato SSE estándar, así que el código anterior funciona sin cambios. No publica cifras de TTFT ni SLA de latencia, de modo que mida con sus propios prompts antes de comprometerse; una hora Meteoro (Meteor) de $1 basta para un benchmark de 50 ejecuciones, y el crédito inicial cubre uno con Gemma 4 VL 26B. Si necesita una latencia inferior al segundo garantizada a gran escala, pruebe con cuidado: una clave de pago por uso admite 4 solicitudes en curso, lo que se ajusta más a aplicaciones y agentes que a un servicio en tiempo real de gran volumen. Los modelos y sus precios están en las páginas de modelos y precios.

Preguntas frecuentes

¿Cuál es un buen tiempo hasta el primer token en una API de LLM?

En un chat, menos de un segundo aproximadamente con prompts cortos se percibe como ágil. Los prompts largos y los modelos de razonamiento tardan más por diseño. Compare el TTFT solo con la misma longitud de prompt y el mismo modelo.

¿Los tokens por segundo son lo mismo que el throughput?

No exactamente. Los tokens por segundo por usuario indican a qué velocidad llega una respuesta. El throughput es el total de tokens que produce un servidor para todos los usuarios. Un proveedor puede aumentar el throughput total mientras baja la velocidad de cada usuario.

¿Por qué el TTFT es tan alto en un modelo de razonamiento?

El modelo genera tokens de razonamiento ocultos antes de la respuesta visible. El primer token puede llegar rápido, pero el primer token de contenido espera a que termine el razonamiento. Baje reasoning_effort en tareas sencillas.

¿El streaming reduce la latencia?

No acorta el tiempo de extremo a extremo. Permite que el usuario lea la respuesta mientras se escribe, así que la latencia percibida baja aproximadamente al TTFT.

¿Cuántas solicitudes necesito para un benchmark de latencia fiable?

Las suficientes para ver la cola. Entre cincuenta y cien solicitudes por tamaño de prompt dan un p95 utilizable. Repártalas a lo largo del día, porque la carga cambia.

Leer en MarkdownPreguntar a ChatGPTPreguntar a ClaudePreguntar a Perplexity