Desempenho em Produção
Nesta página
Para Além da Cache: Desempenho Global
A cache reduz custos, mas a integração em produção depende de mais do que apenas da fatura: latência percecionada pelo utilizador, throughput sustentado, fiabilidade face a erros transitórios e capacidade de diagnosticar degradações. Uma aplicação que custa pouco, mas responde em 12 segundos ou falha uma vez em cada 50, não é performante. Esta lição aborda as quatro dimensões que importam depois de ter dominado os custos.
Streaming: Poupar Tempo sem Realmente Poupar Tempo
Para qualquer interface onde um humano aguarda uma resposta, o streaming SSE (Server-Sent Events) altera radicalmente a perceção. Sem ele, o utilizador encara um cursor enquanto o modelo gera 500 tokens; com ele, as primeiras palavras surgem após algumas centenas de milissegundos e a leitura começa durante a geração. O tempo total é o mesmo, mas o tempo percecionado é reduzido por um fator de várias vezes.
import requests
import json
def appel_streaming(messages, model="grok-4.20"):
reponse = requests.post(
"https://api.x.ai/v1/chat/completions",
headers={
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
},
json={
"model": model,
"messages": messages,
"stream": True
},
stream=True
)
for ligne in reponse.iter_lines():
if ligne and ligne.startswith(b"data: "):
donnees = ligne[6:]
if donnees == b"[DONE]":
break
chunk = json.loads(donnees)
token = chunk["choices"][0]["delta"].get("content", "")
yield token
O parâmetro stream: True não altera nem o número de tokens faturados nem a sua taxa. O que melhora é o TTFT — o time to first token (tempo até ao primeiro token). Note que a função é um gerador: cede o controlo token a token, permitindo-lhe escrever diretamente na resposta HTTP do seu servidor sem manter toda a geração na memória.
Escolher o Seu Modelo para Latência
A segunda alavanca de latência é a escolha do modelo, que depende principalmente do esforço de raciocínio. Um modelo de raciocínio produz tokens de raciocínio invisíveis antes de redigir a sua resposta: a qualidade sobe, mas o atraso também. Nos extremos, o grok-build-0.1 é o mais rápido do catálogo, tornando-o adequado para usos em tempo real como classificação ao voo ou autocompletar; o grok-4.20-0309 na variante sem raciocínio e o grok-4.3 oferecem um compromisso razoável entre qualidade e velocidade; o grok-4.5 com raciocínio profundo situa-se na outra extremidade, reservado para tarefas que realmente o exijam.
A consequência prática é que não escolhe um modelo para uma aplicação, mas para uma etapa. Um padrão comum consiste em ter uma chamada inicial rápida para decidir — este pedido é trivial, ambíguo ou complexo? — e depois enviar apenas a fração de casos que o justifiquem para um modelo de raciocínio. Divide assim tanto a latência média como o custo médio sem degradar os casos difíceis.
Gerir Erros sem Piorar a Situação
O código 429 abordado na Lição 3 não é o único que encontrará. A distinção chave reside entre erros que merecem uma nova tentativa e aqueles onde repetir apenas adiciona tráfego desnecessário.
| Código | Natureza | Ação |
|---|---|---|
| 429 Too Many Requests | Recuperável | Backoff exponencial (Lição 3) |
| 500 Internal Server Error | Recuperável | Nova tentativa com backoff; o erro é do lado do servidor |
| 502 / 503 Service Unavailable | Recuperável | Nova tentativa após alguns segundos |
| 400 Bad Request | Final | Pedido mal formado; corrija a carga útil |
| 401 Unauthorized | Final | Chave de API inválida ou expirada |
| 413 Payload Too Large | Final | O prompt excede o limite de contexto |
Pode codificar esta regra em três linhas, e vale a pena isolá-la numa função em vez de espalhar instruções if por todo o lado:
def classifier_erreur(status_code):
recuperable = {429, 500, 502, 503}
return status_code in recuperable
Timeouts e Resiliência
Um timeout mal configurado cria dois problemas opostos: se for demasiado curto, abandona pedidos que teriam sucesso; se for demasiado longo, bloqueia os seus trabalhadores enquanto a fila aumenta. Defina três separadamente. A ligação deve estabelecer-se em 10 segundos; além disso, o problema é de rede. A leitura em modo não streaming escala com o modelo: 120 segundos para um modelo de raciocínio, 60 segundos para o grok-build-0.1. Em streaming, o limiar relevante não é a duração total, mas o intervalo entre blocos, definido em cerca de 30 segundos.
Um ponto merece verdadeira cautela: quando um timeout expira numa geração longa, não reinicie automaticamente. O modelo pode já ter consumido tokens de raciocínio pelos quais pagará uma segunda vez, e nada garante que o primeiro pedido não tenha tido sucesso no lado do servidor. Um mecanismo de idempotência — uma chave de pedido que mantém para reconhecer um duplicado — ou um retoma explícita funciona melhor do que uma nova tentativa cega.
O Que Instrumentar
Quatro famílias de métricas são suficientes para diagnosticar a maioria dos incidentes.
| Métrica | O Que Revela | Alvo |
|---|---|---|
| TTFT | Latência inicial percecionada | Monitorizar por modelo |
| Taxa de Sucesso | Fiabilidade da integração | Superior a 99,5% |
| Taxa de Cache | Qualidade da estrutura do prompt | Superior a 50% |
| Custo por Pedido | Desvio orçamental, média móvel | Estável ao longo do tempo |
Adicione a latência no percentil 95. A média mascara sempre casos extremos, e são esses que desencadeiam tickets de suporte: um P95 de 8 segundos significa que um em cada 20 utilizadores espera 8 segundos, algo que nenhuma média de 1,2 segundos revelaria.
Pontos-chave
- O streaming SSE reduz a latência percecionada sem afetar o custo
- Escolha um modelo rápido para tempo real e um modelo de raciocínio para qualidade
- Distinga erros recuperáveis (429, 500, 502/503) de erros finais (400, 401)
- Configure timeouts adequados ao modelo em uso
- Monitore o TTFT, a taxa de sucesso, a taxa de cache e o custo médio por pedido