Memoria

Dota a tus agentes de una memoria que sobreviva a una sola conversación. El estado de la sesión mantiene esta conversación; la memoria es el almacenamiento a largo plazo que un agente lee al inicio de un turno y al que escribe a medida que aprende, de modo que la siguiente sesión ya conozca al usuario.

Esta sección te guía desde cero: los dos tipos de memoria que ofrece ADK-Rust, los tipos principales, los backends, el grafo de conocimiento bi-temporal y cómo integrarlo todo en un agente.

¿Es tu primera vez con ADK-Rust? Lee primero la Introducción y Sesiones y estado: la memoria es la contraparte persistente de la sesión efímera.

Dos tipos de memoria

ADK-Rust incluye dos modelos de memoria complementarios detrás del mismo trait MemoryService, para que un agente pueda usar cualquiera de ellos mediante una única interfaz:

No tienes que elegir de forma global: selecciona por agente según necesites una recuperación al estilo de una transcripción o un modelo del usuario limpio y consultable.

El 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)

• Un MemoryService es el backend de almacenamiento: almacena entradas (o nodos del grafo) y responde a search.
• Un MemoryServiceAdapter lo envuelve como un adk_core::Memory, delimitado a un (app_name, user_id, project_id?), que es lo que realmente invoca el search_memory de un agente.
• El Runner contiene el Memory y lo expone al agente; las herramientas de memoria permiten al agente buscar y seleccionar memoria deliberadamente.

Instalación

# 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"] }

Inicio rápido en 60 segundos

Almacena un par de recuerdos y búscalos de nuevo:

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(()) }

En un agente real, no llamas a search manualmente; conectas el servicio al Runner y dejas que el agente recuerde y organice la memoria por sí mismo.

Qué hacer a continuación

1. Conceptos — MemoryEntry, el trait MemoryService, búsqueda, delimitación por proyecto y eliminación conforme al RGPD.
2. Backends — los seis almacenes, las marcas de funcionalidades y cómo elegir.
3. Grafo de conocimiento — GraphMemoryService y por qué es importante la temporalidad bitemporal.
4. Herramientas y agentes — integración de la memoria en los agentes; remember/relate y las herramientas de memoria.