Mentedb

Mentedb

Long-term memory for AI agents: one process_turn call stores each turn and returns the memories your next prompt needs.

76/100Safe BetFree planFreemium

Most memory layers are retrieval bolted onto a vector store; MenteDB does the harder part — deciding what is still true after a decision changes, and surfacing a rule when the agent actually performs the action it governs. Supersession, pain warnings and bi-temporal valid_from/valid_until queries are its real edge over dropping a context plugin on top of a vector database. The 70 KB AGENTS.md test (80 percent rule-following in context vs 100 percent from memory at 2 to 8 times fewer tokens, five trials per file) is the most concrete number a memory vendor has published. Go in expecting beta churn on the API and budget for an adapter.

Verified 1d ago · liveness 76/100 · cite: rightaichoice.com/tools/mentedb

Best for
  • Developers whose agents lose decisions and repeat mistakes across sessions
  • Teams carrying a large AGENTS.md or CLAUDE.md that costs tokens on every message
  • Builders who need contradiction detection and supersession when project decisions change
  • Claude Code and Cursor users who want persistent memory without changing clients
Not ideal for
  • Teams needing a general-purpose relational or NoSQL database for application data
  • Projects that only need key-value or plain vector persistence with no reconciliation
  • Anyone who cannot integrate an SDK, MCP server or self-hosted server
Visit Website

AdvancedSelf-host: install the engine via pip or cargo install mentedb-server (or Docker), wire your LLM key and the nightly maintenance schedule, then add one process_turn call — an afternoon for a developer. Cloud: get an mdb_ API key, call the REST endpoint and skip fact-extraction and maintenance infrastructure. MCP clients (Claude Code, Cursor, Gemini CLI) follow the per-tool setup in the docs andWeb · API · CLIAPI availableVerified 1d ago
Pricing
Free plan
FreemiumFree tier2 plans
Learning curve
Advanced
Self-host: install the engine via pip or cargo install mentedb-server (or Docker), wire your LLM key and the nightly maintenance schedule, then add one process_turn call — an afternoon for a developer. Cloud: get an mdb_ API key, call the REST endpoint and skip fact-extraction and maintenance infrastructure. MCP clients (Claude Code, Cursor, Gemini CLI) follow the per-tool setup in the docs and
Runs on
WebAPICLI
API available · 11 integrations
Who it's for
Claude Code power user with a 70 KB AGENTS.mdBackend engineer whose project switched databases mid-streamTeam running an existing OpenAI-compatible client
Live sentiment
Is Mentedb actually worth it?

We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.

  • Honest verdict, not marketing
  • Real pros & cons from real users
  • Attributed quotes with receipts
Run a free scan

3 free scans · no card needed

Skip it if

Skip MenteDB if you only need nearest-neighbour retrieval with no reconciliation and no interest in adopting a process_turn-style write/recall loop in your agent.

The 30-second take
Price reality

Self-hosting the Apache 2.0 Rust engine puts no per-turn vendor metering between you and the database, so your cost becomes your own infrastructure and LLM spend. The managed API removes that operational load in exchange for per-turn usage on the vendor's side. Compared with a general vector database plus a context plugin, you are paying for reconciliation either in engineering time (self-host) or in metered turns (cloud).

In short

Mentedb — Long-term memory for AI agents: one process_turn call stores each turn and returns the memories your next prompt needs. Best for Developers whose agents lose decisions and repeat mistakes across sessions, Teams carrying a large AGENTS.md or CLAUDE.md that costs tokens on every message, Builders who need contradiction detection and supersession when project decisions change. Free to use.

What's new in Mentedb

Checked yesterday

Across the latest 3 updates: 2 feature updates and 1 news mention.

What people actually say about Mentedb — is it worth it?

We ran a structured research pass across product reviews, community discussions, and post-purchase forum threads to surface the patterns vendors won't publish themselves. Below: the recurring strengths, the hidden costs people mention most, and the cohort that consistently regrets adopting this tool.

7 mentions across 3 sources (Hacker News, Bluesky, GitHub) · researched Jul 4, 2026.

47% positive53% critical

Average across the 3 sources that answered — each source counts once, not each post.

