Agents forget.
Give yours a memory.

Name: Remem
Author: Remem

Self-hosted. No external database. Just Docker Compose. Built-in graph + full memory lifecycle. MCP-native from day one.

Get started — it's free View on GitHub

bash

# Up in 30 seconds
docker pull rememorg/remem-community:server-latest
docker compose up -d

# Prebuilt binaries: coming soon

Rust · self-hosted

Why agents keep starting from scratch

Three problems. One root cause: memory was never designed into the agent stack.

Your agent resets on every run

Every session starts from zero.

Your agent cannot remember that this user prefers bullet points over prose. That they already asked this question last week. That the task it completed on Tuesday connects directly to what it's being asked today. Context windows close. Sessions end. The agent that spoke to your user ten minutes ago is gone.

Connections are invisible

Facts don't live in isolation — but your agent can't see the threads.

A customer mentions their team is restructuring, and three weeks ago they mentioned a budget freeze. An agent with real memory connects those dots automatically. A vector database retrieves the closest text chunk. It has no concept of the relationship between memories — so you end up writing your own graph layer.

Memory has no lifecycle

You add TTL logic yourself, forget to test it, and it becomes a prod bug.

Stale or irrelevant memories pollute recall. Real memory ages, decays, and sometimes disappears. Without a memory lifecycle — decay, expiration, reinforcement — your agent accumulates sludge. Every search gets noisier. Recall degrades. Your agent's memory should behave like memory, not like a database table.

Everything your agent needs to remember

Not a wrapper around a vector database. A purpose-built memory engine.

Zero-ops

One binary, zero external deps

Remem's core is a single Rust binary — REST API, storage engine, and MCP server (Streamable HTTP) all in one process. No PostgreSQL, no Neo4j, no Redis, no Qdrant. docker compose up and it's running. Works on localhost with no sign-up and no phone-home. Self-host on a $5 VPS or embed in your application.

Agent-first

MCP-native from the ground up

Eight MCP tools expose every memory operation as an LLM-optimised action. Works out of the box with Claude Desktop and any MCP-compatible agent framework. Tool descriptions, parameter schemas, and return formats were designed for how LLMs consume structured data — not how humans call REST APIs.

Memory that breathes

Memory lifecycle — the one thing nobody else has

Short-term TTL expiration. Automatic promotion to long-term on high access. Importance decay over time. Soft deletion and archiving. Background lifecycle tasks run inside the binary — no separate worker, no cron job. The longer you use it, the better search results stay.

Connections that emerge

Built-in relationship graph — free

Every stored memory triggers auto-discovery. The HNSW index finds semantically similar memories; edges are written to the CSR graph with typed relationships: related_to, caused_by, part_of. find_related traverses up to N hops. Mem0 charges $249/month for graph access. Remem includes it from day one.

Three modes, one API

Semantic + keyword + hybrid search

All-MiniLM-L6-v2 embeddings (384 dims) for semantic search. Inverted index for keyword. BM25 hybrid scoring for the best of both. Embeddings generated locally via fastembed — no external API, no per-query cost, no data leaving your infrastructure.

Production-grade

Production-hardened by default

OpenAPI spec included. Per-client rate limiting, Bearer auth, and health/readiness endpoints on by default, no extra config. X-Request-ID for distributed tracing. Structured JSON logs. Prometheus metrics and Grafana dashboards ship in the Business Edition.

Your choice of interface

Hackable via REST or MCP

Full REST API with OpenAPI spec served at /docs. Eight MCP tools for agent frameworks. Both surfaces are documented and stable. Build your own client in any language — no official SDK required.

From `store_memory` to insight in three steps

The full memory cycle — store, connect, retrieve — happens automatically.

Store

Your agent calls store_memory. Remem embeds the content locally, writes it to the LSM-tree, and dispatches auto-discovery in a background worker. The API returns in microseconds.

Connect

The background worker queries the HNSW index for semantically similar memories. Candidate pairs above threshold trigger edge creation in the CSR graph with typed relationships. The graph grows organically denser with every stored memory.

Retrieve

search_memories runs hybrid BM25 search and returns ranked results formatted for LLM consumption. find_related traverses the graph — surfacing memories connected but not semantically similar, discovering context you didn't know to search for.

import httpx

client = httpx.Client(
    base_url="http://localhost:4545",
    headers={"Authorization": "Bearer your-key"}
)

# Store what the agent learns
client.post("/api/v1/memories", json={
    "content": "User prefers concise bullet-point answers.",
    "memory_type": "long_term",
    "tags": ["preference", "communication"],
    "importance": 0.8
})

# Retrieve context before responding
results = client.post("/api/v1/memories/search", json={
    "query": "how does this user like to receive information?",
    "search_type": "hybrid",
    "limit": 5
}).json()

Why developers choose Remem

An honest side-by-side. Data from public documentation as of June 2026.

	Remem	Mem0	Zep	Qdrant
Deployment	Single binary, no deps	Docker + external vector DB	Docker + Neo4j	Docker
Language	Rust	Python	Go	Rust
MCP-native	✅	✗	✗	✗
Relationship graph	✅ Free	$249/mo Pro	✅ (temporal)	✗
Memory lifecycle	TTL · decay · promotion · archive	✗	Session summaries only	✗
Embedded storage	HNSW + CSR + LSM in-process	External only	PostgreSQL + Neo4j	✓ (vector only)
Self-host free tier	✅ Unlimited	10K memories	1K episodes	✅
License	FSL	Apache 2.0	Apache 2.0	Apache 2.0
OpenAPI spec	✅	✅	✅	✅
Local dev (no sign-up)	✅	✗ (cloud-first)	✅	✅

No sign-up. docker compose up and it works.Graph included free — Mem0 gates this behind $249/moOpenAPI spec + MCP tools — two integration paths, your choice

Up in 60 seconds

No account. No credit card. No external services.

bash

docker compose up -d

# Store a memory
curl -X POST http://localhost:4545/api/v1/memories \
  -H "Content-Type: application/json" \
  -d '{"content":"User prefers dark mode","memory_type":"long_term","tags":["ui"]}'

# Search
curl -X POST http://localhost:4545/api/v1/memories/search \
  -H "Content-Type: application/json" \
  -d '{"query":"user interface preferences","search_type":"hybrid"}'

Read the full quickstart →

Free to start. Paid when you scale.

The single-node version is not a trial. It's the full product.

Single Node

Recommended

Free

Forever. Self-hosted.

✓Full feature set: graph, lifecycle, MCP, semantic search
✓Single binary, no external dependencies
✓Self-hosted: Docker or bare metal
✓Unlimited memories (single node)
✓Community support (GitHub Issues)
✓License: FSL

Get started →

Multi-Node

Coming soon

On-prem or managed cloud.

✓Everything in single-node
✓Horizontal sharding and replication
✓HA failover
✓Centralised management backoffice
✓Enterprise auth (SSO / SAML)
✓Audit logs & SLA
✓Dedicated support
✓On-prem (Helm/K8s) or managed cloud

Agents forget.Give yours a memory.