Struct MemoryNode 

pub struct MemoryNode {

    pub id: MemoryId,
    pub agent_id: AgentId,
    pub user_id: UserId,
    pub memory_type: MemoryType,
    pub embedding: Embedding,
    pub content: String,
    pub created_at: Timestamp,
    pub accessed_at: Timestamp,
    pub access_count: u32,
    pub salience: Salience,
    pub confidence: Confidence,
    pub space_id: SpaceId,
    pub attributes: HashMap<String, AttributeValue>,
    pub tags: Vec<String>,
    pub valid_from: Option<Timestamp>,
    pub valid_until: Option<Timestamp>,
    pub context: Option<String>,
}

A memory node: the atomic unit of knowledge in MenteDB.

Combines vector embeddings, graph connections, temporal properties, and flexible attributes in a single primitive.

Fields

id: MemoryId

Unique identifier.

agent_id: AgentId

The agent that owns this memory.

user_id: UserId

The end user that owns this memory (orthogonal to agent_id).

A memory belongs to both a user and an agent; a scoped query sees it only when it is visible on both axes. Defaults to the nil (shared) user, both for new() and for data written before this field existed.

memory_type: MemoryType

Memory type classification.

embedding: Embedding

Embedding vector for semantic similarity search.

content: String

Human-readable content.

created_at: Timestamp

When this memory was created.

accessed_at: Timestamp

When this memory was last accessed.

access_count: u32

How many times this memory has been accessed.

salience: Salience

Current salience score (decays over time).

confidence: Confidence

Confidence in this memory’s accuracy.

space_id: SpaceId

The memory space this belongs to.

attributes: HashMap<String, AttributeValue>

Flexible key-value attributes.

tags: Vec<String>

Tags for bitmap indexing.

valid_from: Option<Timestamp>

When this fact became true in the real world. None means valid since creation.

valid_until: Option<Timestamp>

When this fact stopped being true. None means still valid.

context: Option<String>

Optional retrieval context, prepended to the content when the memory is indexed (BM25) and embedded, but NOT stored as part of the content the caller reads back. This is the contextual-retrieval hook: a short situating blurb the caller generates (for example “From a thread about the billing migration”) that makes an otherwise-ambiguous memory findable by terms it never literally contains. None indexes the content as-is.

Implementations

impl MemoryNode

pub fn new( agent_id: AgentId, memory_type: MemoryType, content: String, embedding: Embedding, ) -> Self

Create a new memory node with the given content and embedding.

pub fn with_user_id(self, user_id: UserId) -> Self

Set the owning end user, returning the node (builder style).

Parallels the agent_id constructor argument on the orthogonal user axis. Leave unset (nil) for shared/global memories.

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

Attach retrieval context (builder style). See MemoryNode::context.

pub fn indexed_text(&self) -> Cow<'_, str>

The text to index and embed: the context (when present) prefixed to the content, so retrieval matches on both while the stored content stays exactly what the caller wrote.

impl MemoryNode

pub fn is_valid_at(&self, at: Timestamp) -> bool

Returns true if this memory is temporally valid at the given timestamp.

pub fn invalidate(&mut self, at: Timestamp)

Mark this memory as no longer valid.

pub fn is_invalidated(&self) -> bool

Returns true if this memory has been invalidated.

Trait Implementations

impl Clone for MemoryNode

fn clone(&self) -> MemoryNode

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MemoryNode

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MemoryNode

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for MemoryNode

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.