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

Tokens, Contexto e Janela de Conversação

Aula 7 de 22 Atualizada a 29 de julho de 2026 Programador
Nesta página
  1. Tokens, Contexto e Janela de Conversação
  2. O Que É um Token?
  3. A Janela de Contexto
  4. Três Alavancas de Otimização
  5. O Contexto Acumula-se Ao Longo da Conversação
  6. Pontos-chave

Tokens, Contexto e Janela de Conversação

O token é a unidade que o modelo manipula e a unidade que a sua fatura regista. Enquanto este conceito permanecer pouco claro, os seus custos também o estarão, e acabará por atingir um erro de limite de contexto sem saber porquê. Esta lição esclarece ambas as questões.

O Que É um Token?

Um token não é uma palavra. É um fragmento de texto que o modelo trata como uma unidade indivisível. Em português, um token representa, em média, cerca de 0,7 palavras. A biblioteca tiktoken permite ver exatamente como o texto é dividido: note como “olá-está” se divide em dois tokens, enquanto “hoje”, que aparece com mais frequência no corpus de treino, cabe num só. Este detalhe explica por que razão um texto em português consome mais tokens do que um texto em inglês de comprimento comparável.

from openai import OpenAI
client = OpenAI()

# To estimate tokens, use the tiktoken library
import tiktoken

# cl200k_base is used here as an example: each model generation has its own encoder.
# Check the encoder for the model you call before relying on the count.
enc = tiktoken.get_encoding("cl200k_base")

texte = "Bonjour, comment allez-vous aujourd'hui ?"
tokens = enc.encode(texte)
print(f"Text: {texte}")
print(f"Number of tokens: {len(tokens)}")
print(f"Tokens: {tokens}")
print(f"Decoded: {[enc.decode([t]) for t in tokens]}")

# Result:
# Text: Bonjour, comment allez-vous aujourd'hui ?
# Number of tokens: 9
# Tokens: [38025, 11, 4068, 67590, 5072, 76439, 30, ...]
# Decoded: ['Bonjour', ',', ' comment', ' allez', '-vous', " aujourd'hui", ' ?']

Verifique sempre qual o codificador que corresponde ao modelo que está a chamar. Uma contagem realizada com o codificador errado permanece uma aproximação útil, mas não corresponderá exatamente à sua fatura.

A Janela de Contexto

Cada modelo possui uma janela de contexto máxima, e a armadilha para os iniciantes é que esta inclui tanto a entrada como a saída. Isto não é um orçamento de entrada: é um orçamento total. Se o seu prompt ocupar 190.000 tokens de uma janela de 200.000 tokens, restam apenas 10.000 tokens para a resposta. O modelo será interrompido a meio de uma frase sem qualquer aviso adicional.

# Previous generation, for reference:
# GPT-5.4: 1,000,000 context tokens
# GPT-5.3: 200,000 context tokens
# gpt-5.6-sol  : 200,000 context tokens
# gpt-5.6-terra : 200,000 context tokens

# Example: if your input is 190,000 tokens in a 200,000-token window,
# only 10,000 tokens remain for the response

response = client.responses.create(
    model="gpt-5.6-terra",
    input="A very long text...",
    max_output_tokens=10000  # Limit explicitly
)

Posteriormente, pode ler a contagem exata em response.usage, que distingue os tokens de entrada, os tokens de saída e o total:

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Explain tokens in three sentences."
)

usage = response.usage
print(f"Input tokens: {usage.input_tokens}")
print(f"Output tokens: {usage.output_tokens}")
print(f"Total: {usage.total_tokens}")

# Result:
# Input tokens: 12
# Output tokens: 58
# Total: 70

Três Alavancas de Otimização

A primeira alavanca é a concisão do prompt. Fórmulas de cortesia e precauções retóricas não melhoram a resposta e custam tokens até ao último: a primeira versão abaixo utiliza trinta e cinco tokens para um resultado idêntico ao da segunda, que utiliza dez. À escala de um serviço que processa um milhão de pedidos, a diferença deixa de ser anedótica.

