Struct MemoryEntry 

pub struct MemoryEntry {
    pub id: String,
    pub agent_id: String,
    pub task_id: String,
    pub messages: Vec<Message>,
    pub created_at: u64,
}

A stored conversation between an agent and user.

Each memory entry represents a complete task execution, including all messages exchanged between the user and agent.

Examples

use ceylon_next::memory::MemoryEntry;
use ceylon_next::llm::types::Message;

let messages = vec![
    Message {
        role: "user".to_string(),
        content: "Hello!".to_string(),
    },
    Message {
        role: "assistant".to_string(),
        content: "Hi there!".to_string(),
    },
];

let entry = MemoryEntry::new(
    "agent-123".to_string(),
    "task-456".to_string(),
    messages,
);

Fields

id: String

Unique identifier for this memory entry

agent_id: String

ID of the agent that created this memory

task_id: String

ID of the task this memory is associated with

messages: Vec<Message>

The conversation messages

created_at: u64

Unix timestamp when this memory was created

Implementations

impl MemoryEntry

pub fn new(agent_id: String, task_id: String, messages: Vec<Message>) -> Self

Creates a new memory entry.

Arguments

• agent_id - The ID of the agent that created this memory
• task_id - The ID of the task this memory is associated with
• messages - The conversation messages to store

Examples found in repository

examples/advanced_memory.rs (lines 79-83)

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

Trait Implementations

impl Clone for MemoryEntry

fn clone(&self) -> MemoryEntry

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MemoryEntry

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MemoryEntry

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for MemoryEntry

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.