← All posts
announcementarchitecture

Introducing Remem: persistent memory for AI agents

·1 min read·Remem Team

Every time a user opens a new conversation with your AI agent, it starts from nothing. It doesn’t know that this user prefers short answers. It doesn’t remember the task they finished last week or the context they shared last month. The conversation closes, and everything is lost.

The standard fix is to stuff context into the system prompt. But context windows have limits, and sheer volume of context is not the same as structured memory. What agents need is a real memory layer — one that persists across sessions, understands relationships between memories, and knows when to forget.

That’s what we built.

What Remem is

Remem is a memory engine for AI agents. Its core is a single Rust service, remem-server — REST API, storage engine, and MCP server (Streamable HTTP at /mcp) all in one process — with no external database dependency. No PostgreSQL, no Neo4j, no Redis, no separate vector store. docker compose up and it’s running.

Under the hood, five storage layers work together in-process inside remem-server:

  • HNSW vector index — approximate nearest-neighbour search over 384-dimension embeddings generated locally via fastembed (all-MiniLM-L6-v2). No external embedding API, no per-query cost.
  • CSR relationship graph — a compressed sparse row graph that stores typed edges between memories, such as related_to, caused_by, and contradicts. Updated automatically as memories are stored.
  • BTree — time-windowed range queries.
  • Inverted tag index — tag-based lookup with soft-delete support.
  • LSM-tree key-value store — durable, write-ahead-logged storage for memory payloads and metadata.

All five layers are embedded in the same remem-server process. No network hops for internal storage operations.

Memory lifecycle

Most memory systems are static: you write, you read. Remem adds a lifecycle.

  • Short-term memories expire via TTL. Good for session context, task state, anything that loses relevance quickly.
  • Promotion to long-term happens manually (call promote_to_longterm), automatically at creation time for high-arousal “flashbulb” memories, or automatically when a short-term memory’s TTL expires with a high enough access count.
  • Long-term memories decay in importance over time if unused (~0.5%/day). Every memory also has a health score that decays daily and is boosted by recall — a form of active forgetting that hard-deletes memories nobody looks at.
  • Archiving soft-deletes a memory — it’s removed from search but retained for audit. Hard delete is available too.

Background lifecycle tasks run inside remem-server on their own schedules — no separate worker process needed.

The relationship graph

When you store a memory, Remem doesn’t just write it to the index. It dispatches an auto-discovery job that queries the HNSW index for semantically similar memories, then writes edges between related pairs into the CSR graph.

The result: every stored memory automatically discovers connections to other memories. As the graph grows, find_related traversals surface context your agent didn’t know to search for — multi-hop inference from what it knows.

Mem0 charges $249/month for graph access. Remem includes it in the free tier.

MCP-native from day one

Remem exposes eight MCP tools designed for LLM consumption:

  • store_memory — store a new memory with type, tags, importance
  • search_memories — semantic, keyword, or hybrid search
  • get_memory — retrieve a specific memory by ID
  • update_memory — modify content or metadata
  • delete_memory — soft or hard delete
  • find_related — graph traversal from a starting memory
  • promote_to_longterm — manually promote a short-term memory
  • list_recent_memories — recently created or accessed memories

Three MCP resources: memory://stats, memory://collections/recent, memory://collections/important.

Works out of the box with Claude Desktop. Any MCP-compatible agent framework connects the same way.

Get started in 30 seconds

Terminal window
docker pull rememorg/remem-community:server-latest
docker compose up -d

The quickstart walks through your first stored memory and first search query. No account needed — just set REMEM_API_KEY (or explicitly opt out with REMEM_ALLOW_AUTH_DISABLED=true for local dev).

We’re releasing the single-node version today under the Functional Source License. You can use it freely, self-host it, and build commercial products on top of it. The one restriction: you can’t operate it as a competing managed service.

→ Read the quickstart