BroadRouter

Latência de LLM: TTFT, tokens por segundo e tempo de ponta a ponta

Pela equipe da BroadNet Inference · 4 min de leitura · Publicado em · Atualizado em

O time to first token (TTFT) é a espera até o primeiro token de saída. Tokens por segundo é a rapidez com que a resposta chega depois. A latência de ponta a ponta é TTFT mais o tempo de geração (≈ tokens de saída ÷ velocidade). Tamanho do prompt e filas definem o TTFT, tamanho do modelo e carga, a velocidade, e o da resposta, o total. Meça os três em p50 e p95.

“A API está lenta” pode significar três coisas diferentes, e cada uma tem uma solução diferente. Um usuário de chat espera a primeira palavra. Um agente espera a chamada de ferramenta inteira. Um job em lote se importa com tokens por hora. Este post define os três números, mostra como medi-los a partir do seu próprio código e associa cada ajuste ao número que ele realmente move.

O que são TTFT, tokens por segundo e latência de ponta a ponta?

O guia de benchmarking da NVIDIA traz definições claras, que batem com o que você consegue observar a partir de um cliente:

Métrica O que mede Quem sente Depende de
Time to first token (TTFT) Requisição enviada → primeiro token recebido Usuários de chat Rede, filas, tamanho do prompt (prefill), acertos de cache
Latência entre tokens (ITL) Intervalo médio entre tokens Quem lê uma resposta em streaming Tamanho do modelo, hardware, carga do servidor
Tokens por segundo por usuário Tokens de saída depois do primeiro ÷ tempo de geração (do primeiro ao último token); igual a 1 ÷ ITL médio Leitores, agentes O mesmo que o ITL
Latência de ponta a ponta Requisição enviada → último token recebido Agentes, APIs, lote TTFT + tempo de geração

A fórmula que liga tudo:

ponta a ponta ≈ TTFT + (tokens de saída − 1) × ITL ≈ TTFT + tokens de saída ÷ tokens por segundo por usuário

A velocidade por usuário não é o mesmo que o throughput do servidor, o total de tokens que um servidor produz para todos os usuários; um provedor pode aumentar um enquanto o outro cai.

Tome a velocidade típica que a BroadNet publica para o modelo dos planos, cerca de 100 tokens por segundo. O tempo de geração cresce com o tamanho da resposta: um arquivo de código de 4.000 tokens leva cerca de oitenta vezes mais para ser gerado do que uma classificação de 50 tokens, enquanto os dois esperam o mesmo TTFT. Em respostas curtas, o TTFT é a maior parte da espera; nas longas, contam a velocidade e o tamanho.

Por que modelos de raciocínio precisam de um quarto número?

Modelos de raciocínio como o DeepSeek V4.1 Flash pensam antes de responder, e o raciocínio também é feito de tokens de saída. Se o modelo gasta 800 tokens raciocinando a cerca de 100 tokens por segundo, o usuário espera que todos os 800 sejam gerados antes da primeira palavra visível, mesmo que o TTFT medido na rede pareça rápido. Por isso, meça à parte o tempo até o primeiro token de conteúdo. Na BroadNet Inference, reasoning_effort: "low" encurta o raciocínio em etapas simples; o guia de raciocínio explica o trade-off.

Como medir a latência a partir do cliente?

Meça onde seus usuários estão, com streaming ligado. Cronômetros do lado do servidor não enxergam a rede nem qualquer 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 regras para um benchmark justo:

  1. Fixe o tamanho do prompt e informe esse valor. O TTFT com 500 tokens de prompt e com 200.000 são números diferentes. O contador de tokens diz o tamanho de um prompt de teste antes de você enviá-lo.
  2. Fixe o tamanho da saída com max_tokens e um prompt que o preencha, para que os tokens por segundo sejam comparáveis.
  3. Informe p50 e p95, não a média. A latência de cauda é o que os usuários lembram.
  4. Espalhe as execuções no tempo. A carga muda ao longo do dia.
  5. Aqueça antes. A primeira chamada paga DNS, TLS e abertura de conexão; reutilize um único cliente.

O que realmente melhora cada número?

