d-o-hub/memória-episódica-autoaprendizagem-rust

O que memória-episódica-autoaprendizagem-rust faz?

Um sistema modular de memória episódica autoaprendizável em Rust para agentes de IA, com armazenamento híbrido usando Turso (SQL) e redb (KV), rastreamento de execução assíncrona, pontuação de recompensa, reflexão e evolução de habilidades baseada em padrões. Projetado para aplicabilidade real, manutenibilidade e fluxos de trabalho de agentes escaláveis.

Visão Geral

Esta skill capacita agentes de IA com um sistema de memória episódica que permite:

• Aprendizado Contínuo: O agente aprende com ações passadas, armazenando episódios de execução e refinando seu comportamento com base em recompensas.
• Armazenamento Híbrido: Utiliza Turso (um banco de dados SQL serverless) para metadados estruturados e redb (um banco de dados key-value embarcado) para dados de episódios não estruturados.
• Rastreamento Assíncrono: As execuções de ações são registradas de forma não bloqueante, permitindo que o agente continue operando sem interrupções.
• Reflexão e Evolução: Através da pontuação de recompensa, o sistema reflete sobre episódios passados, identifica padrões e evolui automaticamente as habilidades do agente.

Por que isso é útil?

Agentes de IA tradicionais muitas vezes falham em aprender com experiências passadas, resultando em comportamentos repetitivos e ineficientes. Este sistema de memória episódica permite que o agente:

• Melhore seu desempenho ao longo do tempo.
• Adapte-se a novos contextos sem reconfiguração manual.
• Tome decisões mais informadas baseadas em dados históricos.
• Evolua suas habilidades de forma autônoma, reduzindo a necessidade de intervenção humana.

Plataformas Suportadas

• Claude Code: Integração direta com agentes Claude, permitindo que eles utilizem a memória episódica para melhorar suas respostas e ações.
• Cursor: Pode ser integrado ao Cursor para desenvolvimento assistido por IA com aprendizado contínuo.
• Codex: Compatível com agentes baseados em Codex para automação de tarefas de software com evolução de habilidades.

Como Funciona

1. Rastreamento de Execução

Quando o agente executa uma ação, a skill registra um episódio com:

• task_id: Identificador único da tarefa.
• action: Descrição da ação executada.
• context: Contexto em que a ação foi tomada.
• timestamp: Momento da execução.

// Exemplo de registro de episódio
let episode = Episode {
    task_id: "task_123",
    action: "search_file",
    context: "Procurando por arquivos de configuração",
    timestamp: SystemTime::now(),
};
memory.store_episode(episode).await?;

2. Pontuação de Recompensa

Após a execução, o sistema atribui uma recompensa com base no resultado:

• Positiva: Se a ação contribuiu para o sucesso da tarefa.
• Negativa: Se a ação foi ineficaz ou causou erros.
• Neutra: Se o resultado foi incerto.

memory.score_reward(task_id, Reward::Positive(10)).await?;

3. Reflexão

Periodicamente, o sistema reflete sobre episódios passados para identificar padrões:

• Quais ações levam a recompensas altas?
• Em quais contextos o agente teve mais sucesso?
• Existem padrões de falha recorrentes?

let patterns = memory.reflect().await?;
for pattern in patterns {
    println!("Padrão encontrado: {:?}", pattern);
}

4. Evolução de Habilidades

Com base nos padrões identificados, o sistema pode evoluir as habilidades do agente:

• Criar novas habilidades: A partir de sequências de ações bem-sucedidas.
• Ajustar existentes: Modificar parâmetros de habilidades para melhorar desempenho.
• Remover obsoletas: Eliminar habilidades que nunca são recompensadas.

Requisitos

• Rust: Versão 1.70 ou superior.
• Turso: Conta e banco de dados configurado para armazenamento SQL.
• redb: Versão 1.0 ou superior.
• Dependências adicionais: Veja Cargo.toml no repositório.

Configuração

1. Clone o repositório:

git clone https://github.com/d-o-hub/rust-self-learning-memory.git
cd rust-self-learning-memory

2. Configure as variáveis de ambiente:

TURSO_DATABASE_URL="libsql://seu-banco.turso.io"
TURSO_AUTH_TOKEN="seu-token"
REDB_PATH="./data/memory.db"

3. Instale as dependências:

cargo build --release

Uso

use rust_self_learning_memory::MemorySystem;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let memory = MemorySystem::new().await?;
    
    // Simular execução
    memory.track_execution("task_001", "analyze_logs", "Sistema de logs").await?;
    memory.score_reward("task_001", Reward::Positive(8)).await?;
    
    // Refletir e evoluir
    let patterns = memory.reflect().await?;
    memory.evolve_skills(&patterns).await?;
    
    Ok(())
}

Contribuição

Contribuições são bem-vindas! Por favor, veja o arquivo CONTRIBUTING.md para detalhes.

Licença

Este projeto está licenciado sob a licença MIT - veja o arquivo LICENSE para detalhes.