“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:
- 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.
- Fixe o tamanho da saída com
max_tokense um prompt que o preencha, para que os tokens por segundo sejam comparáveis. - Informe p50 e p95, não a média. A latência de cauda é o que os usuários lembram.
- Espalhe as execuções no tempo. A carga muda ao longo do dia.
- 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.
