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

Otimização de ponta a ponta: do prompt à rede

Aula 2 de 20 Atualizada a 3 de novembro de 2026 Avancado
Nesta página
  1. A otimização é um sistema, não um parâmetro
  2. Otimize o prompt
  3. Otimize os parâmetros da API
  4. Otimize a rede
  5. Otimize o pós-processamento
  6. Pontos-chave

Lição atualizada em 3 de novembro de 2026 com base na documentação da OpenAI: temperature e top_p só são aceites com um esforço de raciocínio de none, enquanto os modelos GPT-5.6 raciocinam por predefinição (medium). As chamadas que definem estes parâmetros devem, portanto, especificar reasoning={"effort": "none"} (API de Respostas) ou reasoning_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 tarefaModelo recomendadoMotivo
Classificação / extraçãogpt-5.6-lunaRápido, económico
Raciocínio complexogpt-5.6-terra com raciocínio médioMelhor relação qualidade/custo
Tarefas críticasgpt-5.6-sol com raciocínio elevadoQualidade máxima, mais lento
Alto volumegpt-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_tokens e use temperature=0 sempre que possível
  • Reutilize ligações HTTP e processe respostas via streaming