Recurring strengths
  • +Purpose-built in Rust for low-level control and performance.
  • +Supports contradiction detection and phantom memories for knowledge gaps.
  • +Offers temporal invalidation with bi-temporal timestamps.
  • +Speculative pre-assembly predicts queries to pre-build context windows.
  • +Semantic search via embeddings across sessions.
Recurring frustrations
  • −Beta stage with missing features and known bugs.
  • −O(n) scan overhead for memory recall, no HNSW integration yet.
  • −Topic canonicalization bug prevents Markov chain learning.
  • −Small community (102 stars) limits support and resources.
  • −Unclear if fully local or requires cloud service.
Patterns worth knowing
Innovative cognitive features are exciting but immature
Seen on Hacker News, GitHub
Performance issues with recall and index utilization
Seen on GitHub
Small but active developer community
Seen on GitHub
Learning curve
advancedProductive in ~A few hours
Hidden costs people mention
  • • No hidden costs reported; self-hosting may require cloud infrastructure for sync

Viability Score

76/100
Safe Bet

How well maintained and how widely used is Mentedb? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this

Recent activity
90
Traction
82
Site health
95
User sentiment
47
What the vendor publishes
60

Last calculated: October 2026

How we score →

Key Features

  • One process_turn call per turn: store the turn and get back memories for the next prompt
  • Automatic extraction of atomic facts, preferences, decisions and corrections on write
  • Contradiction detection flags inconsistent decisions when a project changes direction
  • Supersession resolves conflicting facts inside the database without a model call per write
  • Pain signals and pain warnings resurface past mistakes before the agent repeats them
  • Action rules tagged to the action they govern, fetched when the agent performs that action
  • Hybrid retrieval combining BM25, HNSW vector search and RRF fusion
  • Bi-temporal validity with valid_from/valid_until and point-in-time queries
  • Knowledge graph with entity links, deduplication, decay and community detection
  • Sleeptime enrichment pipeline extracts semantic facts, links entities and builds user profiles
  • Agent file ingestion for CLAUDE.md, AGENTS.md and .cursorrules with measured rule-following
  • MCP server plus Memory Router that swaps one base URL for any OpenAI- or Anthropic-compatible client
  • Claude Code hooks for automatic capture on every turn
  • Native SDKs for Rust, Python and TypeScript, REST API and MQL query language
  • Self-organizing sharding with gossip membership and single-writer lock handoff

About Mentedb

FreemiumAdvancedAPI availableWeb · API · CLI

MenteDB is a long-term memory database for AI agents, built as a purpose-made Rust storage engine rather than a wrapper around a vector database. You run it as a managed API with an mdb_ API key, or self-host the Apache 2.0 engine via pip, cargo install mentedb-server or Docker — the integration surface is the same either way. A single process_turn call per turn captures what was said, extracts atomic facts, preferences, decisions and corrections, and hands back a bounded, ranked memory set to drop into your next prompt. On write it deduplicates, resolves contradictions through supersession without spending a model call per write, decays stale beliefs and links everything into a knowledge graph with bi-temporal valid_from/valid_until stamps. Retrieval is hybrid — BM25 plus HNSW vector search fused with RRF — and a background sleeptime pipeline extracts semantic facts, detects communities and builds user profiles. The measured pitch is agent files: a 70 KB AGENTS.md held in context cost about 17,500 tokens per turn and the model followed 80 percent of its own rules; delivered from memory the same rules hit 100 percent at 2 to 8 times fewer tokens, across five trials per file on public agent files from OpenAI, Kiali and Temporal. It reports 92 percent on LongMemEval. Connections run through MCP (Claude Code, claude.ai, ChatGPT, Cursor, VS Code, Windsurf, Gemini CLI), a Memory Router that swaps one base URL for any OpenAI- or Anthropic-compatible client, and native Rust, Python and TypeScript SDKs.

Behind the Verdict

