Struct SqliteMemoryStore 

pub struct SqliteMemoryStore { /* private fields */ }

SQLite-backed memory store.

Wraps MemoryDatabase and provides high-level CRUD + search operations that the existing MemoryManager API expects.

Implementations

impl SqliteMemoryStore

pub fn new( db: Arc<MemoryDatabase>, embedding: Arc<dyn EmbeddingProvider>, ) -> SqliteMemoryStore

Create a new SQLite memory store.

pub fn db(&self) -> &Arc<MemoryDatabase>

Returns a reference to the underlying database.

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

Store a memory entry. Returns the entry ID.

Inserts into memories table, FTS5 (via trigger), and sqlite-vec.

pub fn get( &self, id: &str, _memory_type: MemoryType, ) -> Result<Option<MemoryEntry>, Error>

Retrieve a single memory by ID and type.

pub fn get_by_id(&self, id: &str) -> Result<Option<MemoryEntry>, Error>

Retrieve a memory by ID (searches all types).

pub fn forget(&self, id: &str, _memory_type: MemoryType) -> Result<bool, Error>

Delete a memory entry.

pub fn list( &self, memory_type: MemoryType, limit: usize, ) -> Result<Vec<MemoryEntry>, Error>

List memories of a given type, most recent first.

pub async fn search( &self, query: &str, memory_type: Option<MemoryType>, limit: usize, ) -> Result<Vec<MemoryEntry>, Error>

Search memories using BM25 + optional vector KNN with RRF fusion.

pub async fn semantic_search( &self, query: &str, memory_type: Option<MemoryType>, limit: usize, ) -> Result<Vec<RankedMemory>, Error>

Semantic search returning scored results.

pub async fn recall( &self, query: &str, max_recall: usize, ) -> Result<Vec<MemoryEntry>, Error>

Recall relevant memories for a new session.

pub async fn recall_with_rerank( &self, query: &str, max_recall: usize, ) -> Result<Vec<MemoryEntry>, Error>

Recall with Flash Attention re-ranking (Phase 6).

First does standard recall, then re-ranks results using Flash Attention to compute context-aware relevance scores.

The query and memory embeddings form the Q/K/V of the attention mechanism. The output attention weights determine final ranking.

pub fn total_entries(&self) -> usize

Count total entries in the database.

pub fn count_by_type(&self, memory_type: MemoryType) -> usize

Count entries by type.

pub fn blend_into_prompt( &self, memories: &[MemoryEntry], system_prompt: &str, ) -> String

Blend recalled memories into the system prompt.

pub async fn is_duplicate(&self, content: &str) -> bool

Check if a memory entry with identical content already exists.

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

Store a memory entry only if no duplicate content exists.

pub fn migrate_if_needed(&self, workspace_dir: &Path) -> Result<(), Error>

Run JSON → SQLite migration if needed.

pub fn build_co_access_graph(&self) -> MemoryGraph

Build a co-access graph from memory session history.

Groups memories by session_id and links all co-accessed pairs. Returns a MemoryGraph ready for PageRank computation.

pub fn compute_pagerank( &self, damping: f64, iterations: usize, initial_scores: Option<&HashMap<u64, f64>>, ) -> HashMap<u64, f64>

Compute PageRank-based importance scores for all memories.

Returns a map of memory rowid -> PageRank score. Higher scores indicate memories that are more “central” in the co-access graph — they bridge topics and appear in many sessions.

pub fn apply_pagerank_boost( &self, pagerank_scores: &HashMap<u64, f64>, boost_factor: f32, ) -> usize

Apply PageRank scores as importance boosts.

For each memory, the importance is updated as: new_importance = old_importance * (1 + pagerank_boost * pagerank_score)

Returns the number of entries updated.

pub fn list_by_tier( &self, tier: MemoryTier, limit: usize, ) -> Result<Vec<MemoryEntry>, Error>

List memories by tier.

pub fn update_entry(&self, entry: &MemoryEntry) -> Result<(), Error>

Update a memory entry in-place.

pub fn save_pattern( &self, id: &str, strategy: &str, domain: Option<&str>, quality: f32, data: &str, ) -> Result<(), Error>

Store a learning pattern.

pub fn load_patterns(&self) -> Result<Vec<PatternRow>, Error>

Load all learning patterns.

pub fn record_pattern_usage(&self, id: &str, success: bool) -> Result<(), Error>

Record a pattern usage.

pub fn auto_promote_patterns(&self, min_quality: f32, min_usage: u32) -> usize

Auto-promote high-quality patterns to long-term storage.

Patterns with quality >= min_quality and use_count >= min_usage are marked as long-term.

pub async fn get_query_vector( &self, query: &str, ) -> Result<Option<Vec<f32>>, Error>

Get or compute a query embedding, using the cache.

Trait Implementations

impl Debug for SqliteMemoryStore

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

Formats the value using the given formatter.

impl MemoryBackend for SqliteMemoryStore

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

where 'life0: 'async_trait, 'life1: 'async_trait, SqliteMemoryStore: 'async_trait,

Store a memory entry. Returns the entry ID.

fn get( &self, id: &str, memory_type: MemoryType, ) -> Result<Option<MemoryEntry>, Error>

Retrieve a single memory by ID and type.

fn get_by_id(&self, id: &str) -> Result<Option<MemoryEntry>, Error>

Retrieve a single memory by ID (searches all types).

fn forget(&self, id: &str, memory_type: MemoryType) -> Result<bool, Error>

Delete a memory entry. Returns true if it existed.

fn list( &self, memory_type: MemoryType, limit: usize, ) -> Result<Vec<MemoryEntry>, Error>

List memories of a given type, most recent first.

fn search<'life0, 'life1, 'async_trait>( &'life0 self, query: &'life1 str, memory_type: Option<MemoryType>, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<MemoryEntry>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, SqliteMemoryStore: 'async_trait,

Search memories by query (semantic + keyword hybrid).

fn recall<'life0, 'life1, 'async_trait>( &'life0 self, query: &'life1 str, max_recall: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<MemoryEntry>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, SqliteMemoryStore: 'async_trait,

Recall relevant memories for a query.

fn recall_with_rerank<'life0, 'life1, 'async_trait>( &'life0 self, query: &'life1 str, max_recall: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<MemoryEntry>, Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, SqliteMemoryStore: 'async_trait,

Recall with Flash Attention re-ranking.

fn blend_into_prompt( &self, memories: &[MemoryEntry], system_prompt: &str, ) -> String

Blend recalled memories into the system prompt.

fn is_duplicate<'life0, 'life1, 'async_trait>( &'life0 self, content: &'life1 str, ) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, SqliteMemoryStore: 'async_trait,

Check if a memory entry with identical content already exists.

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

where 'life0: 'async_trait, 'life1: 'async_trait, SqliteMemoryStore: 'async_trait,

Store a memory entry only if no duplicate content exists.

fn list_by_tier( &self, tier: MemoryTier, limit: usize, ) -> Result<Vec<MemoryEntry>, Error>

List memories by tier.