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

Desempenho em Produção

Aula 11 de 14 Atualizada a 29 de julho de 2026 Avancado
Nesta página
  1. Para Além da Cache: Desempenho Global
  2. Streaming: Poupar Tempo sem Realmente Poupar Tempo
  3. Escolher o Seu Modelo para Latência
  4. Gerir Erros sem Piorar a Situação
  5. Timeouts e Resiliência
  6. O Que Instrumentar
  7. Pontos-chave

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ódigoNaturezaAção
429 Too Many RequestsRecuperávelBackoff exponencial (Lição 3)
500 Internal Server ErrorRecuperávelNova tentativa com backoff; o erro é do lado do servidor
502 / 503 Service UnavailableRecuperávelNova tentativa após alguns segundos
400 Bad RequestFinalPedido mal formado; corrija a carga útil
401 UnauthorizedFinalChave de API inválida ou expirada
413 Payload Too LargeFinalO 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étricaO Que RevelaAlvo
TTFTLatência inicial percecionadaMonitorizar por modelo
Taxa de SucessoFiabilidade da integraçãoSuperior a 99,5%
Taxa de CacheQualidade da estrutura do promptSuperior a 50%
Custo por PedidoDesvio orçamental, média móvelEstá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