Skip to main content
Memory Items are Memind’s structured memory units. They are extracted from Raw Data and represent what should be remembered: durable facts, preferences, events, directives, tool experience, playbooks, resolutions, and optional foresight. Raw Data preserves the source context. Memory Items turn that context into reusable memory.
Memory Item Flow

​
Overview

A Memory Item is not a raw message, a text chunk, or a source document. It is a structured memory unit extracted from source context. Each item is concise enough to retrieve and reuse, but still linked back to the Raw Data that produced it. Memory Items help Memind answer:
What should be remembered from this source context?
This is the bridge between source evidence and usable memory.

​
Why Memory Items exist

Raw Data is useful because it preserves context, but it is still close to the original source. Agents usually need a more compact and durable form of memory. They need to know the user’s stable preferences, current projects, past decisions, tool experience, reusable workflows, and resolved problems without reading the full source context every time. Memory Items provide that layer. They let Memind:
  • extract durable memory from broader source context
  • separate user memory from agent operating memory
  • classify memory into meaningful categories
  • preserve temporal meaning when memory is time-bound
  • extract optional foresight for likely future needs
  • deduplicate repeated facts
  • index structured memory for retrieval
  • connect items through the Item Graph
  • group items into Memory Threads
  • consolidate items into Insights
In short:

​
Extraction flow

Memory Item extraction starts from Raw Data. At a high level, the flow is:
Each step has a specific role. The important point is that Memory Items are extracted from source context, not isolated text snippets. Raw Data captions help provide the broader background behind extraction, so the model can understand the situation that produced the item.

​
Memory Item records

A Memory Item stores structured information about one durable memory unit. Conceptually, it contains: You usually do not need to manipulate these fields directly. They describe how Memind stores memory so it can be searched, traced, connected, and consolidated.

​
Scopes

Memind separates memory into two scopes: USER and AGENT. This distinction matters because agent memory is not only user profiling. A useful agent should remember the user, but it should also remember its own operating experience: durable instructions, tool behavior, reusable task patterns, and past resolutions.

​
Categories

Each Memory Item belongs to a category. Categories give memory structure. They help Memind filter, group, retrieve, connect, and consolidate items.

​
USER categories

Examples:

​
AGENT categories

Examples: A content processor can restrict which categories are allowed for a given input type. This keeps extraction focused on memory that is meaningful for that source.

​
Item types

Memory Items can have different item types. Most items are FACT items. They describe something that is true, happened, is happening, or should be reused. FORESIGHT items are different. They capture useful future-facing signals that may help the agent prepare for what the user is likely to need next.

​
Foresight items

Foresight lets Memind store forward-looking memory. A FORESIGHT item is not a confirmed fact in the same way a FACT item is. It is a predictive or anticipatory memory derived from conversation signals. For example, if a user repeatedly discusses migrating a Java service, stabilizing tooling, and preparing documentation, Memind may infer foresight such as:
Foresight is useful when an agent should not only remember what already happened, but also prepare for likely next steps. Typical foresight signals include:
  • upcoming user needs
  • likely follow-up tasks
  • possible project risks
  • expected tool usage
  • preparation hints for future sessions
  • inferred next-step context
Foresight should be used carefully. It is meant to help the agent anticipate, not to overwrite facts or make unsupported assumptions. A good foresight item should be: In practice:
FORESIGHT extraction is optional and depends on runtime configuration.

​
Temporal information

Not every memory has the same relationship to time. Some memory is stable:
Some memory is time-bound:
Some memory describes a past decision:
Memory Items can preserve temporal fields such as: Temporal information helps Memind distinguish stable user profile, current project state, past events, and future plans. It also gives retrieval a way to reason about time-sensitive memory.

​
Source references

A Memory Item should not be disconnected from its origin. Each item can keep a rawDataId that links it back to the Raw Data record that produced it. This matters because Raw Data carries the broader source context behind the item:
The item gives a concise memory. The Raw Data caption gives the context behind it. This lets developers inspect:
  • where the item came from
  • what source segment produced it
  • what topic context surrounded it
  • whether extraction was accurate
  • whether the item should be kept, corrected, or ignored
Source references make Memory Items explainable.

​
Deduplication

Memory systems can easily grow noisy if they keep appending the same fact. Memind uses content fingerprints to help detect repeated items. Deduplication helps avoid cases like:
Instead of endlessly growing repeated memory, Memind can skip or merge duplicated information depending on the extraction and storage behavior. This keeps the item layer cleaner and makes retrieval less noisy.

​
Indexing

Memory Items are searchable. After extraction, item content can be embedded and stored in a vector index. The item keeps a vectorId so it can participate in semantic retrieval. This is separate from Raw Data and Insight indexing. This separation lets Memind retrieve at different levels:
  • source evidence from Raw Data
  • durable structured memory from Memory Items
  • higher-level patterns from Insights

​
Relationship to other layers

Memory Items are the foundation for several later layers. This is why item quality matters. If items are too noisy, too vague, or disconnected from source context, the graph, threads, insights, and retrieval results become weaker.

​
Inspecting Memory Items

Memind UI lets developers inspect Memory Items. This is useful when you want to understand:
  • what memory was extracted
  • which scope and category were assigned
  • whether temporal fields were normalized correctly
  • which Raw Data record produced the item
  • whether the item has a vector index reference
  • what metadata was attached
  • whether repeated memory is being deduplicated
  • how items connect to downstream graph, thread, and insight layers
Inspecting Memory Items is one of the fastest ways to debug memory quality.

​
Common use cases

Memory Items support several common agent memory workflows.

​
Design principle

Memory Items turn source context into reusable memory. They should be concise enough to retrieve, structured enough to connect, and traceable enough to inspect. Raw Data preserves the background. Memory Items capture what should be remembered. Together, they let Memind avoid the two common extremes of memory systems: raw transcript storage with no structure, or isolated extracted facts with no context.