Memória

Dê aos seus agentes uma memória que sobrevive a uma única conversa. O estado da sessão mantém esta conversa; a memória é o armazenamento de longo prazo que um agente lê no início de um turno e atualiza à medida que aprende — assim, a próxima sessão já conhece o usuário.

Esta seção apresenta tudo desde o início: os dois tipos de memória que ADK-Rust oferece, os tipos principais, os backends, o grafo de conhecimento bitemporal e como integrar tudo isso a um agente.

Novo no ADK-Rust? Leia primeiro a Introdução e Sessões e estado — a memória é a contraparte persistente da sessão efêmera.

Dois tipos de memória

ADK-Rust fornece dois modelos de memória complementares por trás da mesma trait MemoryService, para que um agente possa usar qualquer um deles por meio de uma única interface:

Você não precisa escolher globalmente — escolha por agente, dependendo de precisar de uma recuperação no estilo de transcrição ou de um modelo limpo e consultável do usuário.

Modelo mental

  Agent turn
     │  search_memory(query)         ← recall relevant context at turn start
     ▼
  adk_core::Memory                   ← the interface the agent sees
     │  (MemoryServiceAdapter bridges to…)
     ▼
  MemoryService                      ← add_session / search / delete_user …
     ├─ InMemoryMemoryService        (dev)
     ├─ Sqlite/Postgres/Redis/…      (semantic store)
     └─ GraphMemoryService           (bi-temporal knowledge graph)

• Um MemoryService é o back-end de armazenamento: ele armazena entradas (ou nós de grafo) e responde a search.
• Um MemoryServiceAdapter o encapsula como um adk_core::Memory, com escopo definido para um (app_name, user_id, project_id?), que é o que o search_memory de um agente realmente chama.
• O Runner mantém o Memory e o expõe ao agente; as ferramentas de memória permitem que o agente pesquise e organize a memória deliberadamente.

Instalação

# Semantic store — pick the backend you need
adk-memory = { version = "2.1.0", features = ["sqlite-memory"] }

# Bi-temporal knowledge graph
adk-memory = { version = "2.1.0", features = ["graph-memory"] }

Início rápido em 60 segundos

Armazene algumas memórias e pesquise-as novamente:

use adk_memory::{InMemoryMemoryService, MemoryService, MemoryEntry, SearchRequest};
use adk_core::Content;
use chrono::Utc;

# async fn run() -> anyhow::Result<()> {
let memory = InMemoryMemoryService::new();

memory.add_session("support", "alice", "s1", vec![
    MemoryEntry { content: Content::new("user").with_text("I prefer email over phone"),
                  author: "user".into(), timestamp: Utc::now() },
]).await?;

let hits = memory.search(SearchRequest {
    app_name: "support".into(), user_id: "alice".into(),
    query: "how should we contact this customer?".into(),
    ..Default::default()
}).await?;

for entry in hits.entries { println!("{:?}", entry.content); }
# Ok(()) }

Em um agente real, você não chama search manualmente — conecta o serviço ao Runner e permite que o agente recupere e organize a memória por conta própria.

O que fazer em seguida

1. Conceitos — MemoryEntry, o trait MemoryService, pesquisa, escopo do projeto e exclusão de dados conforme o GDPR.
2. Backends — os seis armazenamentos, sinalizadores de recursos e como escolher.
3. Grafo de conhecimento — GraphMemoryService e por que a temporalidade dupla é importante.
4. Ferramentas e agentes — conectando a memória aos agentes; remember/relate e as ferramentas de memória.