Memoria en Agentes

Almacenar memoria es solo la mitad de la historia; el punto es que un agent la usa — recuerda el contexto relevante antes de responder, y escribe hechos duraderos a medida que aprende. Hay dos mecanismos que cooperan:

1. Adjuntar un servicio para que el agent pueda recordar.
2. Dar al agent herramientas para que pueda buscar y organizar deliberadamente.

1. Adjuntar memoria a un agent

Un MemoryService se conecta a la interfaz adk_core::Memory que un agent usa a través de MemoryServiceAdapter, con ámbito a un (app, user, project?). Adjúntalo al Runner y el search_memory del agent fluirá a tu 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()?;

Con esto en su lugar, el agent puede llamar a search_memory(query) durante un turno — pero cuándo lo hace depende de cómo configures la recuperación. Para eso son las herramientas.

2. Herramientas de memoria (almacén semántico)

adk-tool (característica memory-tools) incluye dos herramientas que convierten la recuperación en comportamiento del 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()?;

Usa preload para "recordar siempre lo básico", load para "buscarlo cuando sea relevante". Consulta la referencia completa: Herramientas de Memoria.

Herramientas de grafo de conocimiento

Cuando el backend es un GraphMemoryService, adk-tool (la característica graph-memory-tools) le da al agente dos herramientas para curar el grafo por sí mismo, de modo que recuerde deliberadamente en lugar de volcar transcripciones:

Sus descripciones guían al modelo hacia hechos estables y reutilizables (nombres, preferencias, objetivos, relaciones) y lejos de la charla trivial. Regístrelos individualmente o como un conjunto de herramientas:

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 esto con el profile_card del grafo inyectado al inicio de la sesión, y obtendrá un agente que lee quién es el usuario de antemano y escribe lo que aprende de vuelta — el bucle que hace que la memoria se sienta real.

En sesiones en tiempo real

El mismo cableado funciona para agentes de voz/multimodales a través de IntegratedRealtimeRunner — remember/relate se conectan automáticamente a una sesión en tiempo real, y un MemoryService inyecta contexto al conectar y almacena los turnos. Vea Tiempo real → Memoria.

Un patrón completo

El realtime_voice (Mindfulness con Mia) ejemplo es la referencia completa: un GraphMemoryService respaldado por archivos es la memoria a largo plazo de Mia; su tarjeta de perfil se inyecta al inicio de la sesión; ella selecciona hechos a mitad de la conversación a través de remember/relate; y un panel en vivo lee y escribe el mismo grafo. Léelo para ver cada pieza de esta página funcionando en conjunto.

← Volver a la Descripción general de la memoria