memind

🏆 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 openai client 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 the same 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 has two AI configuration layers:

The default server configuration defines one chat client and one embedding client:

memind:
  ai:
    chat:
      default-client: openai
      clients:
        openai:
          provider: openai
    embedding:
      client: opena