Estratégias para permanecer dentro do contexto
Implemente memória com janela deslizante, resumo de mensagens e redução seletiva de contexto para lidar com conversas longas sem exceder os limites de tokens.
Estratégias para permanecer dentro do contexto é uma aula grátis de AI Engineering Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Engineering Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Engineering Academy inclui 4 aulas no total.
O problema crescente das conversas
Cada mensagem trocada em uma conversa de chat aumenta a contagem de tokens da próxima chamada à API. Em uma longa sessão de suporte ao cliente ou em uma sessão de programação de várias horas, o histórico acumulado da conversa pode facilmente exceder 20.000–50.000 tokens — e você precisa enviar tudo isso à API a cada turno, pagando repetidamente pelos tokens processados anteriormente.
Sem uma estratégia de gerenciamento de contexto, sua aplicação atingirá o limite de contexto e falhará, ou você acabará truncando mensagens silenciosamente, fazendo com que o modelo perca o controle de informações importantes do contexto anterior. Toda aplicação LLM em produção precisa de uma estratégia explícita para gerenciar o crescimento do contexto.
Estratégia 1: janela deslizante (últimas N mensagens)
A estratégia mais simples é manter apenas as últimas N mensagens no contexto, descartando as mais antigas. Isso é chamado de janela deslizante. É fácil de implementar, tem custo previsível e é suficiente para muitos casos de uso em que o contexto recente é mais importante que as trocas anteriores.
import openai
client = openai.OpenAI()
class SlidingWindowConversation:
def __init__(self, system_prompt, window_size=10):
self.system = system_prompt
self.window_size = window_size
self.history = []
def chat(self, user_message):
self.history.append({'role': 'user', 'content': user_message})
# Keep only the last N messages
windowed = self.history[-self.window_size:]
messages = [{'role': 'system', 'content': self.system}] + windowed
response = client.chat.completions.create(
model='gpt-4o-mini',
messages=messages
)
reply = response.choices[0].message.content
self.history.append({'role': 'assistant', 'content': reply})
print(f'Context: {len(windowed)} messages ({len(self.history)} total)')
return reply
conv = SlidingWindowConversation('You are a helpful assistant.', window_size=6)
print(conv.chat('Hello! My name is Alice.'))
print(conv.chat('What is the capital of France?'))
print(conv.chat('What is my name?')) # Might forget if window is smallEstratégia 2: truncamento consciente dos tokens
Em vez de truncar com base na quantidade de mensagens, o truncamento consciente dos tokens remove mensagens até que a contagem total de tokens fique abaixo de um limite. Isso é mais preciso porque as mensagens podem variar muito de tamanho — um limite de quantidade de mensagens pode incluir 10 mensagens curtas ou 3 muito longas, com custos de tokens bastante diferentes.
import tiktoken
def trim_to_token_budget(
messages, system_prompt, model='gpt-4o-mini', max_input_tokens=8000
):
enc = tiktoken.encoding_for_model(model)
def count(msgs):
return sum(len(enc.encode(m.get('content',''))) + 4 for m in msgs) + 3
# System prompt token count
system_tokens = len(enc.encode(system_prompt)) + 4
budget = max_input_tokens - system_tokens
# Trim from the oldest messages until we fit
trimmed = list(messages)
while trimmed and count(trimmed) > budget:
trimmed.pop(0) # Remove oldest message
removed = len(messages) - len(trimmed)
if removed:
print(f'Trimmed {removed} old messages to stay within {max_input_tokens} tokens')
return trimmedEstratégia 3: sumarização da conversa
A sumarização comprime os turnos antigos da conversa em um resumo conciso, preservando os fatos, as decisões e o contexto principais mencionados pelo usuário. Essa estratégia é mais sofisticada que as janelas deslizantes porque mantém a essência das trocas anteriores, em vez de simplesmente descartá-las.
O padrão funciona da seguinte forma: quando a conversa exceder um limite, envie os N turnos mais antigos ao modelo com um prompt como 'Resuma esta conversa até o momento', substitua esses turnos por uma única mensagem do sistema contendo o resumo e continue a conversa com o novo histórico compactado.
import openai
client = openai.OpenAI()
def summarize_conversation(messages_to_summarize, model='gpt-4o-mini'):
summary_prompt = [
{'role': 'system', 'content': 'You summarize conversations. Be concise but preserve key facts, decisions, and any specific information the user shared (names, numbers, preferences).'},
{'role': 'user', 'content': 'Summarize this conversation:\n' + '\n'.join(
f"{m['role'].upper()}: {m['content']}" for m in messages_to_summarize
)}
]
resp = client.chat.completions.create(model=model, messages=summary_prompt, max_tokens=500)
return resp.choices[0].message.content
def compress_history(history, keep_recent=4):
if len(history) <= keep_recent:
return history
to_summarize = history[:-keep_recent]
summary = summarize_conversation(to_summarize)
summary_msg = {'role': 'system', 'content': f'Earlier conversation summary: {summary}'}
return [summary_msg] + history[-keep_recent:]
print('Summarization strategy compresses old turns into a single summary message')Estratégia 4: memória de entidades
A memória de entidades extrai e mantém uma representação estruturada dos principais fatos mencionados na conversa — preferências do usuário, nomes, detalhes do projeto e decisões tomadas — em vez de armazenar o histórico bruto das mensagens. Antes de cada turno, os fatos armazenados são inseridos no prompt do sistema.
Essa estratégia é mais eficiente em tokens que o histórico completo, porque você inclui apenas o que é semanticamente importante, e não todas as palavras de cada turno. A memória de entidades funciona especialmente bem para assistentes de longa duração, nos quais os usuários fazem referência a preferências e fatos estabelecidos muito antes na conversa.
import openai
import json
client = openai.OpenAI()
def extract_entities(messages, model='gpt-4o-mini'):
prompt = [
{'role': 'system', 'content': 'Extract key facts from this conversation as JSON: {"user_name": null, "preferences": [], "key_facts": []}'},
{'role': 'user', 'content': '\n'.join(f"{m['role']}: {m['content']}" for m in messages)}
]
resp = client.chat.completions.create(
model=model,
messages=prompt,
response_format={'type': 'json_object'}
)
return json.loads(resp.choices[0].message.content)
conversation = [
{'role': 'user', 'content': 'Hi, I am Alice and I prefer Python over JavaScript.'},
{'role': 'assistant', 'content': 'Great to meet you, Alice! Python is an excellent choice.'},
{'role': 'user', 'content': 'I am building a REST API for my e-commerce startup.'}
]
entities = extract_entities(conversation)
print(json.dumps(entities, indent=2))Quando aplicar cada estratégia
Escolha sua estratégia com base nas características da sua aplicação:
- Janela deslizante: aplicações simples de chat em que apenas o contexto recente importa e os usuários não fazem referência a trocas antigas. É a opção mais barata de implementar.
- Truncamento consciente dos tokens: qualquer aplicação em produção em que o tamanho das mensagens varie significativamente. É sempre melhor que o truncamento por quantidade de mensagens.
- Sumarização: assistentes de longa duração, sessões de suporte ao cliente e robôs de gerenciamento de projetos. Os usuários esperam que o assistente se lembre de fatos importantes de trocas ocorridas horas antes.
- Memória de entidades: assistentes pessoais, chatbots atentos às preferências do usuário e sistemas de tutoria em que o perfil do usuário importa durante toda a sessão.
Essas estratégias também podem ser combinadas: use a memória de entidades para os fatos essenciais e uma janela deslizante para a conversa recente.
RAG como alternativa ao preenchimento do contexto
Para aplicações com grande volume de conhecimento, a melhor estratégia de gerenciamento de contexto é não colocar os documentos no contexto; em vez disso, use RAG (Geração Aumentada por Recuperação) para recuperar apenas os trechos específicos relevantes para a consulta atual. Isso mantém o contexto focado, custa menos e muitas vezes produz respostas melhores que inserir um documento inteiro.
A principal percepção é que janelas de contexto longas resolvem o problema de caber ou não caber, mas não o problema de o modelo saberá usá-lo bem?. A recuperação precisa resolve ambos, fornecendo ao modelo apenas as informações de que ele realmente precisa para a pergunta atual.
Como lidar adequadamente com erros de contexto máximo
Apesar dos melhores esforços, você pode encontrar erros de limite de contexto em produção, especialmente por causa de conteúdo gerado pelo usuário que é inesperadamente longo. Sempre trate explicitamente o erro context_length_exceeded, em vez de permitir que ele seja propagado como uma exceção não tratada até o usuário.
import openai
import tiktoken
client = openai.OpenAI()
def chat_with_context_guard(messages, model='gpt-4o-mini', max_tokens=100000):
enc = tiktoken.encoding_for_model(model)
total = sum(len(enc.encode(m.get('content',''))) + 4 for m in messages) + 3
while total > max_tokens and len(messages) > 2:
# Remove the second message (keep system prompt)
removed = messages.pop(1)
total -= len(enc.encode(removed.get('content',''))) + 4
print(f'Trimmed a message. New total: {total} tokens')
try:
return client.chat.completions.create(model=model, messages=messages)
except openai.BadRequestError as e:
if 'context_length' in str(e):
return {'error': 'Message history too long. Please start a new conversation.'}
raisePersistência do contexto entre sessões
Em uma aplicação real, os usuários fecham e reabrem o aplicativo. O servidor é reiniciado. O gerenciamento de contexto precisa considerar a persistência entre sessões, não apenas dentro de uma única sessão. Isso significa armazenar o histórico da conversa em um banco de dados e carregá-lo no início de cada sessão.
Um padrão sensato é armazenar todo o histórico bruto em PostgreSQL para fins de auditoria e ajuste fino, mas, ao carregar o contexto para uma nova chamada à API, aplicar sua estratégia de sumarização ou truncamento para mantê-lo dentro do orçamento de tokens. Dessa forma, você nunca perde dados, mas não paga pelo histórico completo a cada solicitação.
Monitoramento do crescimento do contexto em produção
Registre a contagem de tokens de cada chamada à API e acompanhe sua evolução ao longo do tempo por ID da conversa. Uma conversa saudável deve mostrar um crescimento gradual seguido de um platô, à medida que a sumarização entra em ação. Uma conversa que cresce sem limite até atingir o limite de contexto indica que sua lógica de truncamento não está funcionando corretamente.
Monitore também o tamanho médio do contexto em todas as conversas. Se ele apresentar uma tendência de alta ao longo do tempo, isso pode indicar que seu prompt de sistema padrão está crescendo (por causa da adição de funcionalidades), que os usuários estão colando entradas mais longas ou que o RAG está retornando trechos progressivamente maiores. Cada uma dessas situações exige uma correção diferente.
Combinação de estratégias: um padrão para produção
Um sistema robusto de gerenciamento de contexto em produção combina várias estratégias em camadas:
- Antes de montar o contexto: verifique o orçamento de tokens e registre-o
- Aplique a extração de entidades: insira um bloco de memória estruturada com os fatos principais
- Adicione o histórico recente: inclua as últimas 6–10 mensagens literalmente
- Faça a sumarização do histórico antigo: se houver histórico antigo, insira um resumo contínuo
- Verificação de proteção: se o total ainda exceder o orçamento, remova as mensagens literais mais antigas
Essa abordagem em camadas preserva as informações mais importantes (memória de entidades e contexto recente), enquanto reduz gradualmente o histórico antigo a resumos e, somente como último recurso, ao truncamento.
Verificação rápida
Teste sua compreensão dos conceitos de Engenharia de IA desta lição.
Recapitulação da lição
Nesta lição, você aprendeu que: as janelas deslizantes e o truncamento consciente dos tokens são estratégias simples que descartam o contexto antigo para permanecer dentro dos limites, a sumarização comprime os turnos antigos em uma representação compacta que preserva os fatos principais e a memória de entidades extrai fatos estruturados para fornecer uma memória de longo prazo eficiente em tokens ao longo de uma conversa. A seguir, exploraremos como fazer LLMs retornarem JSON confiável usando o modo JSON e saídas estruturadas.
Aprenda Python com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 30
- Aulas
- 120
Perguntas Frequentes
A aula “Estratégias para permanecer dentro do contexto” é grátis?
Sim — o texto completo de “Estratégias para permanecer dentro do contexto” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Engineering Academy, atualize para CoddyKit PRO. O curso de AI Engineering Academy inclui 4 aulas no total.
O que vou aprender em “Estratégias para permanecer dentro do contexto”?
Implemente memória com janela deslizante, resumo de mensagens e redução seletiva de contexto para lidar com conversas longas sem exceder os limites de tokens. Você pratica AI Engineering Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar AI Engineering Academy?
Nenhuma experiência prévia é necessária. AI Engineering Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.
Quanto tempo leva a aula “Estratégias para permanecer dentro do contexto”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de AI Engineering Academy?
Sim. Cada aula de AI Engineering Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- O que é um token?
- Janelas de contexto: tamanho e implicações
- Calculando e prevendo custos de API
- Estratégias para permanecer dentro do contexto