स्मृति

अपने agents को ऐसी स्मृति दें जो एकल वार्तालाप से परे बनी रहे। Session state इस वार्तालाप को संभालती है; स्मृति वह दीर्घकालिक संग्रह है जिसे agent किसी turn की शुरुआत में पढ़ता है और सीखने के साथ उसमें वापस लिखता है — ताकि अगला session उपयोगकर्ता को पहले से जानता हो।

यह अनुभाग आपको इसे शुरुआत से समझाता है: ADK-Rust द्वारा दी जाने वाली स्मृति के दो प्रकार, मुख्य प्रकार, backends, द्वि-कालिक knowledge graph, और इन सभी को agent में जोड़ने का तरीका।

ADK-Rust में नए हैं? पहले परिचय और Sessions और State पढ़ें — memory, ephemeral session का persistent समकक्ष है।

स्मृति के दो प्रकार

ADK-Rust एक ही MemoryService trait के पीछे दो परस्पर पूरक memory models उपलब्ध कराता है, ताकि कोई agent एक ही interface के माध्यम से इनमें से किसी का उपयोग कर सके:

आपको वैश्विक रूप से चयन करने की आवश्यकता नहीं है — प्रत्येक agent के लिए इस आधार पर चुनें कि आपको ट्रांसक्रिप्ट-शैली की पुनर्प्राप्ति चाहिए या उपयोगकर्ता के एक स्वच्छ, क्वेरी योग्य मॉडल की।

मानसिक मॉडल

  Agent turn
     │  search_memory(query)         ← recall relevant context at turn start
     ▼
  adk_core::Memory                   ← the interface the agent sees
     │  (MemoryServiceAdapter bridges to…)
     ▼
  MemoryService                      ← add_session / search / delete_user …
     ├─ InMemoryMemoryService        (dev)
     ├─ Sqlite/Postgres/Redis/…      (semantic store)
     └─ GraphMemoryService           (bi-temporal knowledge graph)

• एक MemoryService स्टोरेज बैकएंड है: यह प्रविष्टियाँ (या ग्राफ़ नोड) संग्रहीत करता है और search का उत्तर देता है।
• एक MemoryServiceAdapter इसे एक adk_core::Memory के रूप में रैप करता है, जो एक (app_name, user_id, project_id?) के दायरे में होता है और जिसे agent का search_memory वास्तव में कॉल करता है।
• Runner Memory को रखता है और उसे agent के लिए उपलब्ध कराता है; memory tools agent को जानबूझकर memory खोजने और व्यवस्थित करने देते हैं।

इंस्टॉल करें

# Semantic store — pick the backend you need
adk-memory = { version = "2.1.0", features = ["sqlite-memory"] }

# Bi-temporal knowledge graph
adk-memory = { version = "2.1.0", features = ["graph-memory"] }

60-सेकंड की त्वरित शुरुआत

कुछ स्मृतियाँ संग्रहीत करें और उन्हें फिर से खोजें:

use adk_memory::{InMemoryMemoryService, MemoryService, MemoryEntry, SearchRequest};
use adk_core::Content;
use chrono::Utc;

# async fn run() -> anyhow::Result<()> {
let memory = InMemoryMemoryService::new();

memory.add_session("support", "alice", "s1", vec![
    MemoryEntry { content: Content::new("user").with_text("I prefer email over phone"),
                  author: "user".into(), timestamp: Utc::now() },
]).await?;

let hits = memory.search(SearchRequest {
    app_name: "support".into(), user_id: "alice".into(),
    query: "how should we contact this customer?".into(),
    ..Default::default()
}).await?;

for entry in hits.entries { println!("{:?}", entry.content); }
# Ok(()) }

वास्तविक एजेंट में आप search को हाथ से कॉल नहीं करते — आप सेवा को Runner से जोड़ते हैं और एजेंट को स्वयं स्मृति याद करने तथा व्यवस्थित करने देते हैं।

आगे कहाँ जाएँ

1. अवधारणाएँ — MemoryEntry, MemoryService ट्रेट, खोज, प्रोजेक्ट का दायरा, GDPR के अंतर्गत विलोपन।
2. बैकएंड — छह स्टोर, फीचर फ़्लैग और चुनाव करने का तरीका।
3. ज्ञान ग्राफ़ — GraphMemoryService और द्वि-कालिकता क्यों महत्वपूर्ण है।
4. टूल और एजेंट — एजेंट में मेमोरी को जोड़ना; remember/relate और मेमोरी टूल।