Struct RecallBuilder 

pub struct RecallBuilder<'a> { /* private fields */ }

A fluent recall, created by MemoryHandle::recall. Awaiting the builder runs fetch.

Implementations

impl RecallBuilder<'_>

pub fn semantic(self, text: impl Into<String>) -> Self

Rank by semantic similarity to text (sets the Semantic strategy). Honored by an embedding backend. The log backend returns the most recent.

pub fn recent(self) -> Self

Return the most recent items (sets the Recent strategy).

pub fn folded(self) -> Self

Fold the topic in process instead of reading the managed key-value view, the opt-in path for small serverless scenarios with no deployment. The default reads the read view, which does not fold a large topic.

pub fn keyword(self, text: impl Into<String>) -> Self

Rank by lexical relevance to text (sets the Keyword strategy, the managed Query.text rider). The complement to semantic for the exact-term matches an embedding blurs.

pub fn hybrid(self, text: impl Into<String>) -> Self

Combine semantic similarity, keyword overlap, and feedback by addition for text. Each item’s signals keeps the individual scores and ranks.

pub fn strategy(self, strategy: RecallStrategy) -> Self

Set the recall strategy explicitly, the deep form behind the sugar above. Pair a text-driven strategy with the query text (semantic, keyword, or hybrid set it in one call).

pub fn agent(self, agent: AgentId) -> Self

Narrow to an agent.

pub fn user(self, user: impl Into<String>) -> Self

Narrow to an end user.

pub fn application(self, application: impl Into<String>) -> Self

Narrow to an application or org within the deployment.

pub fn stream(self, stream: impl Into<String>) -> Self

Narrow to items remembered on this stream.

pub fn limit(self, limit: usize) -> Self

Cap the number of items returned.

pub async fn block( self, token_budget: Option<usize>, ) -> Result<String, LaserError>

Run the recall and render the items as one prompt-ready block under token_budget, see to_context_block.

pub async fn fetch(self) -> Result<Vec<MemoryItem>, LaserError>

Run the recall.

Trait Implementations

impl<'a> IntoFuture for RecallBuilder<'a>

type Output = Result<Vec<MemoryItem>, LaserError>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = <RecallBuilder<'a> as IntoFuture>::Output> + Send + 'a>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.