Memind

Memory that thinks. Context that evolves.

The memory layer that lets AI systems learn from every conversation, tool call, document, and resolved task.

Memind turns raw context into structured memory and reusable experience, continuously organizes it into memory graphs, threads, and evolving Insight Trees, then recalls the right context through REST, MCP, SDKs, and first-party plugins for popular agents.

Highlights · Quick Start · Integrations · Benchmark

🏆 Highlights

Memind achieves state-of-the-art results across all three mainstream long-memory benchmarks: LoCoMo, LongMemEval, and PersonaMem.

• ☕ The first Java-native SOTA memory and context engine for AI agents: built natively in Java, memind brings benchmark-leading long-memory performance into the Java ecosystem.
• 🚀 Highest reported results across all three benchmarks: under aligned MemOS / EverMemOS-style evaluation, memind ranks #1 among the listed baselines on LoCoMo, LongMemEval, and PersonaMem, surpassing EverMemOS on LoCoMo and LongMemEval and exceeding MemOS on PersonaMem. See Benchmark for full scores, category-level comparisons, context tokens, and evaluation protocol.
• 🧩 One memory engine for users and agents: memind separates USER memory from AGENT memory, letting the same system remember user profiles, preferences, and life context while also preserving agent directives, tool experience, playbooks, and resolved-task knowledge across coding agents, local harness agents, chatbots, companions, copilots, and workflow agents.
• 🌳 Insight Tree turns memory into evolving intelligence: instead of storing isolated facts, memind continuously distills raw memories into Leaf → Branch → Root insights, revealing patterns, preferences, causal signals, and high-level understanding that flat memory cannot capture. See docs.openmemind.com.
• 🔎 Multi-layer retrieval recalls the right context: memind retrieves across Insight Trees, Memory Items, raw source data, Memory Graphs, Memory Threads, vector search, BM25 keyword search, temporal signals, and optional Deep Retrieval with query expansion, sufficiency checking, and reranking.
• 📥 Memory for every kind of context: memind can ingest conversations, documents, images, audio, tool calls, and agent timelines, then uses typed processors, parsers, chunkers, captioners, and plugin-specific extraction strategies to turn them into searchable memory.
• 🕸️ Memory Graph connects scattered context: memind materializes entities, mentions, semantic links, temporal links, causal links, aliases, and co-occurrence signals from extracted memories, then uses graph expansion to recover related context that pure vector similarity can miss.
• 🧵 Memory Thread preserves evolving tasks and episodes: memind groups related memory items into durable threads with timeline events, memberships, lifecycle state, enrichment, and retrieval-time thread assist, helping agents continue unfinished work and reuse resolved task history.

Overview

What is Memind?

Memind is an open-source, self-evolving memory and context engine for AI applications and agents.

It is not a vector-store wrapper. Memind captures raw context from conversations, documents, images, audio, tool calls, agent timelines, and resolved tasks, then turns it into structured user memory, reusable agent experience, evolving insights, connected memory graphs, and task-aware memory threads.

At retrieval time, Memind assembles the right context across these memory layers and exposes it through REST APIs, HTTP MCP tools, SDKs, Java runtime APIs, and first-party agent integrations.

How Memind Works

Memind keeps the raw source, extracted memory, structured understanding, graph relationships, and task timelines connected. This lets AI systems retrieve both precise evidence and higher-level context instead of relying on flat snippets alone.

Use Memind for

Memind is a general memory and context layer for almost any AI system that needs long-term context. Common use cases include:

These are only examples. Memind can also support copilots, enterprise assistants, support automation, research tools, knowledge workers, and any AI application that needs to remember users, tasks, documents, decisions, tools, timelines, and previous outcomes across sessions.

For deeper architecture, configuration, rawdata plugins, MCP tools, SDKs, and agent integrations, see docs.openmemind.com.

Quick Start

Choose the path that matches how you want to use Memind:

• Docker Compose (Recommended): start memind-server and the admin UI with one command.
• Local development: run memind-server and memind-ui directly from source.
• Embedded Java runtime: run Memind inside your own Java or Spring Boot application.

