Struct BasicMemoryProvider 

pub struct BasicMemoryProvider { /* private fields */ }

The v1 backing implementation. Cheap to construct; Clone is shallow (shares the underlying state). Safe to share across tasks.

Implementations

impl BasicMemoryProvider

pub fn new() -> Self

Construct an empty provider. Equivalent to Default::default().

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

Attach a MemoryWriteHook consulted before every write. Use this for policy-driven memory redaction or application-specific write filtering.

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

Attach a Summarizer used by MemoryProvider::summarize_session, MemoryProvider::rollup_day, and MemoryProvider::rollup_rule_week.

Trait Implementations

impl Clone for BasicMemoryProvider

fn clone(&self) -> BasicMemoryProvider

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BasicMemoryProvider

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

Formats the value using the given formatter.

impl Default for BasicMemoryProvider

fn default() -> Self

Returns the “default value” for a type.

impl MemoryProvider for BasicMemoryProvider

fn retrieve<'life0, 'async_trait>( &'life0 self, query: MemoryQuery, ) -> Pin<Box<dyn Future<Output = Result<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 = Result<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 = Result<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 = Result<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 = Result<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 = Result<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 = Result<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 = Result<()>> + 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 = Result<()>> + 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 = Result<()>> + 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 = Result<()>> + 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 = Result<()>> + 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 = Result<()>> + 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 = Result<()>> + 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 = Result<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 = Result<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 = Result<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 = Result<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 = Result<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 = Result<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 = Result<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 = Result<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 = Result<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 = Result<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 = Result<MemoryStats>> + Send + 'async_trait>>

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

Summary statistics for the dashboard / doctor check.