Memory

Conversation memory and history management in PraisonAI Rust SDK

Memory stores conversation history, enabling agents to maintain context across interactions.

Quick Start

1. Enable Agent Memory

   use praisonai::Agent;
   
   let agent = Agent::new()
       .name("Assistant")
       .instructions("Remember our conversation")
       .memory(true)  // Enable memory
       .build()?;
   
   // Conversation context persists between calls
   agent.chat("My name is Alice").await?;
   let response = agent.chat("What's my name?").await?;
   // response: "Your name is Alice"

2. Clear Memory

   use praisonai::Agent;
   
   let agent = Agent::new()
       .name("Assistant")
       .memory(true)
       .build()?;
   
   agent.chat("Remember: secret code is 1234").await?;
   agent.clear_memory().await?;
   agent.chat("What's the secret code?").await?;
   // Agent no longer remembers the code

User Interaction Flow

Memory

Main memory manager for agents.

pub struct Memory {
    adapter: Box<dyn MemoryAdapter>,
    config: MemoryConfig,
}

Factory Methods

Instance Methods

` | Get conversation history |

| search(query, limit) | `async fn search(&self, &str, usize) -> Result<Vec

` | Search messages |

| clear() | async fn clear(&mut self) -> Result<()> | Clear all memory | | config() | fn config(&self) -> &MemoryConfig | Get config reference |

MemoryConfig

Configuration for memory behavior.

pub struct MemoryConfig {
    pub use_short_term: bool,
    pub max_messages: usize,
}

Configuration Options

ConversationHistory

Low-level message storage with automatic trimming.

pub struct ConversationHistory {
    messages: VecDeque<Message>,
    max_messages: usize,
}

Methods

| Get all messages | | clear() | fn clear(&mut self) | Clear all messages | | len() | fn len(&self) -> usize | Message count | | is_empty() | fn is_empty(&self) -> bool` | Check if empty |

Note: When trimming, system messages are preserved – only user/assistant messages are removed.

MemoryAdapter Trait

Interface for custom memory backends.

#[async_trait]
pub trait MemoryAdapter: Send + Sync {
    async fn store_short_term(&mut self, message: Message) -> Result<()>;
    async fn search_short_term(&self, query: &str, limit: usize) -> Result<Vec<Message>>;
    async fn get_short_term(&self) -> Result<Vec<Message>>;
    async fn clear_short_term(&mut self) -> Result<()>;

    // Optional long-term methods (default no-op)
    async fn store_long_term(&mut self, text: &str, metadata: Option<Value>) -> Result<()>;
    async fn search_long_term(&self, query: &str, limit: usize) -> Result<Vec<String>>;
}

InMemoryAdapter

Default in-memory implementation.

pub struct InMemoryAdapter {
    history: ConversationHistory,
}

Methods

Custom Memory Adapter

use praisonai::{MemoryAdapter, Message, async_trait, Result};

struct RedisMemory {
    client: redis::Client,
}

#[async_trait]
impl MemoryAdapter for RedisMemory {
    async fn store_short_term(&mut self, message: Message) -> Result<()> {
        // Store to Redis
        Ok(())
    }

    async fn search_short_term(&self, query: &str, limit: usize) -> Result<Vec<Message>> {
        // Search Redis
        Ok(vec![])
    }

    async fn get_short_term(&self) -> Result<Vec<Message>> {
        // Get from Redis
        Ok(vec![])
    }

    async fn clear_short_term(&mut self) -> Result<()> {
        // Clear Redis keys
        Ok(())
    }
}

Best Practices

Related