advanced⏱70 minLição 4 de 10

Gerenciamento de Contexto

Domine janelas de contexto, sistemas de memoria, geracao aumentada por recuperacao, estrategias de sumarizacao para agentes de IA.

Gerenciamento de Contexto

O Desafio do Contexto

Agentes de IA enfrentam uma restricao fundamental: janelas de contexto limitadas. Mesmo os maiores modelos (200K+ tokens) nao podem conter um codigo fonte inteiro, historico de conversacao e instrucoes da tarefa simultaneamente.

💡 Tip: Use Ctrl + Mouse Wheel to zoom, or click the fullscreen icon

ℹ️Note

Gerenciamento de contexto nao e apenas sobre caber no orcamento de tokens. E sobre decisoes inteligentes sobre o que manter, comprimir, buscar e esquecer.

Sistemas de Memoria

python

class MemoriaHierarquica:
    def __init__(self):
        self.memoria_trabalho = {}
        self.curto_prazo = []
        self.longo_prazo = {}
        self.armazenamento_semantico = []

    def adicionar_trabalho(self, chave, valor):
        self.memoria_trabalho[chave] = valor

    def obter_trabalho(self, chave):
        return self.memoria_trabalho.get(chave)

    def adicionar_curto_prazo(self, mensagem, max_tamanho=20):
        self.curto_prazo.append(mensagem)
        if len(self.curto_prazo) > max_tamanho:
            self.curto_prazo = self.curto_prazo[-max_tamanho:]

    def lembrar(self, chave, valor, importancia=1.0):
        self.longo_prazo[chave] = {
            "valor": valor,
            "importancia": importancia,
            "timestamp": __import__('time').time()
        }

    def recordar(self, chave):
        entrada = self.longo_prazo.get(chave)
        return entrada["valor"] if entrada else None

    def recordar_por_relevancia(self, consulta, top_k=3):
        scores = []
        for chave, entrada in self.longo_prazo.items():
            if consulta.lower() in chave.lower():
                scores.append((entrada["importancia"], chave, entrada["valor"]))
        scores.sort(reverse=True)
        return [(k, v) for _, k, v in scores[:top_k]]

    def sumarizar_e_arquivar(self):
        if len(self.curto_prazo) > 10:
            textos = [m["conteudo"] for m in self.curto_prazo[:5]]
            sumario = " | ".join(textos)
            self.longo_prazo["sumario_conversa"] = {
                "valor": sumario[:500],
                "importancia": 0.5,
                "timestamp": __import__('time').time()
            }
            self.curto_prazo = self.curto_prazo[-5:]


memoria = MemoriaHierarquica()
memoria.lembrar("nome_projeto", "Plataforma Nova", importancia=1.0)
memoria.lembrar("stack_tecnologica", ["Python", "FastAPI", "React"], importancia=0.9)
memoria.adicionar_curto_prazo({"papel": "usuario", "conteudo": "Corrigir bug de login"})
memoria.adicionar_curto_prazo({"papel": "assistente", "conteudo": "Encontrei o problema em auth.py"})
relevantes = memoria.recordar_por_relevancia("stack")
print(f"Stack tecnologica: {relevantes}")

RAG (Geracao Aumentada por Recuperacao)

python

class SistemaRAG:
    def __init__(self):
        self.documentos = []
        self.indice = {}

    def adicionar_documento(self, doc_id, conteudo, metadata=None):
        idx = len(self.documentos)
        self.documentos.append({
            "id": doc_id,
            "conteudo": conteudo,
            "metadata": metadata or {}
        })
        for palavra in conteudo.lower().split():
            if palavra not in self.indice:
                self.indice[palavra] = []
            self.indice[palavra].append(idx)

    def buscar(self, consulta, top_k=3):
        palavras_consulta = consulta.lower().split()
        scores = {}
        for q_palavra in palavras_consulta:
            for doc_idx in self.indice.get(q_palavra, []):
                if doc_idx not in scores:
                    scores[doc_idx] = 0
                scores[doc_idx] += 1

        ranked = sorted(scores.items(), key=lambda x: x[1], reverse=True)
        resultados = []
        for doc_idx, score in ranked[:top_k]:
            doc = self.documentos[doc_idx]
            resultados.append({
                "id": doc["id"],
                "conteudo": doc["conteudo"][:500],
                "relevancia": score / len(palavras_consulta),
                "metadata": doc["metadata"]
            })
        return resultados

    def construir_contexto(self, consulta, max_tokens=2000):
        resultados = self.buscar(consulta)
        partes = []
        contagem = 0
        for r in resultados:
            snippet = f"[Fonte: {r['id']}]\n{r['conteudo']}\n"
            tokens = len(snippet.split())
            if contagem + tokens > max_tokens:
                break
            partes.append(snippet)
            contagem += tokens
        return "\n---\n".join(partes)


rag = SistemaRAG()
rag.adicionar_documento(
    "auth-flow.md",
    "O fluxo de autenticacao usa tokens JWT com expiracao de 1 hora. "
    "Tokens de atualizacao sao armazenados em cookies HTTP-only."
)
rag.adicionar_documento(
    "api-endpoints.md",
    "POST /api/auth/login - Autenticar usuario\n"
    "POST /api/auth/refresh - Atualizar token\n"
    "GET /api/auth/profile - Obter perfil"
)
contexto = rag.construir_contexto("Como funciona a autenticacao?")
print(contexto)

Estrategias de Sumarizacao

yaml

sumarizacao:
  estrategia: hierarquica
  limiares:
    curto_prazo: 10
    sessao: 50
    total: 200
  incluir_no_sumario:
    - decisoes_tomadas
    - alteracoes_codigo
    - padroes_erro
    - preferencias_usuario
  campos_preservar:
    - caminhos_arquivos
    - nomes_funcoes
    - versoes
    - endpoints_api

