Use cases

Memory that manages facts, shown in real conversations

Not industry brochures. Below are the exact moments where a real memory layer changes the conversation, each one a shipped feature.

Coding agents

Remembers your stack and updates its mind when you change yours.

We're on Postgres, and I want Result types for errors, not exceptions.
Got it — Postgres with Result-based error handling.
New session, three days later
Switch the prototype to SQLite.
Moving the prototype from Postgres to SQLite. I'll drop the Postgres-only queries we set up.
Contradiction caught — the old “Postgres” belief is replaced, not stored alongside the new one.

The call behind it

python
from mentedb import MenteDBClient
mem = MenteDBClient(api_key="mdb_...")

# First session — the agent_id ties this memory together
mem.process_turn(
    user_message="We're on Postgres, I want Result types for errors.",
    agent_id="coding-agent",
)

# Days later, a brand-new session
turn = mem.process_turn(
    user_message="Switch the prototype to SQLite.",
    agent_id="coding-agent",
)
turn.context                # recalls your stack from the earlier session
turn.contradiction_details  # flags Postgres -> SQLite

It carried your stack across a session break and reconciled the change instead of holding two conflicting facts. Ask it “what did we decide as of last sprint” and point-in-time recall answers exactly.

Cross-session recallContradiction detectionAS OF point-in-timeMCP: Claude Code, Cursor, Copilot

Large agent files

Your 70 KB AGENTS.md becomes memories that arrive when they matter.

70 KB AGENTS.md ingested once, weeks earlier
Add a Refresh button to the toolbar component.
Done. The label goes through t() since every user visible string in this repo must be translatable.
The task never mentioned translation. The rule arrived from memory because the draft contained a hardcoded label.

The call behind it

python
# Keep editing the file as always; re-running ingest keeps memory
# in sync: new rules stored, edited rules replaced, deleted rules removed.
report = mem.ingest_agent_file(open("AGENTS.md").read())
# 606 memories, 96 action triggers, 0 pinned to every prompt

turn = mem.process_turn(
    user_message="Add a Refresh button to the toolbar component.",
    agent_id="coding-agent",
)
turn.context   # the handful of rules that govern this exact change

Measured on four real public agent files: 100 percent of tested rules followed at 2 to 8 times fewer tokens than carrying the file every turn. The 70 KB file carried whole followed only 80 percent of its own rules. Instruction cost stays flat no matter how large the file grows.

One call ingestionRules arrive on relevanceAction triggersFlat cost per turn

Customer support

Knows the customer before the first reply, and never mixes them up.

Returning customer, brand-new chat
My CSV export is failing again.
You hit the same export timeout last month on your Pro plan and we raised your row limit then. Let me check whether it regressed rather than starting over.
Recalled from past tickets on the first message. No “please re-explain your issue.”

The call behind it

python
# user_id keys memory per customer — isolated from every other customer
turn = mem.process_turn(
    user_message="My CSV export is failing again.",
    user_id="cust_8f21",
)
turn.context   # past tickets, plan, prior fixes — from the first message

Memory is keyed per customer and isolated in the engine, so the bot has their full history from message one, and one customer's context can never surface in another's chat.

Per-user isolationFirst-message recallContradiction detectionBounded, deterministic context

Personal assistants

Surfaces what matters, not just what you searched for.

Find me somewhere for dinner Friday.
You're vegetarian and loved that Thai place by your office, want me to book there? Heads up, it's also your parents' anniversary that weekend.
Profile (vegetarian) plus a fact it surfaced proactively, that you didn't ask for.

The call behind it

python
turn = mem.process_turn(
    user_message="Find me somewhere for dinner Friday.",
    user_id="alex",
)
turn.context            # profile facts (vegetarian) + linked places
turn.proactive_recalls  # surfaced without being asked (the anniversary)

It distills durable facts about you, links the people and places you mention into a graph, and injects what's relevant. Decay keeps recent, reinforced facts on top without ever deleting your curated knowledge.

User profileProactive recallEntity resolutionDecay with reinforcement

Multi-agent systems

Share what agents should, isolate what they shouldn't.

[Researcher agent] stored: Competitor X raised a $50M Series B (source: TechCrunch).
[Writer agent] Using the shared finding on Competitor X's raise. I can read shared knowledge but not the researcher's private scratchpad.
Per-agent scope: shared facts flow between agents, private context stays isolated, enforced in the engine.

The call behind it

python
# Researcher writes under its own agent_id
mem.process_turn(
    user_message="Competitor X raised a $50M Series B.",
    agent_id="researcher",
)

# Writer recalls shared knowledge + its own, never the researcher's notes
turn = mem.process_turn(
    user_message="Draft the market update.",
    agent_id="writer",
)
turn.context   # shared findings only, not the researcher's scratchpad

Each agent recalls its own memories plus what's explicitly shared. Collaboration without cross-contamination, and without a routing mistake ever leaking one agent's context into another's.

Per-agent scopingProject scopesShared knowledgeEngine-enforced isolation

Why this isn't just search over a vector store

Every example above leans on behavior a similarity search can't give you.

Reconciles, not just recalls

When a new fact contradicts an old one, MenteDB updates the belief instead of returning both. Your agent never argues with a stale version of the truth.

Reasons about time

Every memory carries a validity window. Ask what was true as of any past moment and get exactly that, including facts later superseded.

Notices, not just stores

Seven cognitive checks run per turn: interference between competing memories, pain signals on repeated frustration, phantom-memory guards, and more. Signals a vector store can't produce.

One call wires memory into any of these

Send a conversation turn, get back the right context plus what was learned. Start free in the cloud or self-host the open-source engine.

Get startedRead the docs