Conteúdo do curso Lição 175 de 250 · Construindo Agentes (Uso de Ferramentas e ReAct)
Construindo Agentes (Uso de Ferramentas e ReAct)

Memória do Agente e Acúmulo de Estado

O laço ReAct que você construiu tem amnésia: cada passo chama uma tool e esquece. Um agente real tem que levar o que aprendeu adiante - os fatos que ele buscou, os resultados que as tools retornaram - para que um passo posterior possa usá-los. Esse notebook em execução é a memória do agente (as pessoas também chamam de scratchpad ou contexto de trabalho). Seu código é o dono dela; o modelo nunca é.

Mas contexto não é de graça. Tudo na memória é colocado de volta no prompt no próximo passo, e o modelo tem uma janela de contexto fixa medida em tokens. Deixe a memória crescer para sempre e você eventualmente transbordará a janela (e pagará por cada token além disso). Então a memória precisa de duas metades: acumular novos fatos conforme você avança, e cortar de volta para um Orçamento quando ficar muito grande.

O formato disso

State é um dicionário: uma nota system permanente (as instruções fixas do agente, que você nunca descarta) e uma lista de facts que ele coletou:

state = {"system": "You are a research agent.", "facts": []}

Cada observação se torna uma linha de fato. Depois que uma ferramenta roda, você anexa um registro legível do que aconteceu:

state["facts"].append(f"{tool}({args}) -> {observation}")

Recortando para um orçamento de tokens

Tokenizadores reais são aprendidos e baseados em subpalavras; não podemos rodar um aqui, então estimamos um token como uma palavra com espaço (len(text.split())) - o mesmo truque do módulo LLM. (Em produção você usaria a contagem real de subpalavras do campo usage da API, ou a regra prática de caracteres len(text) / 4; a estimativa de espaço apenas mantém este exercício determinístico.) A regra de corte espelha o que agentes de produção realmente fazem: sempre mantenha a nota do sistema, depois mantenha tantos dos mais-recentes fatos quanto couber no que sobra do Orçamento. Recência vence porque os resultados mais recentes são geralmente os que o próximo passo precisa.

budget = max_tokens - est_tokens(state["system"])
# walk facts newest-first, keep while they fit, then stop

Percorra os fatos do mais novo ao mais antigo, somando o custo de token de cada um até que o próximo fato ultrapasse o Orçamento, então pare. Inverta de volta para que os fatos mantidos fiquem em sua ordem original. Se o Orçamento for minúsculo você pode manter zero fatos, mas a nota do sistema sempre sobrevive.

Em um agente ao vivo, o modelo leria render(state) no topo de cada passo e o mesmo ciclo de acumular-e-trimmer rodaria após cada tool call, para que a janela nunca transborde. O tutor no dispositivo pode conduzir esse laço, mas a correção apenas inspeciona o estado determinístico. Pressione Run para acumular uma transcrição curta e observe os fatos mais antigos caírem sob um orçamento apertado.

Sua vez

Construa a memória do agente. Escreva new_state(system_note) -> {"system": note, "facts": []}; record(state, tool, args, observation) que anexa a linha de fato "<tool>(<args>) -> <observation>" e retorna o estado; est_tokens(text) -> contagem de tokens de espaço em branco; e trim(state, max_tokens) que mantém a nota do sistema mais os fatos mais recentes cujos tokens (a nota do sistema conta no Orçamento) cabem em max_tokens. Depois escreva accumulate(system_note, transcript, max_tokens): inicie um estado novo, record a cada (tool, args, observation) passo em ordem, trim uma vez no final, e retorne o estado aparado.

Viu um problema nesta lição? Reporte-o · Pergunte sobre esta lição

Este exercício abre em breve

Termine a lição anterior para que esta seja desbloqueada. O curso inteiro é gratuito, não precisa de conta, e você pode ler esta lição agora mesmo.