MenteDB's argument is that agent memory fails in two places: the agent cannot tell when a fact it holds has been superseded, and it cannot tell when a rule it holds applies. The product answers both with named machinery. Supersession resolves conflicting facts inside the database — you told it Postgres last month and MySQL this month — without spending a model call on every write to decide which one wins. Action rules tag each rule to the action it governs and fetch it when the agent performs that action, rather than keying retrieval on the current conversation, which is why a rule can arrive at the moment it matters instead of scrolling past in a prompt. The storage is its own: a Rust engine with HNSW vector search, a knowledge graph, BM25 + HNSW retrieval fused with RRF, and bi-temporal valid_from/valid_until stamps so you can ask what the system believed on a given date. Around that sit sixteen core systems on the vendor's count — sleeptime enrichment, stream processing, write inference, trajectory tracking, phantom memories for knowledge gaps, interference shielding, pain signals — plus a Memory Router that swaps one base URL so any OpenAI- or Anthropic-compatible client gets persistent memory with your provider key passed through untouched. Where it earns its keep is agent files. The vendor measured the 70 KB ceiling on real public AGENTS.md files from OpenAI, Kiali and Temporal: fully in context, about 17,500 tokens per turn and 80 percent of the file's own rules followed; from memory, 100 percent at 2 to 8 times fewer tokens, at flat cost per turn however large the file grows. That is a vendor measurement across five trials per file, not an independent study — treat it as a strong hypothesis, not a settled result. Weaknesses are real. It is beta and Apache 2.0 with the vendor's own warning that features and the API may change, so integration means adopting the process_turn loop behind an adapter you control rather than pointing an existing vector database at a new endpoint. Self-hosting puts the data, the LLM key and the nightly maintenance schedule on you, and cross-device sync is a cloud-mode feature a single-machine self-hosted setup does not get. The Codex Router is still listed as in development. For teams that want plain vector persistence with no reconciliation, the contradiction machinery is overhead.

Researching Mentedb? Get your full AI stack in 60 seconds.

Free, no signup — tell us your goal and get tools matched to your budget & existing stack.

Real-world workflow fit

Concrete scenarios for the personas Mentedb actually fits — and what changes day-one when you adopt it.

Claude Code power user with a 70 KB AGENTS.md

Ingest the AGENTS.md once, then let the Claude Code hook run process_turn on every turn so rules and corrections land in memory instead of riding in the prompt.

Outcome: The model receives the rules that govern the action it is performing, at the vendored measurement of 100 percent rule-following at 2 to 8 times fewer tokens than carrying the file.

Backend engineer whose project switched databases mid-stream

Turns mentioning Postgres and later turns mentioning MySQL stream in through process_turn; supersession resolves the conflict inside MenteDB without a per-write model call.

Outcome: The agent stops quoting a stale decision, and you can audit what was believed on any date with a valid_from/valid_until point-in-time query.

Team running an existing OpenAI-compatible client

Point the client at the Memory Router base URL instead of the provider's; context is injected before the model responds and every turn captured after.

Outcome: Persistent memory arrives without a client rewrite, and your provider key passes through untouched.

Use Cases

  • Ingest a 70 KB AGENTS.md once and have its rules arrive when they matter, at 2 to 8 times fewer tokens than carrying the file every turn.
  • Catch the moment you told the agent Postgres last month and MySQL this month, instead of discovering the contradiction after a deploy.
  • Resurface a recorded anti-pattern at the moment the agent is about to repeat it.
  • Ask 'what did we decide about auth?' and get the answer via embeddings even when you use different words than the original turn.
  • Keep a laptop and desktop on the same agent memory through cloud sync.
  • Add persistent memory to an existing OpenAI- or Anthropic-compatible client by swapping one base URL with the Memory Router.
  • Run point-in-time queries against what the system believed on a given date using valid_from/valid_until.
  • Build a Slack or Telegram chat bot that remembers prior conversations across sessions.

Models Under the Hood

GPT-5.5

as of 2026-10-15

Limitations

  • MenteDB is in beta and Apache-2.0 open source, and the docs state plainly that features and the API may change as it matures — write integrations behind an adapter you control.
  • Integration means adopting the process_turn loop rather than pointing an existing vector database at a new endpoint.
  • Self-hosting puts responsibility for the data, the LLM key and the nightly maintenance schedule on you.
  • The headline benchmark (80 percent rule-following from a 70 KB AGENTS.md in context versus 100 percent from memory at 2 to 8 times fewer tokens) is the vendor's own measurement on three public agent files across five trials per file, not an independent study.
  • Cross-device sync is a cloud-mode feature, so a fully self-hosted single-machine setup does not get it.
  • The Codex Router is still listed as in development.

