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

सभी बैकएंड समान MemoryService trait को लागू करते हैं, इसलिए आप एक फीचर फ्लैग को सक्षम करके और उसे बनाकर चुनते हैं — आपका Agent कोड नहीं बदलता है। छह हैं।

एक नज़र में

(द्वि-कालिक GraphMemoryService एक सातवाँ है, जिसे इसके अपने पृष्ठ पर कवर किया गया है — Knowledge graph।)

InMemory — यहाँ से शुरू करें

शून्य सेटअप। सब कुछ प्रक्रिया में रहता है और बाहर निकलने पर गायब हो जाता है।

use adk_memory::InMemoryMemoryService;
let memory = InMemoryMemoryService::new();

विकास और परीक्षण सूट के लिए बिल्कुल सही; इसे एक टिकाऊ बैकएंड के लिए एक-लाइन परिवर्तन के साथ बदलें क्योंकि विशेषता समान है।

SQLite — एक फ़ाइल

टिकाऊ, एकल-फ़ाइल, कोई सर्वर नहीं। डेस्कटॉप ऐप्स और एकल-नोड सेवाओं के लिए बढ़िया।

use adk_memory::SqliteMemoryService;
let memory = SqliteMemoryService::new("sqlite://memory.db").await?;
// or build from an existing pool: SqliteMemoryService::from_pool(pool)

Postgres + pgvector — उत्पादन सिमेंटिक खोज

वास्तविक समानता खोज के लिए बैकएंड। यह pgvector में एम्बेडिंग संग्रहीत करता है और आपको इंडेक्स रणनीति चुनने देता है।

use adk_memory::{PostgresMemoryService, VectorIndexType};

let memory = PostgresMemoryService::builder(pool, embedding_provider)
    .vector_index(VectorIndexType::Hnsw { m: 32, ef_construction: 128 })  // or IvfFlat / None
    .build()
    .await?;

VectorIndexType::None सटीक (ब्रूट-फोर्स) खोज करता है — छोटे सेट के लिए ठीक है; Hnsw (डिफ़ॉल्ट) और IvfFlat बड़े सेट के लिए स्केल करते हैं। वेक्टर खोज के लिए एक embedding provider की आवश्यकता होती है।

Redis, MongoDB, Neo4j

इनका उपयोग तब करें जब आप पहले से ही इन्फ्रास्ट्रक्चर चला रहे हों:

use adk_memory::{RedisMemoryService, RedisMemoryConfig};
use std::time::Duration;

let memory = RedisMemoryService::new(RedisMemoryConfig {
    url: "redis://localhost:6379".into(),
    ttl: Some(Duration::from_secs(60 * 60 * 24 * 30)),   // optional expiry
}).await?;

MongoMemoryService::new(...) और Neo4jMemoryService::new(...) एक ही आकार का पालन करते हैं। वे सभी Concepts से (app, user, project) अलगाव का सम्मान करते हैं।

Embeddings

जो बैकएंड वेक्टर समानता (Postgres, वैकल्पिक रूप से Mongo) करते हैं, उन्हें टेक्स्ट को वैक्टर में बदलने की आवश्यकता होती है। एक EmbeddingProvider प्रदान करें:

#[async_trait]
pub trait EmbeddingProvider: Send + Sync {
    async fn embed(&self, texts: &[String]) -> Result<Vec<Vec<f32>>>;
}

कीवर्ड बैकएंड (InMemory, SQLite, Redis) को इसकी आवश्यकता नहीं होती है। उस एम्बेडिंग मॉडल का मिलान करें जिसे आप उस मॉडल के साथ इंडेक्स करते हैं जिससे आप क्वेरी करते हैं।

माइग्रेशन

SQL-समर्थित सेवाएं अपनी स्कीमा बनाने और अपग्रेड करने के लिए संस्करणित, आइडम्पोटेंट माइग्रेशन चलाती हैं, इसलिए एक नया संस्करण तैनात करने के लिए मैन्युअल DDL की आवश्यकता नहीं होती है। स्टार्टअप पर सेवा के migrate() को कॉल करें (या निर्माण को इसे संभालने दें)।

चुनना

• निर्माण / परीक्षण → InMemory।
• एक नोड, इसे स्थायी बनाना चाहते हैं → SQLite।
• बड़े पैमाने पर वास्तविक सिमेंटिक रिकॉल → Postgres + pgvector।
• आप पहले से ही Redis / Mongo / Neo4j चला रहे हैं → वह बैकएंड।
• आप उपयोगकर्ता का एक क्वेरी करने योग्य मॉडल चाहते हैं, न कि एक प्रतिलेख → GraphMemoryService।

अगला: Knowledge graph →