Struct AdvancedMemoryManager 

pub struct AdvancedMemoryManager { /* private fields */ }

Advanced Memory Manager

Orchestrates all memory subsystems:

• Working Memory: Recent context
• Episodic Memory: Past conversations
• Semantic Memory: Facts and knowledge
• Summarization: Automatic compression
• Consolidation: Background processing

Implementations

impl AdvancedMemoryManager

pub async fn new( backend: Arc<dyn Memory>, config: MemoryConfig, ) -> Result<Self, String>

Create a new advanced memory manager

Examples found in repository

examples/advanced_memory.rs (line 38)

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(())
}

pub async fn store_conversation( &self, entry: MemoryEntry, ) -> Result<String, String>

Store a new conversation

Examples found in repository

examples/advanced_memory.rs (line 85)

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(())
}

pub async fn get(&self, id: &str) -> Result<Option<EnhancedMemoryEntry>, String>

Retrieve a memory by ID

pub async fn get_working_memory( &self, max_tokens: Option<usize>, ) -> Vec<EnhancedMemoryEntry>

Get recent working memory

Examples found in repository

examples/advanced_memory.rs (line 92)

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(())
}

pub async fn get_episodic_by_time( &self, agent_id: &str, range: TimeRange, ) -> Result<Vec<EnhancedMemoryEntry>, String>

Get episodic memories by time range

Examples found in repository

examples/advanced_memory.rs (line 106)

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(())
}

pub async fn get_relevant_memories( &self, agent_id: &str, min_score: f32, limit: usize, ) -> Result<Vec<EnhancedMemoryEntry>, String>

Get relevant memories by score

Examples found in repository

examples/advanced_memory.rs (line 160)

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(())
}

pub async fn search( &self, agent_id: &str, query: &str, ) -> Result<Vec<EnhancedMemoryEntry>, String>

Search memories

Examples found in repository

examples/advanced_memory.rs (line 118)

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(())
}

pub async fn get_knowledge(&self, entity_name: &str) -> Option<KnowledgeSummary>

Get knowledge about an entity

pub async fn get_facts_about(&self, subject: &str) -> Vec<Fact>

Get all facts about a subject

Examples found in repository

examples/advanced_memory.rs (line 137)

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(())
}

pub async fn get_semantic_stats(&self) -> SemanticMemoryStats

Get semantic memory statistics

Examples found in repository

examples/advanced_memory.rs (line 129)

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(())
}

pub async fn create_agent_context( &self, agent_id: &str, max_tokens: Option<usize>, include_semantic: bool, ) -> Result<String, String>

Create a comprehensive context message for the agent

Examples found in repository

examples/advanced_memory.rs (line 150)

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(())
}

pub async fn consolidate( &self, task: ConsolidationTask, ) -> Result<ConsolidationResult, String>

Run consolidation tasks

Examples found in repository

examples/advanced_memory.rs (line 175)

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(())
}

pub async fn start_background_processing(&self)

Start background consolidation

pub async fn stop_background_processing(&self)

Stop background consolidation

pub async fn get_statistics(&self) -> MemoryStatistics

Get statistics about memory usage

Examples found in repository

examples/advanced_memory.rs (line 185)

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(())
}

pub async fn clear_agent_memory(&self, agent_id: &str) -> Result<(), String>

Clear all memory for an agent

Trait Implementations

impl Memory for AdvancedMemoryManager

Implement the base Memory trait for compatibility

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.