Memory that thinks. Context that evolves. Instead of treating memory as a flat collection of isolated facts, Memind continuously extracts, organizes, and evolves knowledge from conversations and raw content into structured long-term memory.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.
Why Memind?
Agent memory is not just a search problem. It is a memory construction problem. Most memory systems can store fragments: a fact, a preference, a past message, or a retrieved snippet. But fragmented memory is still not understanding. An agent may know that the user uses Java 21, prefers stable tools, and is migrating a service, yet still fail to understand how those facts relate or how that context is changing over time. Memind is designed to turn scattered memory into evolving understanding. A useful memory system needs to preserve source context, extract durable facts, connect related knowledge, understand how things evolve, consolidate higher-level patterns, and still return concise context when the agent needs it. Memind is built around that full lifecycle.| Problem | Why it matters | How Memind addresses it |
|---|---|---|
| Source context gets lost | If a memory item is wrong or unclear, developers need to know where it came from. | Memind keeps Raw Data as the source layer and generates captions for searchable, inspectable source segments. |
| Flat facts do not explain relationships | Isolated facts cannot show how a user’s preferences, projects, tools, and decisions relate to each other. | Memind extracts structured Memory Items and connects them through the Item Graph using entities, aliases, mentions, item links, and co-occurrence. |
| Memory keeps growing but does not mature | Appending more facts makes retrieval noisier over time. The system needs consolidation. | Memind builds an Insight Tree that distills related items into LEAF,BRANCH, and ROOT insights. |
| Long-running topics are hard to follow | A project, preference, incident, or workflow may span many sessions and many memory items. | Memind derives Memory Threads to group related items into evolving topic-level projections. |
| Time changes meaning | A current plan, past decision, or future intent should not be treated like a timeless fact. | Memind stores temporal fields on memory items and uses temporal retrieval signals when queries contain time constraints. |
| Agents need their own operating memory | A coding or task agent should remember tool usage, durable instructions, reusable playbooks, and resolved problems. | Memind separates memory into USER and AGENT scopes with different categories for each. |
| Retrieval needs different levels of depth | Some queries need fast recall; others need reasoning, expansion, and reranking. | Memind provides SIMPLE retrieval for low-latency recall and DEEP retrieval for LLM-assisted search. |
| Memory must be inspectable | When retrieval feels wrong, developers need to see what was stored, how it was extracted, and why it was returned. | Memind provides Memind UI to inspect buffers, raw data, memory items, item graph, memory threads, insights, settings, and retrieval traces. |
What Memind does
Retain source context
Memind keeps the original source layer instead of only storing extracted facts. When conversations, files, tool calls, or other raw content enter Memind, they are normalized into Raw Data segments. Each segment can carry metadata such as source client, content type, occurrence time, and source references. Memind also generates captions so source segments remain searchable and easier to inspect later. This gives every memory a traceable origin.Extract structured memory
Memind converts raw input into structured Memory Items. Memory items are durable units such as user facts, preferences, events, tool experience, durable directives, reusable playbooks, resolved problems, and foresight. They are assigned a scope, category, content type, source reference, timestamp metadata, and vector index when applicable. This turns messy conversations into memory that agents can actually reuse.Connect fragmented knowledge
Memind links related memory items through the Item Graph. The graph captures entities, aliases, mentions, semantic links, temporal links, and co-occurrence relationships. This lets Memind understand that different memories may be connected even when they were extracted from different sessions or do not share the same wording. This is how Memind moves beyond isolated facts.Follow long-running topics
Memind derives Memory Threads from related items and graph signals. A thread can represent an evolving project, repeated user preference, recurring workflow, incident, investigation, or decision path. Threads make it easier to inspect how a topic develops over time and give retrieval another way to find related context. This helps long-running agent work stay coherent across sessions.Build higher-level understanding
Memind consolidates related memory into the Insight Tree. The Insight Tree progressively distills low-level memory intoLEAF, BRANCH, and ROOT insights. Leaves summarize local groups of items, branches combine patterns across groups, and roots represent higher-level understanding across dimensions.
This is where Memind turns accumulated memory into evolving context.
Retrieve the right context
Memind retrieves memory across multiple layers.SIMPLE retrieval is optimized for low-latency recall. It combines vector search, keyword search, temporal signals, graph assist, memory-thread assist, and result fusion.
DEEP retrieval is designed for harder queries. It adds LLM-assisted sufficiency checking, typed query expansion, graph assist, and optional reranking.
Retrieval can return insights, memory items, raw-data references, evidence, and debug traces, so agents receive useful context without needing the full memory history.
Inspect and operate memory
Memind Open Source includesmemind-server and Memind UI.
The server exposes memory ingestion, commit, retrieval, health, and admin APIs. Memind UI lets developers inspect buffers, raw data, memory items, item graph, memory threads, insight tree, runtime settings, and retrieval traces.
This makes Memind an inspectable memory runtime, not a black-box retrieval layer.