Speicherwerkzeuge

Speicherwerkzeuge ermöglichen es Agenten, während des Schlussfolgerns autonom in ihrem eigenen Langzeitgedächtnis zu suchen. Statt sich ausschließlich auf externe Orchestrierung zu verlassen, entscheidet der Agent, wann und wie der Speicher abgefragt wird.

Übersicht

ADK-Rust stellt zwei Speicherwerkzeuge hinter dem Feature-Flag memory-tools bereit:

Schnellstart

use adk_tool::memory::{LoadMemoryTool, PreloadMemoryTool};
use adk_memory::InMemoryMemoryService;
use std::sync::Arc;

let memory_service = Arc::new(InMemoryMemoryService::new());

// LoadMemoryTool — agent calls during reasoning
let load_tool = LoadMemoryTool::builder()
    .memory_service(memory_service.clone())
    .max_results(5)
    .min_relevance_score(0.3)
    .build()?;

// PreloadMemoryTool — auto-injects at turn start
let preload_tool = PreloadMemoryTool::builder()
    .memory_service(memory_service.clone())
    .max_results(3)
    .build()?;

// Use LoadMemoryTool as a regular tool
let agent = LlmAgentBuilder::new("assistant")
    .model(model)
    .tool(Arc::new(load_tool))
    .before_model_callback(preload_tool.into_before_model_callback())
    .build()?;

Installation

[dependencies]
adk-tool = { version = "2.1.0", features = ["memory-tools"] }
adk-memory = "2.1.0"

LoadMemoryTool

Der Agent ruft dieses Tool während des Reasonings auf, um mit einer Abfrage im Speicher zu suchen:

{
  "name": "load_memory",
  "parameters": {
    "type": "object",
    "properties": {
      "query": { "type": "string", "description": "Search query" },
      "limit": { "type": "integer", "minimum": 1, "maximum": 100 }
    },
    "required": ["query"]
  }
}

Das Tool gibt strukturierte JSON zurück:

{
  "memories": [
    {
      "content": "The user prefers dark mode",
      "author": "assistant",
      "timestamp": "2026-05-15T10:30:00Z"
    }
  ],
  "count": 1
}

PreloadMemoryTool

Kann auf zwei Arten verwendet werden:

Als reguläres Tool

Der Agent ruft es explizit auf (optionaler Parameter query – andernfalls wird die letzte Eingabe des Benutzers verwendet).

Als BeforeModelCallback

Fügt vor jedem Modellaufruf automatisch relevante Erinnerungen in die Systemanweisung ein:

let preload = PreloadMemoryTool::builder()
    .memory_service(service)
    .max_results(3)
    .build()?;

let agent = LlmAgentBuilder::new("assistant")
    .model(model)
    .before_model_callback(preload.into_before_model_callback())
    .build()?;

Konfiguration

Beide Tools verwenden gemeinsam MemoryToolConfig:

Projektspezifischer Speicher

Wenn project_id konfiguriert ist, werden Suchvorgänge innerhalb des Speichers des Benutzers auf dieses Projekt beschränkt:

let tool = LoadMemoryTool::builder()
    .memory_service(service)
    .project_id("my-project")
    .build()?;

Funktioniert mit jedem Backend

Speicherwerkzeuge delegieren an das Trait MemoryService. Jedes Backend funktioniert:

• InMemoryMemoryService — Entwicklung und Tests
• PostgresMemoryService — Produktion mit pgvector
• Benutzerdefinierte Implementierungen

---

Zurück: ← Schemanormalisierung | Weiter: Sitzungen →