AI Agents · Aula

Decaimento da memória e coleta de lixo

Esqueça memórias antigas e pouco relevantes em intervalos programados para manter o índice concentrado.

Aula 4 de 415 etapas

Decaimento da memória e coleta de lixo é uma aula grátis de AI Agents 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 Agents, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Agents inclui 4 aulas no total.

A memória cresce sem limites

Sem manutenção ativa, seu armazenamento de memória continua crescendo. Memórias antigas e irrelevantes poluem a recuperação e desperdiçam espaço de armazenamento.

A memória precisa de coleta de lixo, assim como qualquer outro recurso.

Por que excluir memórias?

  • Privacidade — cumprir solicitações de exclusão do GDPR/CCPA
  • Relevância — fatos antigos têm menos probabilidade de continuar corretos
  • Custo — o armazenamento vetorial se acumula em grande escala
  • Qualidade — índices inflados diluem a relevância da pesquisa

Estratégia 1: TTL

Defina um registro de data e hora de expiração para cada memória:

ALTER TABLE semantic_facts ADD COLUMN expires_at TIMESTAMPTZ;

-- short-lived
INSERT INTO semantic_facts (..., expires_at) VALUES (..., NOW() + INTERVAL '7 days');

-- garbage collect
DELETE FROM semantic_facts WHERE expires_at < NOW();

Estratégia 2: decaimento baseado no tempo

Diminua a confiança com o passar do tempo — memórias mais antigas recebem menor prioridade:

import math

def decayed_confidence(original, age_days, half_life_days=30):
    return original * math.exp(-age_days * math.log(2) / half_life_days)

# Then retrieval filters: WHERE decayed_confidence > 0.3
for age in [0, 30, 60, 90]:
    print(f"Age {age} days -> confidence {decayed_confidence(1.0, age):.3f}")

Estratégia 3: decaimento baseado no uso

Memórias que nunca são recuperadas não são úteis — exclua-as após um período de carência:

ALTER TABLE semantic_facts ADD COLUMN last_used_at TIMESTAMPTZ DEFAULT NOW();

-- update on retrieval
UPDATE semantic_facts SET last_used_at = NOW() WHERE id = ANY(:retrieved_ids);

-- gc
DELETE FROM semantic_facts WHERE last_used_at < NOW() - INTERVAL '90 days';

Estratégia 4: limite de capacidade por usuário

Limite o número de memórias por usuário; quando o limite for atingido, remova a menos utilizada:

MAX_FACTS = 500

SELECT COUNT(*) FROM semantic_facts WHERE user_id = %s;
-- if > MAX_FACTS: delete oldest unused

Compactação: mesclar memórias semelhantes

Várias memórias podem dizer a mesma coisa de maneiras diferentes. Periodicamente, agrupe-as e mescle-as:

def compact(user_id):
    facts = all_facts(user_id)
    clusters = cluster_by_embedding(facts, threshold=0.85)
    for cluster in clusters:
        merged = llm.invoke(f'Merge these into one canonical statement: {cluster}')
        replace_with_merged(cluster, merged)

Resolução de contradições

Se duas memórias se contradisserem, marque a mais antiga como obsoleta:

def resolve(user_id, new_fact):
    similar = retrieve(user_id, new_fact, k=5)
    for s in similar:
        if llm_says_contradicts(s, new_fact):
            mark_obsolete(s.id)
    save(new_fact)

Estratégia 5: ponderação por importância

Algumas memórias são mais importantes que outras. Atribua uma pontuação a cada uma:

importance_prompt = 'Rate the importance of this fact for future interactions (0-1):\n{fact}'

for fact in facts:
    score = float(llm.invoke(importance_prompt.format(fact=fact)).content)
    update_importance(fact.id, score)

# Retrieval: weight by importance and recency

Sumarização no estilo Letta

Letta (MemGPT) compacta a memória arquivada antiga ao resumir blocos de fatos relacionados quando o armazenamento fica cheio:

if archival_size > LIMIT:
    block = oldest_facts(50)
    summary = summarise(block)
    replace(block, summary)

Exclusão acionada pelo usuário

Ofereça aos usuários um botão "esquecer tudo sobre mim". Ao clicar:

def forget_user(user_id):
    conn.execute('DELETE FROM semantic_facts WHERE user_id = %s', (user_id,))
    conn.execute('DELETE FROM episodes WHERE user_id = %s', (user_id,))
    vector_db.delete(filter={'user_id': user_id})

Exclusão lógica versus exclusão física

Para auditorias, prefira a exclusão lógica (marque como excluído, mas mantenha os dados criptografados) até o fim do período de retenção; depois, faça a exclusão física:

ALTER TABLE semantic_facts ADD COLUMN deleted_at TIMESTAMPTZ;
-- queries always: WHERE deleted_at IS NULL

Tarefas agendadas de coleta de lixo

Execute a coleta de lixo conforme uma programação (cron, processo diário). Não faça uma coleta de lixo pesada durante o processamento da solicitação — isso aumenta a latência para os usuários:

# Daily cron at 03:00 UTC
for user_id in all_users():
    decay_confidence(user_id)
    delete_expired(user_id)
    compact_clusters(user_id)

Por que usar decaimento?

Por que diminuir a confiança nas memórias ao longo do tempo?

Recapitulação

TTL, decaimento, remoção baseada no uso, limites de capacidade, compactação, resolução de contradições e exclusão acionada pelo usuário. A memória precisa de um zelador; crie um.

Grátis para começar

Aprenda AI Agents 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
60
Aulas
239

Perguntas Frequentes

A aula “Decaimento da memória e coleta de lixo” é grátis?

Sim — o texto completo de “Decaimento da memória e coleta de lixo” é 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 Agents, atualize para CoddyKit PRO. O curso de AI Agents inclui 4 aulas no total.

O que vou aprender em “Decaimento da memória e coleta de lixo”?

Esqueça memórias antigas e pouco relevantes em intervalos programados para manter o índice concentrado. Você pratica AI Agents 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 Agents?

Nenhuma experiência prévia é necessária. AI Agents 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 “Decaimento da memória e coleta de lixo”?

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 Agents?

Sim. Cada aula de AI Agents 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

  1. Memória episódica (histórico por sessão)
  2. Memória semântica (fatos vetorizados)
  3. Memória procedural (biblioteca de habilidades)
  4. Decaimento da memória e coleta de lixo
← Voltar para AI Agents