Struct MemoryGuide 

pub struct MemoryGuide { /* private fields */ }

Guide that recalls relevant prior memories and injects them into ctx.guides as a Block::Text for the model to see.

Two recall points:

• apply (session start): one-shot recall using ctx.task.description as the query. Always fires.
• apply_before_iter (every model turn): re-recalls using the last user message as query, replacing the previous recall block. Lets the recall track topic drift mid-session. No-op when there’s no user message in history (the very first iteration uses the apply recall).

Filters (chainable builders, post-recall):

• with_top_k(k) — number of candidates to fetch from Memory::recall. Default 5.
• with_min_score(s) — drop entries whose recomputed normalised keyword overlap with the query is below s. Default 0.0 (no filter). Score = (query_tokens ∩ entry_tokens).len() / query_tokens.len().
• with_required_tags(tags) — drop entries that don’t have ALL these tags. Default empty (no filter).
• with_excluded_tags(tags) — drop entries that have ANY of these tags. Default empty.

When filters are tight, we over-fetch top_k * 3 candidates so there’s room to drop without starving the output.

Implementations

impl MemoryGuide

pub fn new(memory: Arc<dyn Memory>) -> Self

Construct a guide that recalls up to 5 entries per session.

pub fn with_top_k(self, k: usize) -> Self

Override the number of memories recalled per session. Pick small — every recalled line spends prompt tokens.

pub fn with_min_score(self, s: f32) -> Self

Drop entries whose recomputed normalised keyword overlap with the query is below s ∈ [0, 1]. Default 0.0 (= keep all top_k).

Score formula: (distinct query tokens present in entry.content+tags) / (query token count)

So a query of 4 tokens needs ≥3 to land in the entry to score ≥ 0.75.

pub fn with_required_tags( self, tags: impl IntoIterator<Item = impl Into<String>>, ) -> Self

Only inject entries that have ALL of these tags. Empty = no filter.

pub fn with_excluded_tags( self, tags: impl IntoIterator<Item = impl Into<String>>, ) -> Self

Drop entries that have ANY of these tags. Empty = no filter.

Trait Implementations

impl Guide for MemoryGuide

fn id(&self) -> &GuideId

fn kind(&self) -> Execution

fn scope(&self) -> &GuideScope

fn apply<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 mut Context, _w: &'life2 World, ) -> Pin<Box<dyn Future<Output = Result<(), GuideError>> + Send + 'async_trait>>

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

Called ONCE per session, at the start, before the first model call. Use for content that doesn’t change across iterations (profile, skills catalogue, static instructions).

fn apply_before_iter<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 mut Context, _w: &'life2 World, ) -> Pin<Box<dyn Future<Output = Result<(), GuideError>> + Send + 'async_trait>>

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

Called BEFORE every model.complete() call within a session (default: no-op). Override to inject content that should adapt to the current conversation state — most useful for recall-style guides that want to re-query an external store based on the last user message.