Option 1: Docker Compose (Recommended)

Prerequisites

• Docker with the Compose plugin
• A model provider key for the chat and embedding models you want to use

Configure .env

Create a local .env file:

cp .env.example .env

For the default setup, edit these values first:

OPENAI_API_KEY=your-api-key
OPENAI_BASE_URL=https://openrouter.ai/api
OPENAI_CHAT_MODEL=openai/gpt-4o-mini
OPENAI_EMBEDDING_MODEL=openai/text-embedding-3-small

The default Spring AI OpenAI configuration can point to OpenAI or any OpenAI-compatible endpoint by changing OPENAI_BASE_URL and the model names. OpenRouter, DeepSeek, GLM, SiliconFlow, and similar providers can be used through Spring AI's OpenAI provider path when they expose an OpenAI-compatible API.

Model names are provider-specific. The default values use OpenRouter-style model names. If you use OpenAI directly, use OpenAI model names such as gpt-4o-mini and text-embedding-3-small.

Start Memind

docker compose up -d --build

After the containers start:

• Admin UI: http://localhost:8080
• Server health check: http://localhost:8366/open/v1/health
• Open API base path: http://localhost:8366/open/v1
• Admin API base path: http://localhost:8366/admin/v1
• HTTP MCP endpoint: http://localhost:8366/mcp

Verify

curl http://localhost:8366/open/v1/health

The health endpoint verifies that the server is running. Model credentials are validated when Memind performs extraction, retrieval, embedding, or rerank calls.

