Struct RememberBuilder 

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

Per-call builder returned by Client::remember.

Awaiting the builder writes the prompt as an episodic memory and returns the persisted row. The write is queue-backed: the returned row’s vector index entry is pending until the worker drains the embed job. Use Client::search for retrieval — remember no longer reads.

Examples

let written = client
    .remember("the user said hello", scope)
    .metadata(serde_json::json!({ "source": "chat" }))
    .await?;
println!("wrote pid={}", written.pid);

Attach a parsed event-time when the utterance references a specific moment:

let written = client
    .remember("the deployment happened Friday", scope)
    .event_at(deploy_time)
    .await?;

Implementations

impl<'a> RememberBuilder<'a>

pub fn metadata(self, metadata: Value) -> Self

Attaches arbitrary JSON metadata to the written memory.

The value is stored verbatim in the memories.metadata JSONB column and surfaces unchanged through Client::recall and Client::search. Operators viewing memories via the admin surface see the same value — do not put secrets in metadata.

Defaults to {} when unset, matching the column’s schema default.

pub fn event_at(self, event_at: impl Into<DateTime<FixedOffset>>) -> Self

Records the wall-clock time the event being remembered occurred.

Distinct from created_at (when memoir was told). Set this when the utterance carries a parseable date or time reference — the agent (or upstream parser) is responsible for resolving “last Friday” to an absolute moment before passing it here. Memoir does not parse the content for time references on this path; LLM-driven event-time extraction is a separate write path (ticket 0011).

Accepts any value convertible to DateTime<FixedOffset>, including DateTime<Utc>. Defaults to None when unset, which is the right value for memories whose content has no meaningful event-time (preferences, identity facts, atemporal observations).

Trait Implementations

impl<'a> IntoFuture for RememberBuilder<'a>

type Output = Result<Memory, ClientError>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = <RememberBuilder<'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.