as of 2026-10-17

Verification history

We have re-verified Mentedb 8 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.

  1. — re-checked, vendor evidence unchanged
  2. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  3. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  4. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  5. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  6. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it

Showing the 6 most recent of 8 verification passes.

Free to cite with attribution — this page re-verifies continuously.

12-month cost

Project the real annual outlay, including the implied monthly cost when only an annual tier is published.

Annual total
Free
Over 12 months
Effective monthly
Free
Billed monthly

Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.

Plans compared

For each published Mentedb tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.

Beta

$0/mo

Ideal for

Developers who want managed memory without running infrastructure — an mdb_ API key, the process_turn endpoint, MCP connections and agent file ingestion with cloud sync.

What this tier adds

Starting entry point on the managed side: hosted API, MCP connections to Claude Code, ChatGPT, Cursor and Gemini CLI, and cross-device cloud sync.

Self-host

$0/mo

Ideal for

Engineers who need the memory database on their own infrastructure and can own the data, the LLM key and the nightly maintenance schedule.

What this tier adds

Same process_turn API contract as the hosted path, but on the Apache 2.0 Rust engine installed via pip, with no per-turn vendor metering.

Where the pricing makes sense

The company stage and team size where Mentedb's pricing actually pencils out — and where peers do it cheaper.

Self-hosting the Apache 2.0 Rust engine puts no per-turn vendor metering between you and the database, so your cost becomes your own infrastructure and LLM spend. The managed API removes that operational load in exchange for per-turn usage on the vendor's side. Compared with a general vector database plus a context plugin, you are paying for reconciliation either in engineering time (self-host) or in metered turns (cloud).

Setup time & first value

How long it actually takes to get something useful out of Mentedb — broken out by persona, not the marketing-page minute.

Self-host: install the engine via pip or cargo install mentedb-server (or Docker), wire your LLM key and the nightly maintenance schedule, then add one process_turn call — an afternoon for a developer. Cloud: get an mdb_ API key, call the REST endpoint and skip fact-extraction and maintenance infrastructure. MCP clients (Claude Code, Cursor, Gemini CLI) follow the per-tool setup in the docs and

Switching to or from Mentedb

How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.

Migrating in
  • →From a CLAUDE.md or AGENTS.md carried in context: ingest the file once with agent file ingestion, then re-ingest to keep memory in sync as you keep editing it.
  • →From a vector store plus context plugin: replace nearest-neighbour retrieval with the process_turn capture/reconcile/recall loop so contradictions get resolved, not just fetched.
  • →From an OpenAI- or Anthropic-compatible client with no memory: swap one base URL to the Memory Router and leave the rest of the client alone.
Migrating out
  • ↗To a plain vector database: MenteDB exposes structured export and MQL, so stored memories can be pulled out; you lose supersession and action-rule surfacing.
  • ↗To a self-hosted deployment: run the same process_turn contract on the Apache 2.0 Rust engine and move off the managed API.
  • ↗To another memory layer: because the integration is a single process_turn loop, keep it behind an adapter and the swap is contained to that boundary.

Integrations

Claude Codeclaude.aiClaude CoworkChatGPTCursorVS CodeWindsurfGemini CLIOpenAI SDKAnthropic SDKAWS Bedrock

Resources & Guides

Tutorials & Learning

YouTube returned 6 videos for “Mentedb”, and we withheld 6: 6 could not be judged, because “Mentedb” is a single word that other videos use for other things. We are showing none, because we could not prove any of them are about Mentedb.

Official links

Tools that pair well with Mentedb

Common stack mates teams adopt alongside Mentedb, with the specific reason each pairing earns its keep.

Featured Head-to-Head Comparisons

Alternatives to Mentedb

View all
Mem0

Mem0

Mem0 is an AI memory layer that gives agents and apps persistent context across sessions

FreemiumTry
Cognee

Cognee

Cognee is an open-source AI agent memory platform that stores facts in a knowledge graph and returns cited recall across sessions.

FreemiumTry
Mempalace

Mempalace

Open-source local-first AI memory that stores every conversation verbatim in a method-of-loci palace on your machine.

FreeTry

Frequently Asked Questions

Used Mentedb? Help shape our editorial sentiment research.