एजेंट्स में मेमोरी

मेमोरी को स्टोर करना आधी कहानी है; मुख्य बात यह है कि एक agent इसका उपयोग करता है — जवाब देने से पहले प्रासंगिक संदर्भ को याद करता है, और सीखने के साथ ही स्थायी तथ्यों को वापस लिखता है। दो सहयोगी तंत्र हैं:

1. एक सेवा संलग्न करें ताकि agent याद कर सके।
2. agent को tools दें ताकि वह जानबूझकर खोज और क्यूरेट कर सके।

1. एक agent से मेमोरी संलग्न करना

एक MemoryService को adk_core::Memory इंटरफ़ेस से जोड़ा जाता है जिसका एक agent MemoryServiceAdapter के माध्यम से उपयोग करता है, जो एक (app, user, project?) तक सीमित है। इसे Runner से संलग्न करें और agent का search_memory आपके बैकएंड तक प्रवाहित होता है:

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

इसके साथ, agent एक बारी के दौरान search_memory(query) को कॉल कर सकता है — लेकिन कब करता है यह इस बात पर निर्भर करता है कि आप रिकॉल को कैसे वायर करते हैं। tools इसी के लिए हैं।

2. मेमोरी tools (सिमेंटिक स्टोर)

adk-tool (feature memory-tools) दो tools प्रदान करता है जो रिकॉल को 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()?;

बुनियादी बातों को हमेशा याद रखने के लिए preload का उपयोग करें, प्रासंगिक होने पर देखने के लिए load का उपयोग करें। पूर्ण संदर्भ देखें: Memory Tools।

ज्ञान-ग्राफ उपकरण

जब बैकएंड एक GraphMemoryService होता है, तो adk-tool (feature graph-memory-tools) Agent को ग्राफ को स्वयं क्यूरेट करने के लिए दो उपकरण देता है — ताकि वह ट्रांसक्रिप्ट्स को डंप करने के बजाय जानबूझकर याद रखे:

उनके विवरण मॉडल को स्थिर, पुन: प्रयोज्य तथ्यों (नाम, प्राथमिकताएं, लक्ष्य, संबंध) की ओर निर्देशित करते हैं और छोटी-मोटी बातों से दूर रखते हैं। उन्हें व्यक्तिगत रूप से या एक टूलसेट के रूप में पंजीकृत करें:

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

इसे ग्राफ़ के profile_card के साथ जोड़ें जो सत्र की शुरुआत में इंजेक्ट किया जाता है, और आपको एक ऐसा एजेंट मिलता है जो उपयोगकर्ता कौन है, इसे पहले से पढ़ता है और जो सीखता है उसे वापस लिखता है — वह लूप जो स्मृति को वास्तविक महसूस कराता है।

रीयलटाइम सत्रों में

वही वायरिंग वॉयस/मल्टीमॉडल एजेंटों के लिए IntegratedRealtimeRunner के माध्यम से काम करती है — remember/relate स्वचालित रूप से एक रीयलटाइम सत्र में ब्रिज किए जाते हैं, और एक MemoryService कनेक्ट होने पर संदर्भ इंजेक्ट करता है और टर्न संग्रहीत करता है। देखें Realtime → Memory।

एक पूर्ण पैटर्न

realtime_voice (मिया के साथ माइंडफुलनेस) उदाहरण एंड-टू-एंड संदर्भ है: एक फ़ाइल-समर्थित GraphMemoryService मिया की दीर्घकालिक स्मृति है; उसका प्रोफ़ाइल कार्ड सत्र की शुरुआत में इंजेक्ट किया जाता है; वह remember/relate के माध्यम से बातचीत के बीच में तथ्यों को क्यूरेट करती है; और एक लाइव पैनल उसी ग्राफ़ को पढ़ता और लिखता है। इस पृष्ठ पर हर टुकड़े को एक साथ काम करते देखने के लिए इसे पढ़ें।

← वापस Memory अवलोकन पर