Graph-based long-term memory that makes your agents actually intelligent. Remember facts, track decisions, discover connections — across sessions, forever.
Works with every agent framework
You spend 20 minutes explaining your project to an AI agent. Tomorrow, it has no idea who you are. This isn't a minor inconvenience — it's the single biggest bottleneck in agent intelligence.
"I already told you I prefer TypeScript." Sound familiar? Without persistent memory, every conversation starts from zero. Users get frustrated. Agents look dumb.
Your agent made a critical decision on Tuesday. By Wednesday, it's gone. Project details, architecture choices, people's names — evaporated. The agent can't learn if it can't remember.
"Why did we choose PostgreSQL over MongoDB?" A human would know. Your agent draws a blank. Without decision history, agents repeat mistakes and ignore lessons learned.
"Giving an AI agent a vector database for memory is like giving a human a filing cabinet full of sticky notes — technically storage, but not really memory."
Other tools remember text. MemTap remembers relationships.
Vector databases find similar text. That's useful, but it's not memory. Real memory understands that "chose PostgreSQL" is connected to "billing project", which has a "deadline of March 30", which was "decided by Alex".
MemTap stores memories as typed nodes connected by typed edges in a knowledge graph powered by ArangoDB. When your agent recalls something, it doesn't just get the top-N similar results — it traverses the graph to discover context that keyword search would never find.
8 memory types. 7 edge types. Automatic entity extraction. Zero manual wiring.
Eight integrated capabilities that turn forgetful agents into intelligent ones.
BM25 fulltext search with importance weighting and confidence scoring. Finds relevant memories across all types, ranked by what matters most right now. No embeddings required — works out of the box.
The killer feature. Combines vector embeddings, BM25 fulltext search, and multi-hop graph traversal in a single query. Discovers memories that are logically connected but textually different — things pure similarity search would miss entirely.
An LLM watches your agent's conversations and automatically extracts facts, decisions, preferences, and entities. No manual remember calls needed. Agents learn from every interaction without being told to.
First-class support for decisions with options, context, deadlines, and outcomes. Create a decision, defer it with a reason, or resolve it with the chosen option. Never lose the "why" behind a choice again.
Memory decay makes old unaccessed memories fade naturally (configurable rate, 10% floor — nothing fully disappears). Contradiction detection flags conflicting facts. Deduplication merges near-identical memories. Your knowledge graph stays clean automatically.
Inspect the structure of your agent's knowledge. Find orphan memories with no connections, discover topic clusters, trace paths between any two memories, and get global stats on your knowledge graph's health.
People, projects, companies, devices, and locations are automatically extracted from memories and linked as graph nodes. Navigate your agent's knowledge through the people and things it mentions — not just keyword matches.
Each agent gets its own memory scope, but memories can be shared across your agent fleet. A research agent discovers a fact, and your coding agent can recall it. Scoped by default, shared when needed.
Get up and running in under five minutes. One Docker command, one config line, and your agents have persistent memory.
One command deploys the MemTap server and ArangoDB. Nothing else to install.
Add the plugin to your agent config. Works with OpenClaw natively, or use the REST API with any framework.
Memories are captured automatically from conversations. Context persists across sessions, forever.
Seven tools your agent calls directly. Full REST API for custom integrations. Every response includes graph context.
We built MemTap because existing solutions were missing the graph layer. Here's how the landscape looks.
| Feature | MemTap | Mem0 | Zep | Graphiti | Vector DBs | Flat Files |
|---|---|---|---|---|---|---|
| Semantic search | BM25 + vectors | Vectors | Vectors + temporal | Vectors | Vectors | grep |
| Knowledge graph | Native (ArangoDB) | No | Partial | Native (Neo4j) | No | No |
| Typed memories | 8 types | Untyped | Sessions + facts | Episodes + entities | Untyped | Untyped |
| Typed edge relationships | 7 types | No | No | Temporal edges | No | No |
| Entity extraction | Automatic | No | Automatic | Automatic | No | Manual |
| GraphRAG | BM25 + vector + BFS | No | No | Vector + graph | No | No |
| Contradiction detection | Automatic | No | No | No | No | No |
| Decision tracking | Built-in | No | No | No | No | Manual |
| Memory decay | Configurable | No | Temporal | Temporal | No | No |
| Self-hosted | Docker | Yes + Cloud | Cloud-first | Yes | Cloud only | Yes |
| Open source | Apache 2.0 | Apache 2.0 | MIT (CE) | Apache 2.0 | No | N/A |
| Paid tier starts at | €19/mo | $99/mo | $99/mo | Free (OSS) | ~$70/mo | Free |
Every tier includes self-hosted deployment. Your data never leaves your infrastructure.
For individual developers
For serious agent builders
For teams and organizations
| Feature | Free | Pro | Enterprise |
|---|---|---|---|
| Memories | 500 | 10,000 | Unlimited |
| Agents | 1 | 10 | Unlimited |
| BM25 fulltext search | ✓ | ✓ | ✓ |
| 8 memory types | ✓ | ✓ | ✓ |
| Entity linking | ✓ | ✓ | ✓ |
| Decision tracking | ✓ | ✓ | ✓ |
| REST API | ✓ | ✓ | ✓ |
| Knowledge graph (basic) | ✓ | ✓ | ✓ |
| GraphRAG (vector + graph) | — | ✓ | ✓ |
| Memory decay reports | — | ✓ | ✓ |
| Contradiction detection | — | ✓ | ✓ |
| Deduplication scanning | — | ✓ | ✓ |
| Advanced graph traversal | — | ✓ | ✓ |
| Custom integrations | — | — | ✓ |
| SSO & audit logging | — | — | ✓ |
| SLA guarantee | — | — | ✓ |
| Support | Community | Priority email | Dedicated |
Vector databases store embeddings and return similar results. MemTap adds a knowledge graph layer — memories are connected through typed relationships (CAUSED_BY, UPDATES, CONTRADICTS, etc.). This means your agent can traverse connections and discover related information that pure similarity search would miss. It's the difference between "find similar text" and "understand how things relate."
Everything runs on your infrastructure. MemTap uses ArangoDB as its backend, deployed via Docker Compose alongside the MemTap server. Your memories, graphs, and embeddings never leave your machines. No cloud dependency, no third-party data sharing.
Yes — self-hosting is the default and recommended deployment. MemTap is designed to run on your own infrastructure via Docker Compose. There is no hosted/cloud version. You own your data completely.
Yes. Pro includes a 7-day free trial with full access to all Pro features including GraphRAG, memory maintenance, and advanced graph traversal. No credit card required to start.
MemTap ships with a native OpenClaw plugin (7 tools + 2 hooks), but the REST API works with any agent framework. LangChain, CrewAI, AutoGPT, Claude Code, or your custom agent — if it can make HTTP requests, it can use MemTap.
No. MemTap works out of the box with BM25 fulltext search — no embedding model required. For semantic similarity search and GraphRAG, you can optionally connect any OpenAI-compatible embedding API, including local models. The free tier works perfectly without embeddings.
Memories naturally lose importance over time, just like human memory. The decay rate is configurable (default: 0.5% per day) with a floor of 10% — nothing is ever fully forgotten. Accessing a memory resets its decay clock. This ensures recent, important memories surface first while older ones gracefully fade unless reinforced.
Yes. Export your existing memories and POST them to MemTap's REST API. The graph relationships and entity linking will be auto-generated from your imported data, immediately enriching your existing knowledge base. Migration guides are available in the docs.
At 500 memories, new writes are blocked but all existing memories remain fully searchable and accessible. You can archive old memories to free up space, or upgrade to Pro for 10,000 memories. Your data is never deleted.
Yes. MemTap is backed by ArangoDB, a battle-tested multi-model database used in production by major enterprises. The server includes health checks, graceful error handling, Ed25519-signed license validation, and automated maintenance. Docker Compose makes deployment reproducible and reliable.
Start with 500 free memories. No credit card. No cloud lock-in. Deploy in under 5 minutes.