Limites de Janela de Contexto

Modelo	Janela	Orcamento Efetivo
GPT-4o	128K tokens	~96K
GPT-4o-mini	128K tokens	~96K
Claude Sonnet 4	200K tokens	~170K
Claude Opus 4	200K tokens	~170K
Gemini 1.5 Pro	1M tokens	~800K

Pratica

Practice Question

Qual o proposito principal de uma janela deslizante no gerenciamento de contexto?

Practice Question

Em um sistema de memoria hierarquica, que tipo de informacao deve ser armazenada na memoria de longo prazo?

Practice Question

Para que serve RAG (Geracao Aumentada por Recuperacao) no gerenciamento de contexto?

✅**Principais Conclusoes**

Gerenciamento de contexto requer decisoes sobre o que manter, comprimir, buscar e esquecer
Memoria hierarquica (trabalho, curto prazo, longo prazo, semantico) fornece arquitetura escalavel
RAG permite acesso a grandes bases de conhecimento sem encher a janela de contexto
Sumarizacao comprime informacao preservando detalhes importantes
Priorizacao de contexto garante que itens critics sempre caibam no orcamento de tokens
Diferentes modelos tem limites diferentes; projete para o orcamento efetivo

Fluxo de Trabalho Detalhado

💡 Tip: Use Ctrl + Mouse Wheel to zoom, or click the fullscreen icon

💡Tip

Este diagrama ilustra o fluxo de trabalho basico do agente. Adapte-o ao seu caso de uso especifico.

Exemplos Adicionais de Codigo

python

# Exemplo adicional de implementacao
class ExemploAdicional:
    """Classe de exemplo para ilustrar conceitos adicionais."""

    def __init__(self, nome):
        self.nome = nome
        self.dados = {}

    def processar(self, entrada):
        """Processa a entrada e armazena o resultado."""
        resultado = self._transformar(entrada)
        self.dados[entrada] = resultado
        return resultado

    def _transformar(self, valor):
        return valor * 2 if isinstance(valor, (int, float)) else valor.upper()

    def obter_estatisticas(self):
        """Retorna estatisticas sobre os dados processados."""
        if not self.dados:
            return {"status": "vazio", "total": 0}
        return {
            "status": "processado",
            "total": len(self.dados),
            "ultimo": list(self.dados.keys())[-1]
        }

exemplo = ExemploAdicional('teste')
print(exemplo.processar(21))  # 42
print(exemplo.obter_estatisticas())

json

{
  "configuracao_exemplo": {
    "versao": "1.0",
    "parametros": {
      "timeout": 30,
      "max_tentativas": 3,
      "modo": "automatico"
    },
    "seguranca": {
      "requer_aprovacao": true,
      "nivel_autonomia": 2
    }
  }
}

yaml

# configuracao-adicional.yaml
ambiente:
  nome: producao
  variaveis:
    LOG_LEVEL: "debug"
    MAX_TOKENS: 128000
agentes:
  - nome: agente-principal
    modelo: gpt-4o
    temperatura: 0.3
  - nome: agente-revisor
    modelo: claude-sonnet-4-20250514
    ferramentas_permitidas:
      - read
      - grep
      - glob
    ferramentas_negadas:
      - write
      - edit
      - bash

monitoramento:
  metrics: true
  tracing: true
  alertas:
    - tipo: erro_critico
      canal: slack
    - tipo: timeout
      canal: email

Notas Importantes

ℹ️Note

Este conceito e fundamental para o entendimento do modulo. Certifique-se de compreende-lo antes de prosseguir.

⚠️Warning

Preste atencao a este detalhe: configuracoes incorretas podem levar a comportamentos inesperados do agente.

💡Tip

Uma dica pratica: sempre valide suas configuracoes em ambiente de staging antes de promover para producao.

✅Success

Ao dominar este conceito, voce estara apto a construir agentes mais robustos e confiaveis.

Tabela Comparativa

Caracteristica	Abordagem A	Abordagem B	Abordagem C
Complexidade	Baixa	Media	Alta
Flexibilidade	Limitada	Moderada	Total
Manutencao	Facil	Media	Dificil
Performance	Otima	Boa	Variavel
Seguranca	Basica	Avancada	Maxima
Caso de uso	Prototipos	Producao	Sistemas criticos

ℹ️Note

Escolha a abordagem com base nos requisitos especificos do seu projeto. Nao existe solucao unica para todos os casos.

Practice Question

Pergunta adicional 1 sobre o conteudo desta aula?

Practice Question

Pergunta adicional 2 sobre o conteudo desta aula?

Practice Question

Pergunta adicional 3 sobre o conteudo desta aula?

✅**Principais Conclusoes Adicionais**

Reforce seu entendimento praticando com exemplos reais
Consulte a documentacao oficial para casos avancados
Compartilhe seu conhecimento com a comunidade
Sempre teste suas implementacoes em ambientes controlados
Mantenha-se atualizado com as melhores praticas da industria
A pratica consistente e a chave para a maestria
Agentes de IA bem projetados combinam tecnologia com boas praticas de engenharia

Progresso40%

Habilidades e Capacidades

Pipelines de Agentes

Contéudo do Curso

1. Introducao a Agentes de IA 2. Arquitetura de Agentes 3. Habilidades e Capacidades 4. Gerenciamento de Contexto 5. Pipelines de Agentes 6. OpenCode como Ferramenta de Desenvolvimento 7. Construindo Habilidades Personalizadas 8. Engenharia de Prompt para Agentes 9. Melhores Praticas e Padroes 10. Projetos Reais com Agentes