Speicher in Agents

Speicher ist die halbe Miete; der Punkt ist, dass ein Agent ihn nutzt – relevanten Kontext abruft, bevor er antwortet, und dauerhafte Fakten zurückschreibt, während er lernt. Es gibt zwei zusammenwirkende Mechanismen:

1. Einen Dienst anhängen, damit der Agent sich erinnern kann.
2. Dem Agenten Tools geben, damit er gezielt suchen und kuratieren kann.

1. Speicher an einen Agenten anhängen

Ein MemoryService wird über MemoryServiceAdapter, begrenzt auf einen (app, user, project?), mit der adk_core::Memory Schnittstelle verbunden, die ein Agent verwendet. Hängen Sie ihn an den Runner an, und die search_memory des Agenten fließt zu Ihrem 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()?;

Damit kann der Agent search_memory(query) während eines Zuges aufrufen – aber wann er dies tut, hängt davon ab, wie Sie den Abruf verdrahten. Dafür sind die Tools da.

2. Speicher-Tools (semantischer Speicher)

adk-tool (feature memory-tools) liefert zwei Tools, die das Erinnern in Agentenverhalten umwandeln:

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

Verwenden Sie preload für „immer die Grundlagen im Gedächtnis behalten“, load für „bei Relevanz nachschlagen“. Die vollständige Referenz finden Sie unter: Memory Tools.

Wissensgraph-Tools

Wenn das Backend ein GraphMemoryService ist, adk-tool (feature graph-memory-tools) gibt dem Agenten zwei Tools, um den Graphen selbst zu kuratieren — damit er sich bewusst erinnert, anstatt Transkripte abzulegen:

Ihre Beschreibungen leiten das Modell zu stabilen, wiederverwendbaren Fakten (Namen, Präferenzen, Ziele, Beziehungen) und weg von oberflächlichem Geplauder. Registrieren Sie sie einzeln oder als Toolset:

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

Kombinieren Sie dies mit der profile_card des Graphen, die beim Sitzungsstart injiziert wird, und Sie erhalten einen Agenten, der den Benutzer von vornherein liest und das Gelernte zurückschreibt – die Schleife, die die Erinnerung real erscheinen lässt.

In Echtzeit-Sitzungen

Die gleiche Verkabelung funktioniert für Sprach-/multimodale Agenten durch IntegratedRealtimeRunner — remember/relate werden automatisch in eine Echtzeit-Sitzung überbrückt, und ein MemoryService injiziert Kontext beim Verbinden und speichert Konversationen. Siehe Realtime → Memory.

Ein vollständiges Muster

Das realtime_voice (Achtsamkeit mit Mia) Beispiel ist die End-to-End-Referenz: ein dateibasiertes GraphMemoryService ist Mias Langzeitgedächtnis; ihre Profilkarte wird beim Sitzungsstart injiziert; sie kuratiert Fakten mitten im Gespräch über remember/relate; und ein Live-Panel liest und schreibt denselben Graphen. Lesen Sie es, um zu sehen, wie jedes Teil auf dieser Seite zusammenarbeitet.

← Zurück zur Speicherübersicht