Mémoire dans les Agents

Stocker la mémoire n'est que la moitié de l'histoire ; l'important est qu'un agent l'utilise — qu'il se souvienne du contexte pertinent avant de répondre, et qu'il enregistre des faits durables au fur et à mesure qu'il apprend. Il existe deux mécanismes coopératifs :

1. Attacher un service pour que l'agent puisse se souvenir.
2. Donner des outils à l'agent pour qu'il puisse rechercher et organiser délibérément.

1. Attacher la mémoire à un agent

Un MemoryService est relié à l'interface adk_core::Memory qu'un agent utilise via MemoryServiceAdapter, délimité à un (app, user, project?). Attachez-le au Runner et le search_memory de l'agent transite vers votre 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()?;

Avec cela en place, l'agent peut appeler search_memory(query) pendant un tour — mais quand il le fait dépend de la façon dont vous configurez le rappel. C'est à cela que servent les outils.

2. Outils de mémoire (stockage sémantique)

adk-tool (fonctionnalité memory-tools) fournit deux outils qui transforment le rappel en comportement d'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()?;

Utilisez preload pour "toujours se souvenir des bases", load pour "rechercher quand c'est pertinent". Voir la référence complète : Outils de mémoire.

Outils de graphe de connaissances

Lorsque le backend est un GraphMemoryService, adk-tool (fonctionnalité graph-memory-tools) donne à l'agent deux outils pour organiser le graphe lui-même — afin qu'il se souvienne délibérément au lieu de vider des transcriptions :

Leurs descriptions guident le modèle vers des faits stables et réutilisables (noms, préférences, objectifs, relations) et l'éloignent des bavardages. Enregistrez-les individuellement ou comme un ensemble d'outils :

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

Associez cela avec le profile_card du graphe injecté au démarrage de la session, et vous obtenez un agent qui lit qui est l'utilisateur dès le départ et écrit ce qu'il apprend en retour — la boucle qui rend la mémoire réelle.

Dans les sessions en temps réel

Le même câblage fonctionne pour les agents vocaux/multimodaux via IntegratedRealtimeRunner — remember/relate sont automatiquement pontés dans une session en temps réel, et un MemoryService injecte du contexte à la connexion et stocke les tours. Voir Temps réel → Mémoire.

Un modèle complet

L'exemple realtime_voice (Pleine conscience avec Mia) est la référence de bout en bout : un GraphMemoryService basé sur un fichier est la mémoire à long terme de Mia ; sa carte de profil est injectée au début de la session ; elle organise les faits en milieu de conversation via remember/relate ; et un panneau en direct lit et écrit le même graphe. Lisez-le pour voir chaque élément de cette page fonctionner ensemble.

← Retour à la vue d'ensemble de la mémoire