# BAD — verbose prompt (35 tokens)
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Could you please give me a list "
          "of three fruits that are red in color, if that "
          "does not bother you of course?"
)

# GOOD — concise prompt (10 tokens)
response = client.responses.create(
    model="gpt-5.6-terra",
    input="List 3 red fruits."
)

A segunda alavanca visa a saída, que custa várias vezes mais do que a entrada. Combine a instrução no prompt com um limite técnico: o primeiro enquadra a escrita, o segundo garante que o seu orçamento se mantém mesmo que o modelo ignore a instrução.

# No limit — the model can generate many tokens
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Explain photosynthesis."
)

# With limit — cost control
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Explain photosynthesis in 2 sentences maximum.",
    max_output_tokens=100
)

A terceira alavanca é estimar o custo antes da chamada, o que se torna essencial assim que processa documentos de tamanho variável. Pode então rejeitar ou dividir um pedido que seja demasiado pesado, em vez de o descobrir na sua fatura.

import tiktoken

def estimate_cost(text: str, model: str = "gpt-5.6-terra") -> dict:
    """Estimate the cost of an API call."""
    enc = tiktoken.get_encoding("cl200k_base")
    input_tokens = len(enc.encode(text))

    # Approximate prices per million tokens (check current prices)
    prices = {
        "gpt-5.6-sol": {"input": 5.0, "output": 30.0},
        "gpt-5.6-terra": {"input": 2.0, "output": 12.0},
        "gpt-5.6-luna": {"input": 0.20, "output": 1.20},
    }

    input_cost = (input_tokens / 1_000_000) * prices[model]["input"]

    return {
        "input_tokens": input_tokens,
        "input_cost_usd": round(input_cost, 6),
        "model": model
    }

print(estimate_cost("Explain relativity in 3 sentences."))
# Result: {'input_tokens': 10, 'input_cost_usd': 2.5e-05, 'model': 'gpt-5.6-terra'}

O Contexto Acumula-se Ao Longo da Conversação

Quando encadeia trocas utilizando previous_response_id, cada turno reinicia a partir da totalidade dos turnos anteriores. Os tokens de entrada continuam, portanto, a crescer: um diálogo que começa com 50 tokens pesa 150 no segundo turno e muito mais no décimo. Esta é a causa mais comum de faturas que disparam sem aumento de tráfego, e monitorizar response.usage.input_tokens é o seu sinal de alerta.

# Turn 1: 50 tokens
r1 = client.responses.create(
    model="gpt-5.6-terra",
    input="Hello, I am a Python developer."
)

# Turn 2: 50 + 100 = 150 tokens (cumulative context)
r2 = client.responses.create(
    model="gpt-5.6-terra",
    input="Which web frameworks do you recommend?",
    previous_response_id=r1.id
)

# Turn 10: tokens accumulate!
# Monitor response.usage.input_tokens to avoid surprises
print(f"Cumulative tokens at turn 2: {r2.usage.input_tokens}")

Para conversas longas, a solução é truncar ativamente o histórico: remova as mensagens mais antigas até ficar abaixo de um limite escolhido, mantendo a primeira, que geralmente carrega o contexto fundador da troca.

def conversation_with_limit(messages: list, token_limit: int = 50000):
    """Keep the conversation under a token limit."""
    enc = tiktoken.get_encoding("cl200k_base")

    total = sum(len(enc.encode(m["content"])) for m in messages)

    # Remove oldest messages if necessary
    while total > token_limit and len(messages) > 2:
        removed = messages.pop(1)  # Keep the first message (context)
        total -= len(enc.encode(removed["content"]))

    return messages

Pontos-chave

  • Um token equivale a cerca de 0,7 palavras em português
  • A janela de contexto inclui a entrada E a saída
  • As janelas variam consoante o modelo: na geração anterior, 1M de tokens para o GPT-5.4 e 200K para o GPT-5.3, o3-pro e o4-mini
  • Utilize o tiktoken para contar tokens antes da chamada
  • Monitore response.usage para controlar os seus custos
  • Gere ativamente o contexto em conversas longas