Struct SqliteMemoryProvider 

pub struct SqliteMemoryProvider { /* private fields */ }

SQLite-backed MemoryProvider.

Implementations

impl SqliteMemoryProvider

pub async fn open( path: impl AsRef<Path>, embedder: Arc<dyn Embedder>, ) -> Result<Self, SqliteMemoryError>

Open or create a memory database at the given path. Loads sqlite-vec into the connection, runs pending migrations, returns a ready-to-use provider.

The provided Embedder determines the dimensionality used at write time. The migration schema currently hard-codes FLOAT[384] for memory_vec; if the embedder’s dim is different, writes that produce embeddings will fail with DimMismatch. Future migrations will make the dim configurable.

pub fn with_write_hook(self, hook: Arc<dyn MemoryWriteHook>) -> Self

Attach a MemoryWriteHook consulted before every write. Use this to connect policy checks, redaction rules, or application-specific write filters.

pub fn with_summarizer(self, summarizer: Arc<dyn Summarizer>) -> Self

Attach a Summarizer used by MemoryProvider::summarize_session, rollup_day, and rollup_rule_week. Applications pass a concrete downstream cel_memory::Summarizer implementation; tests can pass a cel_memory::MockSummarizer.

Calling MemoryProvider::summarize_session without first attaching a summarizer returns cel_memory::MemoryError::NotImplemented when summarization is not configured.

pub async fn open_in_memory( embedder: Arc<dyn Embedder>, ) -> Result<Self, SqliteMemoryError>

Open an in-memory database for tests.

Trait Implementations

impl MemoryProvider for SqliteMemoryProvider

