Struct SqliteStore 

pub struct SqliteStore { /* private fields */ }

A SQLite-backed implementation of the Memory trait.

This provides persistent storage of conversation history using SQLite. All conversations are stored in a local SQLite database file.

Examples

use ceylon_next::memory::SqliteStore;
use std::sync::Arc;

#[tokio::main]
async fn main() {
    let memory = Arc::new(
        SqliteStore::new("agent_memory.db").await.unwrap()
    );
}

Implementations

impl SqliteStore

pub async fn new<P: Into<PathBuf>>(db_path: P) -> Result<Self, String>

Creates a new SQLite store with the given database path.

Arguments

• db_path - Path to the SQLite database file (will be created if it doesn’t exist)

Examples

use ceylon_next::memory::SqliteStore;

#[tokio::main]
async fn main() {
    let store = SqliteStore::new("memory.db").await.unwrap();
}

Examples found in repository

examples/advanced_memory.rs (line 23)

async fn main() -> Result<(), String> {
    println!("🧠 Ceylon AI Framework - Advanced Memory Management Demo\n");

    // 1. Setup Advanced Memory Manager
    println!("1️⃣  Setting up Advanced Memory Manager...");
    let backend = Arc::new(SqliteStore::new("advanced_memory_demo.db").await?);

    let config = MemoryConfig {
        working_memory_limit: 5,
        episodic_memory_limit: 100,
        auto_summarize: true,
        min_summary_length: 2,
        auto_consolidate: false, // Manual for demo
        consolidation_interval: 3600,
        duplicate_threshold: 0.85,
        enable_decay: true,
        decay_rate: 0.05,
        ..Default::default()
    };

    let memory = AdvancedMemoryManager::new(backend, config).await?;
    println!("   ✓ Memory manager initialized\n");

    // 2. Store Multiple Conversations
    println!("2️⃣  Storing conversations...");

    let conversations = vec![
        (
            "What is Rust?",
            "Rust is a systems programming language focused on safety, concurrency, and performance.",
        ),
        (
            "Tell me about Alice",
            "Alice is a software engineer who works at Google on cloud infrastructure projects.",
        ),
        (
            "What projects is Alice working on?",
            "Alice is currently working on Kubernetes optimization and distributed systems.",
        ),
        (
            "How does Rust ensure memory safety?",
            "Rust ensures memory safety through its ownership system, borrowing rules, and lifetimes.",
        ),
        (
            "What is the capital of France?",
            "The capital of France is Paris, a major European city known for art and culture.",
        ),
    ];

    for (i, (user_msg, assistant_msg)) in conversations.iter().enumerate() {
        let messages = vec![
            Message {
                role: "user".to_string(),
                content: user_msg.to_string(),
            },
            Message {
                role: "assistant".to_string(),
                content: assistant_msg.to_string(),
            },
        ];

        let entry = MemoryEntry::new(
            "demo-agent".to_string(),
            format!("task-{}", i),
            messages,
        );

        let id = memory.store_conversation(entry).await?;
        println!("   ✓ Stored conversation {} (ID: {})", i + 1, &id[..8]);
    }
    println!();

    // 3. Query Working Memory
    println!("3️⃣  Querying Working Memory (recent context)...");
    let working = memory.get_working_memory(None).await;
    println!("   Working memory contains {} conversations", working.len());
    for (i, mem) in working.iter().enumerate() {
        if let Some(summary) = &mem.summary {
            println!("   {}. {}", i + 1, summary);
        } else {
            println!("   {}. {} messages", i + 1, mem.entry.messages.len());
        }
    }
    println!();

    // 4. Query Episodic Memory by Time Range
    println!("4️⃣  Querying Episodic Memory...");
    let recent = memory
        .get_episodic_by_time("demo-agent", TimeRange::LastDays(7))
        .await?;
    println!("   Found {} conversations in the last 7 days", recent.len());

    let all = memory
        .get_episodic_by_time("demo-agent", TimeRange::All)
        .await?;
    println!("   Total conversations: {}", all.len());
    println!();

    // 5. Search Memories
    println!("5️⃣  Searching memories for 'Alice'...");
    let search_results = memory.search("demo-agent", "Alice").await?;
    println!("   Found {} results:", search_results.len());
    for (i, mem) in search_results.iter().enumerate() {
        if let Some(summary) = &mem.summary {
            println!("   {}. {}", i + 1, summary);
        }
    }
    println!();

    // 6. Query Semantic Memory
    println!("6️⃣  Querying Semantic Memory...");
    let stats = memory.get_semantic_stats().await;
    println!("   Entities tracked: {}", stats.total_entities);
    println!("   Facts stored: {}", stats.total_facts);
    println!("   Relationships: {}", stats.total_relationships);

    // Query facts about Alice (if extracted)
    if stats.total_facts > 0 {
        println!("\n   Facts about 'Alice':");
        let alice_facts = memory.get_facts_about("Alice").await;
        for fact in alice_facts {
            println!(
                "   - {} {} {} (confidence: {:.2})",
                fact.subject, fact.predicate, fact.object, fact.confidence
            );
        }
    }
    println!();

    // 7. Generate Agent Context
    println!("7️⃣  Generating comprehensive agent context...");
    let context = memory
        .create_agent_context("demo-agent", Some(1000), true)
        .await?;
    println!("   Context length: {} characters", context.len());
    println!("   Preview:");
    let preview: String = context.lines().take(10).collect::<Vec<_>>().join("\n");
    println!("{}\n", preview);

    // 8. Get Relevant Memories
    println!("8️⃣  Getting most relevant memories...");
    let relevant = memory
        .get_relevant_memories("demo-agent", 0.0, 3)
        .await?;
    println!("   Top 3 most relevant memories:");
    for (i, mem) in relevant.iter().enumerate() {
        println!(
            "   {}. Relevance: {:.2} - {} messages",
            i + 1,
            mem.relevance_score(),
            mem.entry.messages.len()
        );
    }
    println!();

    // 9. Run Consolidation
    println!("9️⃣  Running memory consolidation...");
    let result = memory.consolidate(ConsolidationTask::All).await?;
    println!("   Consolidation results:");
    println!("   - Memories processed: {}", result.memories_processed);
    println!("   - Memories merged: {}", result.memories_merged);
    println!("   - Memories deleted: {}", result.memories_deleted);
    println!("   - Duration: {}ms", result.duration_ms);
    println!();

    // 10. Memory Statistics
    println!("🔟 Overall Memory Statistics:");
    let final_stats = memory.get_statistics().await;
    println!("   Working memory:");
    println!("     - Count: {}", final_stats.working_memory_count);
    println!("     - Tokens: {}", final_stats.working_memory_tokens);
    println!("   Semantic memory:");
    println!("     - Entities: {}", final_stats.semantic_entities);
    println!("     - Facts: {}", final_stats.semantic_facts);
    println!("     - Relationships: {}", final_stats.semantic_relationships);
    println!();

    println!("✅ Advanced Memory Management Demo Complete!");
    println!("\n💡 Key Features Demonstrated:");
    println!("   • Working memory for recent context");
    println!("   • Episodic memory for past conversations");
    println!("   • Semantic memory for facts and knowledge");
    println!("   • Automatic summarization");
    println!("   • Time-based and relevance-based retrieval");
    println!("   • Memory consolidation and optimization");
    println!("   • Comprehensive context generation");

    Ok(())
}

