Otimização de ponta a ponta: do prompt à rede
Nesta página
Lição atualizada em 3 de novembro de 2026 com base na documentação da OpenAI:
temperatureetop_psó são aceites com um esforço de raciocínio denone, enquanto os modelos GPT-5.6 raciocinam por predefinição (medium). As chamadas que definem estes parâmetros devem, portanto, especificarreasoning={"effort": "none"}(API de Respostas) oureasoning_effort="none"(Chat Completions). Fontes: Utilizar o GPT-6 · GPT-5.6 Terra.
A otimização é um sistema, não um parâmetro
Reduzir a latência e os custos de uma aplicação LLM não se resume a escolher um modelo mais rápido. Trata-se de uma cadeia de otimizações que se estende desde o prompt até à configuração da rede, onde o elo mais fraco dita o desempenho de todo o conjunto. Uma equipa que reduza para metade o tamanho do seu prompt de sistema, mas mantenha o servidor a abrir uma nova ligação TLS para cada pedido, perderá em sobrecarga de rede tudo o que poupou em tokens.
A ordem pela qual aborda estas alavancas é crucial. Comece pelo prompt, pois impacta tanto o custo como a latência sem exigir alterações na infraestrutura. Em seguida, otimize os parâmetros da API, depois a configuração da rede e, finalmente, a forma como a sua aplicação consome a resposta. Esta lição guia-o através de cada alavanca, nesta ordem.
Otimize o prompt
Cada token de entrada custa tempo e dinheiro, e a maioria dos prompts em produção carrega bagagem da sua fase de prototipagem: instruções adicionadas uma a uma, cada uma a reformular a anterior. O seu primeiro reflexo deve ser reescrever o prompt de forma densa, removendo formas de tratamento e repetições sem tocar nas restrições reais transmitidas ao modelo.
# ❌ Prompt prolixo
prompt_long = """
You are an expert financial analysis assistant. You must always
respond in a professional and structured manner. You must use
numerical data when possible. You must avoid unnecessary jargon.
You must be concise but complete.
Analyze the following quarterly report: ...
"""
# ✅ Prompt otimizado (mesmo resultado, menos tokens)
prompt_court = """Role: Senior financial analyst.
Constraints: Structured, numerical, concise.
Task: Analyze this quarterly report: ..."""
Ambas as versões transmitem exatamente as mesmas cinco restrições; a segunda fá-lo sem as cinco frases “You must” que nada acrescentam ao modelo. Num serviço que processa dez mil relatórios por dia, esta reescrita de trinta segundos paga-se a si própria diariamente.
Escolha o modelo certo para a tarefa
A segunda alavanca baseia-se no facto de nem todas as chamadas exigirem o mesmo modelo. Encaminhar uma tarefa de extração de campos para um modelo de alto raciocínio significa pagar por capacidade que a tarefa não utiliza e esperar mais tempo por um resultado idêntico.
| Tipo de tarefa | Modelo recomendado | Motivo |
|---|---|---|
| Classificação / extração | gpt-5.6-luna | Rápido, económico |
| Raciocínio complexo | gpt-5.6-terra com raciocínio médio | Melhor relação qualidade/custo |
| Tarefas críticas | gpt-5.6-sol com raciocínio elevado | Qualidade máxima, mais lento |
| Alto volume | gpt-5.6-luna via Batch API | -50% de custo |
Na prática, codifique esta escolha numa função de encaminhamento em vez de a deixar ao critério dos programadores; caso contrário, o modelo predefinido prevalecerá sempre:
import openai
client = openai.OpenAI()
def route_model(task: str, complexity: str) -> str:
"""Seleciona o modelo ótimo com base na tarefa."""
if complexity == "low":
return "gpt-5.6-luna"
elif task in ("reasoning", "math", "code"):
return "gpt-5.6-terra"
elif complexity == "critical":
return "gpt-5.6-sol"
return "gpt-5.6-terra"
def optimized_call(prompt: str, task: str, complexity: str) -> str:
model = route_model(task, complexity)
response = client.responses.create(
model=model,
input=prompt,
)
return response.output_text
Otimize os parâmetros da API
Uma resposta demasiado longa desperdiça tempo de geração que ninguém vai ler. Especifique sempre max_output_tokens: este é um limite rígido que protege tanto a sua fatura como a sua interface, impedindo que um prompt mal formulado derive numa divagação de duas mil palavras.
response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature exige effort none
input="Summarize this text in one sentence.",
max_output_tokens=100, # Limite rígido
temperature=0.0, # Determinístico = mais rápido
)
Os parâmetros de amostragem funcionam na mesma direção. Definir temperature=0 torna as respostas determinísticas e ligeiramente mais rápidas, o que é exatamente o que deseja para tarefas de extração ou classificação onde a criatividade é fonte de variância, não um trunfo. Reduzir top_p para 0,1 restringe o espaço de busca e acelera a geração; reserve esta configuração para tarefas onde apenas uma formulação é aceitável e mantenha os valores predefinidos onde a riqueza da resposta faz parte do produto.
Otimize a rede
O custo da viagem dos pacotes acumula-se em cada chamada, embora permaneça invisível nas métricas da sua aplicação. A API da OpenAI está alojada principalmente na costa leste dos EUA: colocar o seu servidor de aplicação na mesma região que o endpoint pode gerar um ganho potencial de 50 a 150 milissegundos na latência de rede. Para uma aplicação conversacional, isto representa uma fração significativa do Tempo para o Primeiro Token (TTFT).
O segundo ganho provém da reutilização de ligações. Sem um pool, cada pedido repete o handshake TLS, adicionando várias idas e voltas antes de qualquer fluxo de dados útil. Configurar um cliente HTTP uma vez por todas resolve este problema:
import httpx
# Cliente com pool de ligações persistentes
client_http = httpx.Client(
base_url="https://api.openai.com/v1",
timeout=60.0,
limits=httpx.Limits(
max_connections=20,
max_keepalive_connections=10,
),
)
Otimize o pós-processamento
O último elo é frequentemente aquele que as pessoas esquecem: uma aplicação que recebe uma resposta em streaming mas espera até ao fim para a exibir anula todos os benefícios do streaming. Processe a resposta à medida que chega, em vez de após a receção total.
async def progressive_processing(prompt: str):
"""Processa cada fragmento assim que chega."""
stream = client.responses.create(
model="gpt-5.6-terra",
input=prompt,
stream=True,
)
buffer = ""
for event in stream:
if event.type == "response.output_text.delta":
buffer += event.delta
# Processar por frase completa
if buffer.endswith((".", "!", "?")):
yield buffer.strip()
buffer = ""
Dividir por frases completas é um compromisso deliberado: emitir cada token produz uma exibição trémula, enquanto esperar pelo parágrafo inteiro recria a sensação de espera. A frase é a unidade que os leitores consomem naturalmente. Reutilize este padrão sempre que a sua interface necessite de exibir, ler em voz alta ou transmitir em streaming o que o modelo produz.
Pontos-chave
- Otimize primeiro o prompt: menos tokens = menos latência e custo
- Encaminhe para o modelo certo com base na complexidade da tarefa
- Limite
max_output_tokense usetemperature=0sempre que possível - Reutilize ligações HTTP e processe respostas via streaming