Enum MemoryHandle 

pub enum MemoryHandle {
    Log(LogMemory),
    Vector(Arc<VectorMemory<SharedEmbedder>>),
    Reranked {
        inner: Box<MemoryHandle>,
        reranker: SharedReranker,
    },
    Custom(Arc<dyn DynMemory>),
}

The front door to agent memory: remember, recall, improve, forget. Built by Laser::memory, or Laser::memory_with for an explicit MemoryBackend. Hold one instance per namespace and reuse it so recall stays incremental across calls.

Variants

Log(LogMemory)

The durable stream model: every write publishes to the memory topic, and a deployment materializes it into the versioned key-value read view.

Vector(Arc<VectorMemory<SharedEmbedder>>)

The in-process vector backend, shared so the handle stays cheap to clone while the index lives across calls.

Reranked

Any backend wrapped with a rerank second stage (see embedder / reranker).

Fields

inner: Box<MemoryHandle>

reranker: SharedReranker

Custom(Arc<dyn DynMemory>)

An external durable backend plugged in through Laser::memory_custom.

Implementations

impl MemoryHandle

pub fn backend(&self) -> &'static str

Which backend this handle resolved to: "log" for the durable stream model (the default), "vector" for the in-process similarity index.

pub fn vector(embedder: impl Embedder + Sync + 'static) -> Self

A standalone in-process vector handle over embedder, with no Laser and no governance. For a governed vector handle use Laser::memory_with with MemoryBackend::Vector.

pub fn embedder(self, embedder: impl Embedder + Sync + 'static) -> Self

Register the embedding seam for similarity recall. It configures the in-process vector index. The durable log model recalls by recency, so an embedder on a log handle is unused (build with memory_with(.., MemoryBackend::Vector) for similarity recall).

pub fn reranker(self, reranker: impl Reranker + Sync + 'static) -> Self

Wrap recall with a rerank second stage, exactly as RerankedMemory does: the backend retrieves, the reranker reorders when the query carries its semantic text. Composition, not configuration.

impl MemoryHandle

pub async fn set( &self, key: impl AsRef<str>, payload: impl Into<Vec<u8>>, ) -> Result<(), LaserError>

The simple altitude: write named point state under your own key. remember/recall address items by content and relevance. set/fetch/update/remove address them by name, the working-note shape (“the current plan”, “the user’s tier”). Every write is a durable event on the memory topic, like the rest of memory, so a deployment materializes it and other consumers see it. The in-process vector handle has no key space and refuses typed.

pub async fn fetch( &self, key: impl AsRef<str>, ) -> Result<Option<Vec<u8>>, LaserError>

Point-read the named item written by set, or None.

pub async fn fetch_folded( &self, key: impl AsRef<str>, ) -> Result<Option<Vec<u8>>, LaserError>

Point-read the named item by folding the topic in process, the opt-in path for a deployment with no managed read view. Prefer fetch, which reads the materialized key-value view.

pub async fn update( &self, key: impl AsRef<str>, patch: impl Into<Vec<u8>>, ) -> Result<(), LaserError>

Merge-patch the named item (RFC 7386 over a JSON value): fields in patch overwrite, null removes. Reads the current value, merges, and writes the result back as one event. For a whole-value overwrite use set.

pub async fn remove(&self, key: impl AsRef<str>) -> Result<(), LaserError>

Delete the named item. Idempotent: removing an absent key is fine.

pub fn remember(&self, payload: impl Into<Vec<u8>>) -> RememberBuilder<'_>

Start a fluent remember. Chain .scope/.agent/.durable/.dedup and finish with .send().await.

pub async fn recall_folded( &self, scope: &MemoryScope, query: &MemoryQuery, ) -> Result<Vec<MemoryItem>, LaserError>

Recall by folding the topic in process (the opt-in behind RecallBuilder::folded). The log backend folds, the vector backend is already in process, and a reranked backend folds its inner then reranks.

pub fn recall( &self, conversation: impl Into<Option<ConversationId>>, ) -> RecallBuilder<'_>

Start a fluent recall in conversation, or across every conversation of the namespace with None. Chain .semantic/.limit and finish with .fetch().await (or await the builder itself).

pub async fn context( &self, conversation: ConversationId, token_budget: Option<usize>, ) -> Result<String, LaserError>

The one-call context altitude: recall conversation’s most relevant items and render them as one prompt-ready block under an optional token budget (see to_context_block). The 90% case above the deep recall builder: assembled, budgeted, ready to prompt.

pub async fn consolidate( &self, scope: &MemoryScope, max_items: usize, ) -> Result<ConsolidationReport, LaserError>

One consolidation pass over scope with the default policy: keep the newest max_items, prune the rest. For the summarize and invalidation passes build a DefaultConsolidator with its seams and run it directly. This is the one-call altitude.

pub async fn consolidate_with( &self, scope: &MemoryScope, max_items: usize, summarizer: impl Summarizer + Sync, prune_summarized: bool, ) -> Result<ConsolidationReport, LaserError>

consolidate with the summarize pass: the Message items in scope are first folded through summarizer into one durable summary per conversation, and prune_summarized forgets the folded items so the summary replaces them.

pub async fn improve( &self, scope: &MemoryScope, feedback: Feedback, ) -> Result<MemoryId, LaserError>

Record feedback on a recalled item under scope.

pub async fn forget( &self, scope: &MemoryScope, id: MemoryId, ) -> Result<(), LaserError>

Forget the item id under scope.

Trait Implementations

impl Memory for MemoryHandle

async fn remember( &self, scope: &MemoryScope, payload: Vec<u8>, ) -> Result<MemoryId, LaserError>

Append payload to the memory under scope. The body is opaque bytes, so encode it with whatever codec you like before calling.

async fn append( &self, scope: &MemoryScope, id: MemoryId, kind: MemoryKind, payload: Vec<u8>, ) -> Result<MemoryId, LaserError>

Append a typed item. Custom backends can keep their remember fallback.

async fn recall( &self, scope: &MemoryScope, query: &MemoryQuery, ) -> Result<Vec<MemoryItem>, LaserError>

async fn improve( &self, scope: &MemoryScope, feedback: Feedback, ) -> Result<MemoryId, LaserError>

Record feedback on a recalled item, the log-native signal a ranking backend folds into future recall. Returns the feedback record’s id.

async fn forget( &self, scope: &MemoryScope, id: MemoryId, ) -> Result<(), LaserError>

impl Memory for &MemoryHandle

async fn remember( &self, scope: &MemoryScope, payload: Vec<u8>, ) -> Result<MemoryId, LaserError>

Append payload to the memory under scope. The body is opaque bytes, so encode it with whatever codec you like before calling.

fn append( &self, scope: &MemoryScope, id: MemoryId, kind: MemoryKind, payload: Vec<u8>, ) -> impl Future<Output = Result<MemoryId, LaserError>> + Send

where Self: Sync,

Append a typed item. Custom backends can keep their remember fallback.

async fn recall( &self, scope: &MemoryScope, query: &MemoryQuery, ) -> Result<Vec<MemoryItem>, LaserError>

async fn improve( &self, scope: &MemoryScope, feedback: Feedback, ) -> Result<MemoryId, LaserError>

Record feedback on a recalled item, the log-native signal a ranking backend folds into future recall. Returns the feedback record’s id.

async fn forget( &self, scope: &MemoryScope, id: MemoryId, ) -> Result<(), LaserError>