Memória em Agentes

Armazenar memória é apenas parte da história; o ponto é que um agent a utiliza — relembra o contexto relevante antes de responder e registra fatos duradouros à medida que aprende. Existem dois mecanismos cooperativos:

1. Anexar um serviço para que o agent possa relembrar.
2. Fornecer ferramentas ao agent para que ele possa pesquisar e curar deliberadamente.

1. Anexando memória a um agent

Um MemoryService é conectado à interface adk_core::Memory que um agent usa via MemoryServiceAdapter, com escopo para um (app, user, project?). Anexe-o ao Runner e o search_memory do agent fluirá para o seu backend:

use adk_memory::{InMemoryMemoryService, MemoryServiceAdapter};
use std::sync::Arc;

let service = Arc::new(InMemoryMemoryService::new());
let memory: Arc<dyn adk_core::Memory> =
    Arc::new(MemoryServiceAdapter::new(service.clone(), "support", "alice"));

let runner = Runner::builder()
    .agent(agent)
    .session_service(sessions)
    .memory_service(memory)        // ← the agent can now recall
    .build()?;

Com isso em vigor, o agent pode chamar search_memory(query) durante um turno — mas quando ele o faz depende de como você configura a recuperação. É para isso que servem as ferramentas.

2. Ferramentas de memória (armazenamento semântico)

adk-tool (recurso memory-tools) fornece duas ferramentas que transformam a recuperação em comportamento do agent:

use adk_tool::memory::{LoadMemoryTool, PreloadMemoryTool};

let load = LoadMemoryTool::builder()
    .memory_service(service.clone())
    .max_results(5)
    .min_relevance_score(0.3)
    .build()?;

let preload = PreloadMemoryTool::builder()
    .memory_service(service.clone())
    .max_results(3)
    .build()?;

let agent = LlmAgentBuilder::new("assistant")
    .model(model)
    .tool(Arc::new(load))                                        // on-demand recall
    .before_model_callback(preload.into_before_model_callback()) // automatic recall
    .build()?;

Use preload para "sempre lembrar o básico," load para "consultar quando relevante." Veja a referência completa: Ferramentas de Memória.

Ferramentas de grafo de conhecimento

Quando o backend é um GraphMemoryService, adk-tool (recurso graph-memory-tools) dá ao agent duas ferramentas para gerenciar o grafo em si — para que ele se lembre deliberadamente em vez de despejar transcrições:

Suas descrições guiam o modelo para fatos estáveis e reutilizáveis (nomes, preferências, objetivos, relacionamentos) e longe de conversas triviais. Registre-os individualmente ou como um conjunto de ferramentas:

use adk_tool::memory::{RememberTool, RelateTool, GraphMemoryToolset};
use std::sync::Arc;

let kg = Arc::new(GraphMemoryService::new("sqlite://mem.db").await?);
kg.migrate().await?;

// individually…
let agent = LlmAgentBuilder::new("coach")
    .model(model)
    .tool(Arc::new(RememberTool::new(kg.clone())))
    .tool(Arc::new(RelateTool::new(kg.clone())))
    .build()?;

// …or as one toolset
let toolset = GraphMemoryToolset::new(kg.clone());

Combine isso com o profile_card do grafo injetado no início da sessão, e você obtém um agent que lê quem é o usuário de antemão e escreve o que aprende de volta — o loop que faz a memória parecer real.

Em sessões em tempo real

A mesma configuração funciona para agents de voz/multimodais através de IntegratedRealtimeRunner — remember/relate são automaticamente conectados a uma sessão em tempo real, e um MemoryService injeta contexto na conexão e armazena as interações. Veja Realtime → Memory.

Um padrão completo

O realtime_voice (Mindfulness com Mia) exemplo é a referência completa: um GraphMemoryService baseado em arquivo é a memória de longo prazo da Mia; o cartão de perfil dela é injetado no início da sessão; ela organiza fatos no meio da conversa via remember/relate; e um painel ao vivo lê e escreve o mesmo grafo. Leia-o para ver todas as partes desta página funcionando juntas.

← Voltar para a Visão geral da memória