The UI container proxies /open/* and /admin/* to memind-server, so the browser can use the UI as a same-origin local admin console.

Common commands

# View logs
docker compose logs -f memind-server
docker compose logs -f memind-ui

# Stop containers but keep persisted memory data
docker compose down

# Stop containers and remove persisted memory data
docker compose down -v

By default, memind-server stores SQLite data and the fallback file vector store in the Docker volume memind-data, mounted at /app/data inside the container.

The Compose setup is intended for local development and inspection. The admin UI has no built-in authentication, so do not expose it directly to public networks.

memind:
  ai:
    chat:
      default: openAiChatModel
    embedding:
      default: openAiEmbeddingModel

memind:
  ai:
    chat:
      default: defaultChatClient
      slots:
        ITEM_EXTRACTION: extractionChatClient
        INSIGHT_GENERATOR: reasoningChatClient
        THREAD_ENRICHMENT: threadEnrichmentChatClient
    embedding:
      default: openAiEmbeddingModel

docker compose up -d --build

Option 2: Local Development

Use this path when you want to develop Memind itself or run the server and UI directly from source.

Prerequisites

• Java 21
• Maven
• Node.js 20.19+ or 22+
• pnpm
• A valid model provider key

Start memind-server

OPENAI_API_KEY=your-key \
mvn -pl memind-server -am spring-boot:run

The server starts at:

• Server health check: http://localhost:8366/open/v1/health
• Open API base path: http://localhost:8366/open/v1
• Admin API base path: http://localhost:8366/admin/v1
• HTTP MCP endpoint: http://localhost:8366/mcp

Start memind-ui

In another terminal:

cd memind-ui
pnpm install
pnpm dev

The Vite dev server starts at http://localhost:5173 and proxies /admin/* requests to memind-server on port 8366.

Option 3: Embedded Java Runtime

Use this path when you want Memind as an in-process Java memory engine instead of calling a separate memind-server.

Add dependencies

Import the Memind BOM first, then add the core runtime, the Spring AI plugin, and one JDBC dialect plugin.

The dependency snippet below shows the plain-Java path. For Spring Boot, use memind-plugin-ai-spring-ai-starter, memind-plugin-jdbc-starter, and Spring configuration.

For the default SQLite setup:

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>com.openmemind.ai</groupId>
      <artifactId>memind-dependencies</artifactId>
      <version>0.2.0</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

<dependencies>
  <dependency>
    <groupId>com.openmemind.ai</groupId>
    <artifactId>memind-core</artifactId>
  </dependency>
  <dependency>
    <groupId>com.openmemind.ai</groupId>
    <artifactId>memind-plugin-ai-spring-ai</artifactId>
  </dependency>
  <dependency>
    <groupId>com.openmemind.ai</groupId>
    <artifactId>memind-plugin-jdbc-sqlite</artifactId>
  </dependency>
</dependencies>

If you use MySQL or PostgreSQL, replace memind-plugin-jdbc-sqlite with memind-plugin-jdbc-mysql or memind-plugin-jdbc-postgresql.

Minimal usage

Once the Memory runtime is assembled, the core API is small:

var memoryId = DefaultMemoryId.of("user-1", "my-agent");

// messages = your conversation history
memory.addMessages(memoryId, messages).block();

var retrieval = memory.retrieve(
        memoryId,
        "What does the user prefer?",
        RetrievalConfig.Strategy.SIMPLE).block();

For a complete plain-Java runtime assembly with centralized defaults, start with ExampleSettings.java.

Full runnable Java examples

The maintained Java examples live in memind-examples/memind-example-java.

Run the default quickstart example:

OPENAI_API_KEY=your-key \
mvn -pl memind-examples/memind-example-java -am -DskipTests \
  -Dexec.mainClass=com.openmemind.ai.memory.example.java.quickstart.QuickStartExample \
  exec:java

Integrations

Memind can be integrated through first-party agent plugins, SDKs, REST APIs, or the built-in HTTP MCP server. Choose the path that matches where your AI system runs.

Connect Memind to Any Agent

Use first-party integrations when you want Memind to automatically recall context, inject memory, and capture agent activity across sessions.

Memind provides official integrations for popular agents:

• Claude Code: persistent project memory, session-start continuity context, tool-aware context injection, and coding-agent timeline ingestion.
• Codex: persistent project memory, prompt/tool context injection, retry-backed timeline ingestion, and source tagging for Codex sessions.
• OpenClaw: prompt-time Memind recall plus completed OpenClaw agent activity ingestion as agent_timeline raw data.
• Hermes: a native Hermes memory provider that retrieves relevant context before turns and captures completed Hermes activity after responses.

SDKs and REST APIs

Use SDKs and REST APIs when you want to connect Memind to an application, backend service, chatbot, workflow system, or custom agent.

Open API base path:

http://localhost:8366/open/v1

Official API clients:

• TypeScript: memind-clients/typescript
• Python: memind-clients/python
• Java: memind-clients/java
• Go: github.com/openmemind/memind/memind-clients/go
• Rust: memind-clients/rust

Use REST or SDK clients when your system already runs its own application process and wants Memind as a memory service.

Open API ingestion semantics

The default ingestion endpoints (/open/v1/memory/extract, /open/v1/memory/add-message, and /open/v1/memory/commit) are fire-and-forget: a successful HTTP response means Memind accepted and dispatched the work, not that extraction completed. Retry-aware clients should use /open/v1/memory/sync/extract with a caller-owned raw-content payload and clear their local retry state only when the returned extraction status is SUCCESS.

/open/v1/memory/sync/add-message and /open/v1/memory/sync/commit report immediate server-buffer success or failure, but they are not durable replay boundaries because the server owns the buffered conversation state.

HTTP MCP Server

Use MCP when your agent supports Model Context Protocol and should call Memind as a tool server.

memind-server includes a stateless HTTP MCP server at /mcp, enabled by default. It exposes Memind memory tools for MCP-compatible agents and uses the same runtime, database, configuration, and logs as the REST APIs.

Claude Code can connect to the local server with:

claude mcp add --transport http memind http://localhost:8366/mcp

Default MCP tools:

• Retrieval and context: memind_compile_context, memind_retrieve, memind_recent.
• Write flows: memind_extract_text, memind_extract_rawdata, memind_add_message, memind_commit.
• Memory item inspection: memind_items_search, memind_items_get, memind_items_sources.
• Rawdata inspection: memind_rawdata_search, memind_rawdata_get.

Use memind_compile_context when an agent needs a concise, sectioned context pack. Use memind_retrieve when it needs the structured retrieval response. Use memind_extract_text for one-off text memory, memind_extract_rawdata for typed rawdata payloads, and memind_add_message followed by memind_commit for conversation-style memory.

The optional governance tool memind_forget is disabled by default. Enable it with MEMIND_MCP_GOVERNANCE_ENABLED=true; it defaults to dry-run mode, requires a non-blank reason, and deletes only ITEM or RAWDATA records that match the supplied userId and agentId.

To disable the MCP endpoint, set MEMIND_MCP_ENABLED=false before starting memind-server.

Do not expose /mcp directly to public networks without an authentication gateway or equivalent network controls. MCP tools can read and write scoped memory.

Benchmark

Memind is evaluated on three mainstream long-memory benchmarks: LoCoMo, LongMemEval, and PersonaMem.

Evaluation protocol: benchmark responses are evaluated with GPT-4o-mini under the LLM-as-a-Judge setup used by MemOS and EverMemOS. Baseline results are reproduced or quoted from published systems under aligned settings where possible.

Summary

Memind ranks #1 among the listed baselines on all three benchmarks under aligned MemOS / EverMemOS-style evaluation, while keeping retrieved context compact enough for production agent workflows.

Deltas in the Memind row compare against the best non-Memind score in the same metric column. Context Tokens are reported as average retrieved context per answered question.

Detailed Results

LoCoMo

Takeaway: Memind achieves the highest LoCoMo overall score in this comparison, with strong open-domain QA performance and lower context usage than EverMemOS.

LongMemEval

Takeaway: Memind achieves the highest LongMemEval overall score in this comparison, with clear gains on multi-session and temporal-reasoning tasks.

PersonaMem

Memind Category-Level Results on PersonaMem

Takeaway: Memind achieves the highest PersonaMem score in this comparison, especially on preference-aligned recommendations, user-shared fact recall, and reasoning over prior updates.

export OPENAI_API_KEY=your-key
export OPENAI_BASE_URL=your-base-url
export OPENAI_CHAT_MODEL=openai/gpt-4o-mini

export EMBEDDING_API_KEY=your-key
export EMBEDDING_BASE_URL=your-base-url
export OPENAI_EMBEDDING_MODEL=openai/text-embedding-3-small

export RERANK_BASE_URL=your-rerank-base-url
export RERANK_API_KEY=your-rerank-key
export RERANK_MODEL=jina-reranker-v3

mvn -pl memind-evaluation -am -DskipTests spring-boot:run \
  -Dspring-boot.run.profiles=locomo \
  -Dspring-boot.run.arguments="--evaluation.run-name=locomo-readme --evaluation.stages=add,search,answer,evaluate --evaluation.clean-groups=true"

mvn -pl memind-evaluation -am -DskipTests spring-boot:run \
  -Dspring-boot.run.profiles=longmemeval \
  -Dspring-boot.run.arguments="--evaluation.run-name=longmemeval-readme --evaluation.stages=add,search,answer,evaluate --evaluation.clean-groups=true"

mvn -pl memind-evaluation -am -DskipTests spring-boot:run \
  -Dspring-boot.run.profiles=personamem \
  -Dspring-boot.run.arguments="--evaluation.run-name=personamem-readme --evaluation.stages=add,search,answer,evaluate --evaluation.clean-groups=true"

mvn -pl memind-evaluation -am -DskipTests spring-boot:run \
  -Dspring-boot.run.profiles=locomo \
  -Dspring-boot.run.arguments="--evaluation.run-name=locomo-smoke --evaluation.stages=add,search,answer,evaluate --evaluation.smoke=true --evaluation.from-conv=0 --evaluation.to-conv=1 --evaluation.clean-groups=true"

Contributing

Contributions are welcome! Feel free to open an issue or submit a pull request.

Community

• LINUX DO

License

Apache License 2.0