Para melhorar Faça isto Por quê
TTFT Encurte ou coloque em cache o prefixo do prompt O tempo de prefill cresce com o tamanho do prompt; prefixos em cache pulam trabalho
TTFT Mantenha as conexões aquecidas, use uma região próxima Elimina setup e idas e voltas
Tempo até o primeiro token de conteúdo Reduza o esforço de raciocínio, ou use um modelo sem raciocínio em etapas simples Menos raciocínio oculto antes da resposta
Tokens por segundo Use um modelo menor ou mais rápido para a etapa A velocidade de decodificação depende do tamanho do modelo e do serving
Ponta a ponta Peça saídas mais curtas (schemas, limites de palavras) O tamanho da saída multiplica o ITL
Ponta a ponta em muitas chamadas Rode chamadas independentes em paralelo dentro do seu limite de concorrência O tempo de relógio cai, mesmo que cada chamada seja igual
Latência percebida Faça streaming para o usuário Ele lê enquanto o modelo escreve

O tamanho da saída é a alavanca mais subestimada. Pedir “JSON com estes quatro campos” em vez de “explique sua resposta” pode cortar o tempo de geração em uma ordem de grandeza, sem nenhum trabalho de infraestrutura. A saída estruturada ajuda nisso.

A alavanca do cache é tratada em estrutura de prompt para cache. A do paralelismo esbarra rápido nos rate limits; veja como lidar com erros 429.

Como o tamanho do prompt muda o trade-off?

O TTFT cresce com o prompt porque o modelo precisa processar cada token de entrada antes de começar a escrever. Esse é o custo escondido de prompts muito longos e parte da decisão entre contexto longo e RAG: um prompt de 1M de tokens responde perguntas que a RAG não consegue, mas começa mais devagar. Se a velocidade interativa importa, mantenha curto o caminho principal e envie o contexto grande só quando a pergunta precisar.

Onde a BroadNet Inference se encaixa

A BroadNet publica uma velocidade típica de cerca de 100 tokens por segundo para o modelo dos planos e faz streaming no formato SSE padrão, então o código acima funciona sem mudanças. Ela não publica números de TTFT nem SLAs de latência, então meça com seus próprios prompts antes de se comprometer; uma hora Meteor de $1 basta para um benchmark de 50 execuções, e o crédito inicial cobre um no Gemma 4 VL 26B. Se você precisa de latência garantida abaixo de um segundo em grande escala, teste com cuidado: uma chave de pagamento por uso permite 4 requisições em andamento, o que combina mais com apps e agentes do que com serving em tempo real de alto volume. Os modelos e seus preços estão nas páginas de modelos e preços.

Perguntas frequentes

Qual é um bom time to first token para uma API de LLM?

Para chat, menos de cerca de um segundo em prompts curtos já parece responsivo. Prompts longos e modelos de raciocínio demoram mais por natureza. Compare o TTFT só com o mesmo tamanho de prompt e o mesmo modelo.

Tokens por segundo é a mesma coisa que throughput?

Não exatamente. Tokens por segundo por usuário é a rapidez com que uma resposta chega. Throughput é o total de tokens que um servidor produz para todos os usuários. Um provedor pode aumentar o throughput total enquanto a velocidade de cada usuário cai.

Por que o TTFT é tão alto num modelo de raciocínio?

O modelo gera tokens de raciocínio ocultos antes da resposta visível. O primeiro token pode chegar rápido, mas o primeiro token de conteúdo espera o fim do raciocínio. Reduza o reasoning_effort em tarefas simples.

O streaming reduz a latência?

Não encurta o tempo de ponta a ponta. Ele deixa o usuário ler a resposta enquanto ela ainda está sendo escrita, então a latência percebida cai para mais ou menos o TTFT.

Quantas requisições preciso para um benchmark de latência confiável?

O suficiente para enxergar a cauda. De cinquenta a cem requisições por tamanho de prompt dão um p95 utilizável. Espalhe-as ao longo do dia, porque a carga muda.

Ler em MarkdownPerguntar ao ChatGPTPerguntar ao ClaudePerguntar ao Perplexity