मेमोरी

adk-memory का उपयोग करके AI agents के लिए दीर्घकालिक सिमेंटिक मेमोरी।

अवलोकन

मेमोरी सिस्टम एजेंट वार्तालापों के लिए स्थायी, खोजने योग्य भंडारण प्रदान करता है। सत्र स्थिति (जो क्षणिक है) के विपरीत, मेमोरी सत्रों में बनी रहती है और agents को पिछली बातचीत से प्रासंगिक संदर्भ याद रखने में सक्षम बनाती है।

इंस्टॉलेशन

[dependencies]
adk-memory = "0.2.0"

मुख्य अवधारणाएँ

MemoryEntry

सामग्री, लेखक और टाइमस्टैम्प के साथ एक एकल मेमोरी रिकॉर्ड:

use adk_memory::MemoryEntry;
use adk_core::Content;
use chrono::Utc;

let entry = MemoryEntry {
    content: Content::new("user").with_text("I prefer dark mode"),
    author: "user".to_string(),
    timestamp: Utc::now(),
};

MemoryService Trait

मेमोरी बैकएंड के लिए मुख्य trait:

#[async_trait]
pub trait MemoryService: Send + Sync {
    /// Store session memories for a user
    async fn add_session(
        &self,
        app_name: &str,
        user_id: &str,
        session_id: &str,
        entries: Vec<MemoryEntry>,
    ) -> Result<()>;

    /// Search memories by query
    async fn search(&self, req: SearchRequest) -> Result<SearchResponse>;
}

SearchRequest

मेमोरी सर्च के लिए query पैरामीटर:

use adk_memory::SearchRequest;

let request = SearchRequest {
    query: "user preferences".to_string(),
    user_id: "user-123".to_string(),
    app_name: "my_app".to_string(),
};

InMemoryMemoryService

विकास और परीक्षण के लिए सरल इन-मेमोरी कार्यान्वयन:

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

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let memory = InMemoryMemoryService::new();

    // Store memories from a session
    let entries = vec![
        MemoryEntry {
            content: Content::new("user").with_text("I like Rust programming"),
            author: "user".to_string(),
            timestamp: Utc::now(),
        },
        MemoryEntry {
            content: Content::new("assistant").with_text("Rust is great for systems programming"),
            author: "assistant".to_string(),
            timestamp: Utc::now(),
        },
    ];

    memory.add_session("my_app", "user-123", "session-1", entries).await?;

    // Search memories
    let request = SearchRequest {
        query: "Rust".to_string(),
        user_id: "user-123".to_string(),
        app_name: "my_app".to_string(),
    };

    let response = memory.search(request).await?;
    println!("Found {} memories", response.memories.len());

    Ok(())
}

मेमोरी आइसोलेशन

मेमोरीज़ को इसके द्वारा आइसोलेट किया जाता है:

• app_name: विभिन्न applications में अलग-अलग मेमोरी स्पेस होते हैं
• user_id: प्रत्येक user की मेमोरी निजी होती है

// User A's memories
memory.add_session("app", "user-a", "sess-1", entries_a).await?;

// User B's memories (separate)
memory.add_session("app", "user-b", "sess-1", entries_b).await?;

// Search only returns user-a's memories
let request = SearchRequest {
    query: "topic".to_string(),
    user_id: "user-a".to_string(),
    app_name: "app".to_string(),
};

सर्च व्यवहार

InMemoryMemoryService शब्द-आधारित मिलान का उपयोग करता है:

1. query को शब्दों में tokenize किया जाता है (lowercase)
2. प्रत्येक मेमोरी की content को tokenize किया जाता है
3. किसी भी मिलान वाले शब्द वाली मेमोरीज़ लौटाई जाती हैं

// Query: "rust programming"
// Matches memories containing "rust" OR "programming"

कस्टम मेमोरी बैकएंड

कस्टम स्टोरेज (उदाहरण के लिए, वेक्टर डेटाबेस) के लिए MemoryService लागू करें:

use adk_memory::{MemoryService, MemoryEntry, SearchRequest, SearchResponse};
use adk_core::Result;
use async_trait::async_trait;

pub struct VectorMemoryService {
    // Your vector DB client
}

#[async_trait]
impl MemoryService for VectorMemoryService {
    async fn add_session(
        &self,
        app_name: &str,
        user_id: &str,
        session_id: &str,
        entries: Vec<MemoryEntry>,
    ) -> Result<()> {
        // 1. Generate embeddings for each entry
        // 2. Store in vector database with metadata
        Ok(())
    }

    async fn search(&self, req: SearchRequest) -> Result<SearchResponse> {
        // 1. Generate embedding for query
        // 2. Perform similarity search
        // 3. Return top-k results
        Ok(SearchResponse { memories: vec![] })
    }
}

एजेंट्स के साथ एकीकरण

LlmAgentBuilder के साथ मेमोरी एकीकृत होती है:

use adk_agent::LlmAgentBuilder;
use adk_memory::InMemoryMemoryService;
use std::sync::Arc;

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

let agent = LlmAgentBuilder::new("assistant")
    .model(model)
    .instruction("You are a helpful assistant with memory.")
    .memory(memory)
    .build()?;

जब मेमोरी कॉन्फ़िगर की जाती है:

1. प्रत्येक टर्न से पहले, प्रासंगिक मेमोरीज खोजी जाती हैं
2. मेल खाने वाली मेमोरीज को संदर्भ में इंजेक्ट किया जाता है
3. प्रत्येक सेशन के बाद, बातचीत को मेमोरीज के रूप में संग्रहीत किया जाता है

वास्तुकला

┌─────────────────────────────────────────────────────────────┐
│                      Agent Request                          │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                    Memory Search                            │
│                                                             │
│   SearchRequest { query, user_id, app_name }               │
│                         │                                   │
│                         ▼                                   │
│   ┌─────────────────────────────────────────────────────┐  │
│   │              MemoryService                          │  │
│   │  ┌─────────────┐  ┌─────────────┐  ┌────────────┐  │  │
│   │  │ InMemory    │  │ Vector DB   │  │ Custom     │  │  │
│   │  │ (dev/test)  │  │ (Qdrant)    │  │ Backend    │  │  │
│   │  └─────────────┘  └─────────────┘  └────────────┘  │  │
│   └─────────────────────────────────────────────────────┘  │
│                         │                                   │
│                         ▼                                   │
│   SearchResponse { memories: Vec<MemoryEntry> }            │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│              Context Injection                              │
│                                                             │
│   Relevant memories added to agent context                 │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                    Agent Execution                          │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                   Memory Storage                            │
│                                                             │
│   Session conversation stored for future recall            │
└─────────────────────────────────────────────────────────────┘

सर्वोत्तम अभ्यास

सत्रों के साथ तुलना

---

पिछला: ← गार्डरेल्स | अगला: स्टूडियो →