Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Medir e analisar a latência

Aula 1 de 20 Atualizada a 28 de julho de 2026 Avancado
Nesta página
  1. Por que a latência é a sua métrica número um
  2. Componentes da latência
  3. Diagnóstico de estrangulamentos
  4. Pontos-chave

Por que a latência é a sua métrica número um

Quando coloca uma aplicação alimentada por LLM em produção, a latência que os seus utilizadores percecionam determina diretamente a adoção. Uma resposta que demora 8 segundos a aparecer afasta 70% dos utilizadores: estes fecham o separador, repetem o pedido ou concluem que a ferramenta não funciona. Nenhuma melhoria de qualidade pode compensar esta perda, pois ela ocorre antes mesmo de o utilizador ler a resposta.

O desafio em produção é que «é lento» não constitui um diagnóstico. A mesma duração de oito segundos pode resultar de um prompt de sistema demasiado grande, de uma configuração de raciocínio excessivamente ambiciosa, de um servidor de aplicação mal posicionado ou de um pós-processamento que aguarda a resposta completa antes de exibir qualquer coisa. Cada causa exige uma correção diferente e corrigir a errada não altera nada. Esta lição ensina-o a medir, decompor e diagnosticar a latência de ponta a ponta, para que possa transformar uma queixa num número acionável.

Componentes da latência

A latência total de uma chamada à API decompõe-se em quatro segmentos que deve separar. A latência de rede é o tempo de trânsito entre o seu servidor e a API da OpenAI; é invisível nos registos da sua aplicação, mas pode exceder 100 milissegundos se o seu servidor estiver longe do endpoint. O Tempo até ao Primeiro Token (TTFT) mede o atraso antes da geração do primeiro token: este é o segmento que os utilizadores sentem como «espera», uma vez que o ecrã permanece em branco até ser concluído. O Tempo por Token de Saída (TPOT) descreve então a velocidade de geração de cada token subsequente; multiplicado pelo comprimento da resposta, fornece a duração do deslocamento do texto. Finalmente, a latência da aplicação abrange tudo o que o seu próprio servidor faz antes e depois da chamada: obter documentos, montar o prompt, validar o JSON de saída e escrever na base de dados.

Esta decomposição não é académica. Uma equipa que descobre que o seu TTFT está bom, mas que a latência da aplicação adiciona dois segundos, não trocará de modelo: examinará a sua consulta SQL de obtenção de contexto.

Medição com Python

Eis como instrumentar uma chamada à 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:
    """Measure decomposed latency of an API call."""
    metrics = {}

    start_total = time.perf_counter()

    # Stream the call to measure 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("Explain Bayes' theorem in 3 sentences.")
for key, value in result.items():
    print(f"{key}: {value:.4f}" if isinstance(value, float) else f"{key}: {value}")

A principal conclusão deste código é a utilização de stream=True. Sem streaming, não consegue isolar o TTFT: a API só retorna após a resposta completa, pelo que mede apenas um total. O temporizador inicia antes da chamada, para no primeiro delta de texto e a duração restante dividida pelo número de tokens restantes fornece o TPOT. Execute o mesmo prompt contra dois modelos ou duas configurações de raciocínio e, em poucos minutos, terá a comparação quantitativa que substitui as suposições da sua equipa.

Diagnóstico de estrangulamentos

Um TTFT elevado, acima de dois segundos, aponta para três causas. A mais comum é um prompt de sistema excessivamente longo que não está em cache: o modelo deve ingerir vários milhares de tokens antes de começar a escrever, em cada chamada. Em seguida, surge uma configuração de raciocínio elevada — high, xhigh ou max no GPT-5.6 — que deliberadamente faz o modelo pensar antes de produzir qualquer saída visível; isto não é um erro, é um comportamento esperado, mas deve ser uma escolha consciente, não uma configuração herdada de um protótipo. Finalmente, pode ocorrer um pico de carga do lado da OpenAI, que não pode controlar: é precisamente por isso que necessita de medição contínua em vez de uma verificação pontual, para a distinguir das outras duas.

Um TPOT elevado, acima de 50 ms por token, lê-se de forma diferente. Um max_output_tokens muito elevado empurra o modelo a produzir sequências longas e a duração total aumenta mecanicamente, mesmo que cada token chegue à velocidade normal. A utilização de chamadas de função complexas com muitas ferramentas declaradas também sobrecarrega a geração. Concretamente, uma equipa que deixou quinze ferramentas no seu esquema quando metade já não é utilizada pagará essa sobrecarga em cada chamada.

Ferramentas de monitorização

Medir uma vez não é suficiente: precisa de acompanhar a distribuição ao longo do tempo, pois a cauda da distribuição gera tickets de suporte. Para monitorização contínua em produção, integre estas métricas na sua pilha de observabilidade:

import logging
from dataclasses import dataclass, field

@dataclass
class LatencyMetrics:
    """Aggregates latency metrics over a sliding window."""
    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"Samples: {len(self.measurements)}"
        )

A janela deslizante de mil medições impede o crescimento ilimitado da memória, mantendo simultaneamente uma amostra representativa do tráfego recente. Crucialmente, esta classe expõe dois percentis, não uma média: um p50 de 700 ms com um p99 de 6 segundos descreve um serviço que a maioria dos utilizadores considera rápido e que uma minoria considera inutilizável. Uma média teria mascarado ambas as realidades. Ligue o report() à sua ferramenta de métricas e defina um limiar de alerta no p99 antes de tocar no resto do sistema.

Pontos-chave

  • A latência decompõe-se em TTFT + geração (TPOT × tokens) + rede
  • Meça sempre com streaming para obter o TTFT real
  • Acompanhe os percentis p50 e p99, não apenas a média
  • A escolha do modelo e as configurações de raciocínio impactam diretamente a latência: o GPT-5.6 Terra com raciocínio baixo responde mais rapidamente do que o GPT-5.6 Sol com raciocínio elevado