The state and context database
for persistent AI agents.
Preserve facts, relationships, lifecycle, and context across sessions. Self-host the Go-based, Pebble-backed service with MCP and REST interfaces.
# Build and start Remem 0.5
git clone https://github.com/remem-org/remem-community.git
cd remem-community
cp .env.example .env
docker compose up --build -d
Go and self-hostedPersistent agents need durable context
Remem treats agent context as persistent state with relationships, history, and lifecycle.
Conversation history is not durable state
Context windows close, but the work continues.
An agent needs more than a transcript. It needs durable preferences, decisions, observations, and task context that remain available across sessions without forcing users to repeat themselves.
Similarity alone misses the state behind a decision
Agents need relationships, sequence, and provenance.
A relevant text fragment is not always enough. Persistent agents need to connect facts, trace how a state changed, and understand why a decision was made. Those are data-management problems, not only embedding problems.
State changes and stale context causes errors
Bad memory can be worse than no memory.
Outdated or irrelevant context can lead an agent to act on a resolved issue or obsolete instruction. Lifecycle controls such as expiration, decay, promotion, and deletion make retention an explicit database concern.
State and context capabilities for persistent agents
A focused, self-hosted foundation for agent context that must survive beyond one session.
One self-hosted service
Remem combines its REST API, Pebble-backed storage, and MCP server in one Go service. Run it locally or on your own infrastructure without PostgreSQL, Neo4j, Redis, or a separate vector database.
Interfaces for agents and applications
MCP tools give compatible agent runtimes a structured way to store and retrieve context. A documented REST API and OpenAPI specification support application integrations in any language.
Lifecycle is a core data capability
Use TTL expiration, importance decay, promotion to long-term memory, soft deletion, and archiving to keep context relevant as the agent and its environment change.
Relationships are first-class
Remem can discover related memories and store typed graph connections. Agents can traverse those connections to retrieve context that a similarity query alone would not reveal.
Multiple retrieval paths
Use semantic, keyword, and hybrid retrieval through one API. Local embeddings, graph connections, and embedded indexes keep retrieval close to the data and under your operational control.
Built for trustworthy operation
Durable writes, background jobs, migrations, repair workflows, authentication, rate limiting, readiness endpoints, and structured logs support dependable single-node operation.
A foundation for agent state
Remem is built around the direction persistent agents require: facts, relationships, time, lifecycle, and structured state. The Go 0.5 foundation keeps the core focused while leaving room for multi-tenant and horizontally scaled deployments.
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 durably to Pebble, and dispatches relationship discovery in a background job. The API returns without waiting for graph enrichment.
Connect
A background job finds semantically related memories and creates typed connections. The graph grows organically as the corpus grows, without adding another service to operate.
Retrieve
search_memories supports semantic, keyword, and hybrid retrieval with consistent ranking. find_related traverses the graph and surfaces context a similarity query alone would miss.
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.",
"policy": "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()A durable foundation, from local development to production
Remem keeps the capabilities that make agent state useful in the core product and reserves future commercial editions for operating that foundation at scale.
Keep the data model capable
Core retrieval, graph relationships, lifecycle controls, APIs, and logical namespaces belong in the Community Edition. Developers should be able to build serious products on one node.
Charge for operating at organisational scale
Multi-node clustering, replication, high availability, enterprise tenancy, access control, audit, and fleet management are operational capabilities for a future Enterprise Edition.
Use one product foundation
The edition boundary should be operational rather than a forked data engine. This gives developers a clear path from local experimentation to production infrastructure.
Up in 60 seconds
No account. No credit card. No external services.
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","policy":"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"}'Build locally. Operate at scale.
Community provides the complete single-node foundation. Future commercial editions focus on operating it across an organisation.
Community
RecommendedFree
Single node. Self-hosted.
- Single-node agent-state database
- Vector, graph, keyword, and hybrid retrieval
- Memory lifecycle and logical namespaces
- MCP, REST API, and local persistence
- Self-hosted with capacity set by your hardware
- Community support (GitHub Issues)
- Apache 2.0 license
Enterprise
Coming soon
Multi-node operation for production infrastructure.
- Everything in Community
- Replication, clustering, and horizontal scaling
- High availability and failover
- Enterprise tenancy and resource controls
- RBAC, SSO, audit, and compliance controls
- Control plane, backup, and disaster recovery
- Dedicated support and SLA