नॉलेज ग्राफ़

GraphMemoryService मेमोरी का एक अलग आकार है: टेक्स्ट प्रविष्टियों के ढेर के बजाय, यह उपयोगकर्ता का एक नॉलेज ग्राफ़ संग्रहीत करता है — संस्थाएँ, उनसे जुड़े तथ्य ("अवलोकन"), और उनके बीच टाइप किए गए संबंध — और यह इन सभी को द्वि-कालिक रूप से ट्रैक करता है। यह Mindfulness-with-Mia उदाहरण और रीयलटाइम मेमोरी पेज के पीछे का बैकएंड है।

यह अन्य बैकएंड के समान MemoryService ट्रेट को लागू करता है, इसलिए यह उसी तरह एक एजेंट में फिट हो जाता है — लेकिन यह शीर्ष पर एक समृद्ध ग्राफ़ API को उजागर करता है।

डेटा मॉडल

   Entity "Alice"  (type: person)
     ├─ observation: "prefers email over phone"   valid_from 2026-06-01
     ├─ observation: "timezone is CET"            valid_from 2026-06-10
     └─ relation:    Alice ──works_at──▶ "Acme"

• Entity — एक नामित चीज़ (एक व्यक्ति, स्थान, वरीयता, विषय) जिसमें एक मुक्त-रूप entity_type होता है।
• Observation — एक इकाई से जुड़ा एक तथ्य, जिसमें एक स्थिर id और एक valid_from टाइमस्टैम्प होता है।
• Relation — दो संस्थाओं (source ──relation_type──▶ target) के बीच एक टाइप किया गया किनारा, उदा. Alice ──works_at──▶ Acme।

एक एपिसोडिक स्टोर (kg_episodic) भी है जो क्यूरेटेड ग्राफ़ से अलग, कच्चे टर्न को लॉग करता है — ताकि आप प्रतिलेख और डिस्टिल्ड मॉडल दोनों को रख सकें।

द्वि-कालिक क्यों

प्रत्येक अवलोकन और संबंध को दो समय अक्षों के साथ ट्रैक किया जाता है:

• वैध समय — जब तथ्य दुनिया में सत्य था (valid_from → valid_to)।
• अंतर्ग्रहण समय — जब सिस्टम ने इसे सीखा।

जब कोई तथ्य बदलता है, तो पुराना वाला हटाया नहीं जाता है — इसे अमान्य किया जाता है (इसका valid_to सेट किया जाता है) और नया वाला जोड़ा जाता है। इसका मतलब है कि ग्राफ़ यह जवाब दे सकता है कि "उपयोगकर्ता की वर्तमान वरीयता क्या है?" बिना यह खोए कि "यह पहले क्या थी।" अधिग्रहित तथ्य वर्तमान को अधिलेखित करने के बजाय इतिहास में रहते हैं — जो कि महीनों तक आप जिस मेमोरी पर भरोसा करेंगे, उसके लिए बिल्कुल वही है जो आप चाहते हैं।

kg.invalidate_observation(old_id).await?;   // mark a fact no longer valid
kg.invalidate_relation(old_id).await?;      // mark an edge no longer valid

एक बनाना

graph-memory SQLite-समर्थित है, इसलिए यह एक फ़ाइल है (या परीक्षणों के लिए इन-मेमोरी):

use adk_memory::GraphMemoryService;
use std::sync::Arc;

let kg = GraphMemoryService::new("sqlite://mia-memory.db").await?;
kg.migrate().await?;                         // idempotent schema setup
let kg = Arc::new(kg);

ग्राफ़ में लिखना

use adk_memory::{CreateEntityInput, CreateRelationInput};

kg.create_entities("coach", "alice", vec![CreateEntityInput {
    name: "Alice".into(),
    entity_type: "person".into(),
    observations: vec!["prefers morning sessions".into(), "goal: run a 10k".into()],
}]).await?;

kg.create_relations("coach", "alice", vec![CreateRelationInput {
    source: "Alice".into(), relation_type: "training_for".into(), target: "10k race".into(),
}]).await?;

// add facts to an existing entity later
kg.add_observations("coach", "alice", /* entity */ "Alice", vec!["timezone is CET".into()]).await?;

एक इकाई बनाना अप्सर्ट है — एक ज्ञात इकाई को फिर से बनाने से उसकी प्रकार और टाइमस्टैम्प अपडेट होता है बजाय इसके कि उसे डुप्लिकेट किया जाए।

इसे वापस पढ़ना

ट्रेट के search के शीर्ष पर तीन रिकॉल आकार:

// 1. Token-scored relevance search → entities + their relations + a score
let hits = kg.search_nodes("coach", "alice", "what is she training for?", 5).await?;

// 2. Fetch specific entities by name
let nodes = kg.open_nodes("coach", "alice", &["Alice".into()]).await?;

// 3. The whole graph (small graphs / debugging)
let graph = kg.read_graph("coach", "alice").await?;

प्रोफ़ाइल कार्ड

एजेंटों के लिए किलर फ़ीचर: profile_card उपयोगकर्ता कौन है इसका एक कॉम्पैक्ट, वर्तमान सारांश प्रस्तुत करता है — सबसे हाल ही में अपडेट की गई संस्थाएँ और उनके वैध अवलोकन — सत्र की शुरुआत में एक सिस्टम प्रॉम्प्ट में इंजेक्ट करने के लिए तैयार।

let card = kg.profile_card("coach", "alice").await?;
// → a short text block: "Alice (person): prefers morning sessions; goal: run a 10k…"

इसके आकार को एक बजट के साथ सीमित करें ताकि ग्राफ़ बढ़ने पर प्रॉम्प्ट छोटा रहे:

let kg = GraphMemoryService::new(url).await?
    .with_profile_budget(/* entities */ 12, /* observations per entity */ 5);

एजेंट को इसे क्यूरेट करने देना

आप उत्पादन में create_entities को शायद ही कभी हाथ से कॉल करते हैं — आप एजेंट को ग्राफ़ में लिखने के लिए उपकरण देते हैं जैसे वह सीखता है। remember और relate के लिए Tools & agents देखें, जो सीधे उपरोक्त कॉलों पर मैप करते हैं और adk-tool में शिप होते हैं।

अगला: Tools & agents →