examples/11_persistent_memory.rs (line 27)

async fn main() {
    println!("🤖 Ceylon Agent - Persistent Memory Example\n");

    // ============================================
    // Part 1: SQLite Backend
    // ============================================
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("📦 Part 1: SQLite Backend");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

    let sqlite_path = "agent_memory.db";
    let sqlite_store = SqliteStore::new(sqlite_path).await
        .expect("Failed to create SQLite store");

    let mut agent = Agent::new("PersistentAssistant", "ollama::gemma3:latest");
    agent.with_memory(Arc::new(sqlite_store))
         .with_system_prompt("You are a helpful assistant with persistent memory across sessions.");

    println!("✅ Created agent with SQLite backend at {}\n", sqlite_path);

    // Run some tasks to populate memory
    let tasks = vec![
        "My name is Alice and I love programming in Rust",
        "What programming language do I like?",
    ];

    for prompt in tasks {
        println!("📋 Task: {}", prompt);
        let mut task = TaskRequest::new(prompt);
        task.with_priority(5);

        let response = agent.run(task).await;
        if let OutputData::Text(_) = response.result() {
            println!("✓ Task completed\n");
        }
    }

    println!("📊 SQLite database now contains conversation history");
    println!("   This data persists even after the program exits!\n");

    // ============================================
    // Part 2: File-based Backend (JSON)
    // ============================================
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("📄 Part 2: File-based Backend (JSON)");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

    let json_path = "agent_memory.json";
    let file_store = FileStore::new(json_path, StorageFormat::Json).await
        .expect("Failed to create File store");

    let mut agent2 = Agent::new("FileAssistant", "ollama::gemma3:latest");
    agent2.with_memory(Arc::new(file_store))
          .with_system_prompt("You are a helpful assistant storing memories in JSON files.");

    println!("✅ Created agent with JSON file backend at {}\n", json_path);

    let task = TaskRequest::new("Remember: My favorite color is blue");
    let response = agent2.run(task).await;

    if let OutputData::Text(_) = response.result() {
        println!("✓ Memory saved to JSON file");
        println!("   You can open {} to view the human-readable data!\n", json_path);
    }

    // ============================================
    // Part 3: MessagePack Backend
    // ============================================
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("📦 Part 3: MessagePack Backend (Compact Binary)");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

    let msgpack_path = "agent_memory.msgpack";
    let msgpack_store = FileStore::new(msgpack_path, StorageFormat::MessagePack).await
        .expect("Failed to create MessagePack store");

    let mut agent3 = Agent::new("BinaryAssistant", "ollama::gemma3:latest");
    agent3.with_memory(Arc::new(msgpack_store))
          .with_system_prompt("You are a helpful assistant using compact binary storage.");

    println!("✅ Created agent with MessagePack backend at {}\n", msgpack_path);

    let task = TaskRequest::new("Store this efficiently: The quick brown fox jumps over the lazy dog");
    let response = agent3.run(task).await;

    if let OutputData::Text(_) = response.result() {
        println!("✓ Memory saved to MessagePack file");
        println!("   Binary format is more compact than JSON!\n");
    }

    // ============================================
    // Part 4: Memory Migration
    // ============================================
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("🔄 Part 4: Memory Migration Between Backends");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

    // Create source and destination stores
    let source_db = SqliteStore::new("source.db").await.unwrap();

    // Create an agent with source backend and add some data
    let mut temp_agent = Agent::new("MigrationAgent", "ollama::gemma3:latest");
    temp_agent.with_memory(Arc::new(source_db));

    let task = TaskRequest::new("Migration test: This data will be migrated!");
    temp_agent.run(task).await;

    // Note: You would normally track your agent IDs. For this demo, we'll use
    // a known pattern - the agent creates entries with its own ID
    println!("💡 Tip: To migrate data, you need to know the agent's ID");
    println!("   In production, track agent IDs when creating agents\n");

    println!("✓ Migration between backends is available via migrate_memory()\n");
    println!("   Example: migrate_memory(&source, &target, \"agent-id\").await\n");

    // ============================================
    // Part 5: Export/Import Utilities
    // ============================================
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("💾 Part 5: Export/Import Utilities");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

    // Demonstrate export/import with the existing SQLite database
    println!("💡 Export and import utilities are available:\n");
    println!("   • export_to_json(store, agent_id, path)");
    println!("   • export_to_msgpack(store, agent_id, path)");
    println!("   • import_from_json(store, path)");
    println!("   • import_from_msgpack(store, path)\n");

    println!("✓ These functions allow you to backup and restore agent memories\n");

    // ============================================
    // Summary
    // ============================================
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("📊 Summary: Available Backends");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

    println!("1. InMemoryStore (default)");
    println!("   • Fast, but data lost on restart");
    println!("   • Best for: Development, testing\n");

    println!("2. SqliteStore");
    println!("   • Persistent, efficient queries");
    println!("   • Best for: Production apps, large datasets\n");

    println!("3. FileStore (JSON)");
    println!("   • Human-readable, easy to inspect");
    println!("   • Best for: Debugging, data sharing\n");

    println!("4. FileStore (MessagePack)");
    println!("   • Compact binary format");
    println!("   • Best for: Large datasets, bandwidth constraints\n");

    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("📝 Files Created:");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

    println!("• agent_memory.db         - SQLite database");
    println!("• agent_memory.json       - JSON storage");
    println!("• agent_memory.msgpack    - MessagePack storage");
    println!("• backup.json             - Migrated data");
    println!("• exported_memory.json    - Exported snapshot");
    println!("• exported_memory.msgpack - Exported snapshot (binary)\n");

    println!("✅ Example completed successfully!");
    println!("\n💡 Tip: Check the created files to see your persisted data!");
    println!("   Try running this example again - your SQLite data will persist!");
}

pub fn db_path(&self) -> &PathBuf

Returns the path to the database file.

Trait Implementations

impl Memory for SqliteStore

fn store<'life0, 'async_trait>( &'life0 self, entry: MemoryEntry, ) -> Pin<Box<dyn Future<Output = Result<String, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Stores a conversation in memory.

fn get<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<MemoryEntry>, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieves a specific conversation by ID.

fn get_agent_history<'life0, 'life1, 'async_trait>( &'life0 self, agent_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<MemoryEntry>, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieves all conversations for an agent.

fn get_recent<'life0, 'life1, 'async_trait>( &'life0 self, agent_id: &'life1 str, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<MemoryEntry>, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieves the most recent N conversations for an agent.

fn search<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, agent_id: &'life1 str, query: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<MemoryEntry>, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Searches conversations for a query string.

fn clear_agent_memory<'life0, 'life1, 'async_trait>( &'life0 self, agent_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Clears all memory for an agent.