fn retrieve<'life0, 'async_trait>( &'life0 self, query: MemoryQuery, ) -> Pin<Box<dyn Future<Output = MemoryResult<Vec<MemoryChunk>>> + Send + 'async_trait>>

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

Hybrid retrieval over the memory store. The provider applies the query’s profile, scope, and filters and returns up to query.k chunks in descending relevance order.

fn get<'life0, 'life1, 'async_trait>( &'life0 self, chunk_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = MemoryResult<Option<MemoryChunk>>> + Send + 'async_trait>>

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

Fetch a chunk by ID.

fn get_session<'life0, 'life1, 'async_trait>( &'life0 self, session_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = MemoryResult<Option<MemorySession>>> + Send + 'async_trait>>

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

Fetch a session by ID.

fn list_sessions<'life0, 'async_trait>( &'life0 self, filter: SessionFilter, ) -> Pin<Box<dyn Future<Output = MemoryResult<Vec<MemorySession>>> + Send + 'async_trait>>

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

List sessions matching the filter, most-recent-first.

fn write<'life0, 'async_trait>( &'life0 self, new_chunk: NewMemoryChunk, ) -> Pin<Box<dyn Future<Output = MemoryResult<MemoryChunk>> + Send + 'async_trait>>

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

Persist a single new chunk. The provider assigns id, created_at, tier, and embedding-model metadata.

fn write_batch<'life0, 'async_trait>( &'life0 self, chunks: Vec<NewMemoryChunk>, ) -> Pin<Box<dyn Future<Output = MemoryResult<Vec<MemoryChunk>>> + Send + 'async_trait>>

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

Persist many chunks in one call. The provider may batch embeddings; the v1 stub processes them one at a time.

fn open_session<'life0, 'async_trait>( &'life0 self, init: NewMemorySession, ) -> Pin<Box<dyn Future<Output = MemoryResult<MemorySession>> + Send + 'async_trait>>

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

Open a new session. Returns the session record.

fn close_session<'life0, 'life1, 'async_trait>( &'life0 self, session_id: &'life1 str, outcome: SessionOutcome, ) -> Pin<Box<dyn Future<Output = MemoryResult<()>> + Send + 'async_trait>>

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

Close an open session. Triggers session summarization where supported.

fn rename_session<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_id: &'life1 str, title: &'life2 str, ) -> Pin<Box<dyn Future<Output = MemoryResult<()>> + Send + 'async_trait>>

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

Rename a session’s display title. Returns Err(NotFound) if the session does not exist. The v1 BasicMemoryProvider implements this in-memory; SqliteMemoryProvider updates the memory_sessions.title column.

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

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

Set or clear the pin flag on a chunk.

fn update_importance<'life0, 'life1, 'async_trait>( &'life0 self, chunk_id: &'life1 str, importance: f32, ) -> Pin<Box<dyn Future<Output = MemoryResult<()>> + Send + 'async_trait>>

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

Set the importance score on a chunk. Out-of-range values are clamped to [0.0, 1.0]. The v1 stub no-ops (importance is not scored).

fn supersede<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, old_id: &'life1 str, new_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = MemoryResult<()>> + Send + 'async_trait>>

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

Mark old_id as superseded by new_id. Both chunks are retained; retrieval surfaces the superseder. The v1 stub no-ops.

fn record_access<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, chunk_id: &'life1 str, retrieved_by: &'life2 str, used: bool, ) -> Pin<Box<dyn Future<Output = MemoryResult<()>> + Send + 'async_trait>>

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

Record that a chunk was returned by a retrieval call. used=true signals the consumer cited or acted on it (drives importance bumps in the full impl).

fn delete<'life0, 'life1, 'async_trait>( &'life0 self, chunk_id: &'life1 str, reason: EvictionReason, ) -> Pin<Box<dyn Future<Output = MemoryResult<()>> + Send + 'async_trait>>

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

Hard-delete a single chunk, logging the reason.

fn delete_matching<'life0, 'async_trait>( &'life0 self, predicate: MemoryPredicate, reason: EvictionReason, ) -> Pin<Box<dyn Future<Output = MemoryResult<usize>> + Send + 'async_trait>>

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

Hard-delete all chunks matching the predicate. Returns the count.

fn purge_all<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = MemoryResult<PurgeReport>> + Send + 'async_trait>>

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

Hard-delete every chunk, session, access-log row, and eviction-log row. The “forget everything” flow.

fn summarize_session<'life0, 'life1, 'async_trait>( &'life0 self, session_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = MemoryResult<MemoryChunk>> + Send + 'async_trait>>

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

Produce a JobSummary chunk synthesizing the named session. Inserted into the store; returned to the caller. v1 stub returns crate::MemoryError::NotImplemented.

fn rollup_day<'life0, 'async_trait>( &'life0 self, date: NaiveDate, ) -> Pin<Box<dyn Future<Output = MemoryResult<Vec<MemoryChunk>>> + Send + 'async_trait>>

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

Produce one or more Rollup chunks for the named day. v1 stub returns crate::MemoryError::NotImplemented.

fn rollup_day_forced<'life0, 'async_trait>( &'life0 self, date: NaiveDate, ) -> Pin<Box<dyn Future<Output = MemoryResult<Vec<MemoryChunk>>> + Send + 'async_trait>>

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

Force-produce one or more Rollup chunks for the named day even if a prior rollup exists. Default impl delegates to Self::rollup_day for backward compatibility; the SQLite provider overrides to actually honour the force flag.

fn rollup_rule_week<'life0, 'life1, 'async_trait>( &'life0 self, rule_id: &'life1 str, week_start: NaiveDate, ) -> Pin<Box<dyn Future<Output = MemoryResult<MemoryChunk>> + Send + 'async_trait>>

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

Produce a Rollup chunk for the named rule across the named week. v1 stub returns crate::MemoryError::NotImplemented.

fn rollup_rule_week_forced<'life0, 'life1, 'async_trait>( &'life0 self, rule_id: &'life1 str, week_start: NaiveDate, ) -> Pin<Box<dyn Future<Output = MemoryResult<MemoryChunk>> + Send + 'async_trait>>

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

Force-produce a Rollup chunk for the named rule + week even if a prior rollup exists. Default impl delegates to Self::rollup_rule_week for backward compatibility; the SQLite provider overrides to honour the force flag.

fn run_aging_sweep<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = MemoryResult<AgingReport>> + Send + 'async_trait>>

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

Run the aging sweeper: tier transitions, retention-horizon deletes, importance-based eviction. Idempotent.

fn re_embed_all<'life0, 'life1, 'async_trait>( &'life0 self, target_model: &'life1 str, ) -> Pin<Box<dyn Future<Output = MemoryResult<ReEmbedReport>> + Send + 'async_trait>>

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

Re-embed every chunk against the target model. Long-running. Resumable. v1 stub returns crate::MemoryError::NotImplemented.

fn export<'life0, 'async_trait>( &'life0 self, filter: ExportFilter, ) -> Pin<Box<dyn Future<Output = MemoryResult<ExportBundle>> + Send + 'async_trait>>

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

Export memory matching the filter as a self-contained bundle.

fn stats<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = MemoryResult<MemoryStats>> + Send + 'async_trait>>

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

Summary statistics for the dashboard / doctor check.