Memory Construction

Documentation Index

Fetch the complete documentation index at: https://docs.openmemind.com/llms.txt

Use this file to discover all available pages before exploring further.

​

Overview

Memind does not treat memory as a list of text snippets. When new information enters the system, Memind progressively transforms it into a layered memory state: Raw input -> context boundary -> normalized content -> Raw Data -> Memory Items -> Item Graph -> Memory Threads -> Insight Tree Each stage adds a different kind of structure. The result is not a flat vector collection. It is a constructed memory state that keeps source evidence, structured facts, relationships, topic continuity, and higher-level understanding together.

​

Input sources

Memory construction starts with raw information. Typical input sources include:

• conversation messages
• streaming chat messages
• files
• URLs
• tool output
• custom application content

These inputs may come from Java applications, agent integrations, memind-server, or other systems that write memory into Memind. At this point, Memind has not decided what should become durable memory. The input is still raw material.

​

Intake mode

Memind supports different intake modes because applications produce memory in different ways. Batch and raw-content inputs can usually move directly into normalization. Streaming chat needs one additional step: Memind must decide when the conversation has enough context to extract useful memory.

​

Context boundary

For streaming chat, extracting memory from every single message is usually too noisy. A single message may not contain enough context. It may depend on previous turns, or it may only become meaningful once the user and agent finish a small topic. Memind uses a context boundary stage to handle this. The runtime keeps:

• pending messages
• recent messages
• source metadata
• conversation context

When new messages arrive, Memind checks whether the pending conversation should be committed. If the answer is no, the message stays in the buffer and Memind waits for more context. If the answer is yes, Memind seals the current conversation segment and sends it into the construction pipeline. This stage answers an important question:

When is there enough context to extract memory?

Applications can also commit manually when they already know a conversation boundary has been reached.

​

Content normalization

After Memind has an input segment, it normalizes the content before construction begins. Content normalization prepares different input types for the same memory pipeline. This stage can include:

• resolving the content type
• applying metadata
• parsing files or URLs
• fetching external resources
• applying raw-data plugins
• preparing an extraction request

The goal is to make conversations, files, URLs, tool outputs, and custom content usable by the same downstream construction stages. This is also where Memind’s extension points matter. Content parsers, resource fetchers, and raw-data plugins allow applications to add new ingestion behavior without changing the core memory model.

​

Raw Data construction

Raw Data is the source and evidence layer. Before Memind extracts higher-level memory, it preserves the original source context in a more inspectable form. Raw Data construction can include:

• segmenting source content
• generating captions
• preserving metadata
• keeping source references
• indexing source captions

The output is Raw Data. Raw Data is important because extracted memory needs traceability. If a memory item looks wrong, incomplete, or surprising, developers should be able to inspect where it came from. Raw Data answers:

What source information did Memind observe?

It is not the final memory layer. It is the source layer that makes the rest of the memory system inspectable.

​

Memory Item extraction

Memory Items are structured units of durable memory. After Raw Data is built, Memind extracts memory items from the source segments. A Memory Item may represent:

• a user fact
• a preference
• an event
• a durable directive
• tool experience
• a reusable playbook
• a resolved problem
• optional foresight

During this stage, Memind can also assign:

• USER or AGENT scope
• memory category
• content type
• source reference
• temporal information
• vector index information

Memory Item extraction can also deduplicate items so the system does not simply accumulate repeated facts forever. This stage answers:

What durable memory should be kept from the source?

Memory Items are the foundation for later layers. The Item Graph, Memory Threads, Insight Tree, and Retrieval all depend on useful structured items.

​

Item Graph update

The Item Graph connects fragmented memory. Without a graph, memory items remain isolated. An agent may know several facts, but still fail to understand how they relate. The Item Graph update stage connects items through signals such as:

• entities
• aliases
• mentions
• semantic links
• temporal links
• causal links
• co-occurrence

This lets Memind connect memory across different sessions, different wording, and related concepts. For example, two items may not use the same exact phrase, but they may mention the same project, tool, repository, user preference, incident, or decision path. The graph gives Memind a way to connect those fragments. This stage answers:

How are these memory items related?

The Item Graph is one of the main reasons Memind can move beyond flat fact storage.

​

Memory Thread projection

Memory Threads track long-running topics. Some memory should not be understood as isolated facts. Projects, workflows, incidents, investigations, decisions, and recurring preferences often span many sessions and many memory items. Memory Thread projection groups related items into evolving topic-level projections. A thread can represent:

• a project
• a workflow
• an incident
• an investigation
• a decision path
• a recurring user preference
• a repeated agent behavior

Threads help Memind understand continuity. They answer:

What ongoing topic does this memory belong to?

This layer is configurable. Depending on runtime settings, Memory Threads may be enabled or disabled, and thread derivation may run synchronously or asynchronously.

​

Insight Tree consolidation

The Insight Tree is the consolidation layer. As memory grows, simply storing more items is not enough. The system needs a way to mature memory into higher-level understanding. Memind consolidates related memory into an Insight Tree:

• LEAF insights summarize local groups of memory.
• BRANCH insights combine patterns across groups.
• ROOT insights represent broader understanding.

This stage can include:

• grouping related memory
• generating insight points
• building LEAF insights
• merging into BRANCH insights
• consolidating into ROOT insights
• reorganizing the tree as memory changes

The Insight Tree answers:

What higher-level understanding can be derived from accumulated memory?

This is where Memind turns memory growth into memory evolution.

​

Persisted memory state

The output of Memory Construction is a layered memory state. It can include: This state can be inspected through Memind UI and used later by retrieval. The important point is that memory construction does not produce one object. It produces a connected memory system.

​

Supporting services

Several services support the construction pipeline. These services support memory construction, but they are not the memory model themselves. The memory model is the layered result: Raw Data, Memory Items, Item Graph, Memory Threads, and Insight Tree.

​

Why this flow matters

Memory construction is the core of Memind’s design. A flat memory store usually appends fragments and retrieves similar text later. Memind takes a different approach. It preserves source evidence, extracts structured memory, connects related knowledge, follows long-running topics, and consolidates higher-level understanding. That is why Memind memory can evolve over time instead of only growing.