Struct LogMemory 

pub struct LogMemory { /* private fields */ }

Memory over the append-only Iggy log (AgentTopic::Memory). remember appends, forget appends a tombstone, recall returns the folded items for a conversation (most recent first by limit), applying tombstones and the agent filter. The log is the source of truth.

Recall is incremental: LogMemory keeps a folded projection plus a per-partition cursor, and each recall drains only what was appended since the last one (the same partition-drain the Cursor is built on), with no rescan from offset 0. A fresh instance rebuilds the projection from the log on its first recall. There is no side checkpoint to keep because the log already holds the truth.

Implementations

impl LogMemory

pub fn new(laser: Laser) -> Self

A log-backed memory over an owned Laser (cheap to clone, shares the one connection). Hold a single instance to keep recall incremental: it folds only what was appended since the last recall, never rescanning from offset zero. A fresh instance rebuilds the projection from the log on its first recall, so reuse one instance for an agent that recalls repeatedly.

pub fn in_namespace(laser: Laser, namespace: impl Into<String>) -> Self

Like new but carries a caller-named namespace: the prefix the named-item altitude keys on. The records still ride the default AgentTopic::Memory. This is what Laser::memory builds.

pub fn on_topic(laser: Laser, topic: Identifier) -> Self

Like new but writes and folds a caller-named memory topic instead of the default AgentTopic::Memory. The configurable memory stream: one deployment can keep several isolated memory topics. The namespace defaults to the topic’s name.

pub fn on_stream_topic( laser: Laser, stream: Option<String>, topic: Identifier, ) -> Self

Like on_topic but on a caller-named stream too, not the client’s default. None keeps the default stream.

pub fn on_topic_named(laser: Laser, topic: &str) -> Result<Self, LaserError>

on_topic from a topic name, validating it.

pub fn on_stream_topic_named( laser: Laser, stream: Option<String>, topic: &str, ) -> Result<Self, LaserError>

on_stream_topic from a topic name, validating it.

pub async fn set_named( &self, key: &str, body: Vec<u8>, ) -> Result<(), LaserError>

Write named point state: publish a keyed item to the topic (a record, like every memory write) and reflect it in the projection for read-your-writes.

pub async fn update_named( &self, key: &str, patch: Vec<u8>, ) -> Result<(), LaserError>

Merge-patch named point state (RFC 7386): read the current value, merge patch, and write the result back as one event.

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

Delete named point state: publish a keyed forget (a tombstone the managed backend applies as a delete) and drop it from the projection.

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

Read named point state, folding the topic first so a fresh handle sees what was written before it.

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

Read named point state by folding the topic in process, the opt-in path for small serverless scenarios. Prefer fetch_named, which reads the materialized key-value view.

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

Recall by folding the topic in process: read every memory record for the scope’s conversation off the log and return the most-recent items. This is the opt-in path for small, serverless scenarios with no managed read view. It does not scale: a large topic folds every record, so prefer the default recall, which reads the materialized key-value view.

Trait Implementations

impl Memory for LogMemory

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>