MemCite Review: Agent Memory With Cited Sources

In short

MemCite is a Python package (pip install memcite) that gives coding agents a memory store where every remembered fact must cite where it came from — a file and line range, a git commit SHA, a URL, or a human note. Before a memory is served back to the agent, MemCite re-checks whether that source still says what it said. If the file changed, the memory is flagged stale and down-weighted instead of being fed to the model as fact. The design rule is blunt: no evidence, no memory. Calling add() without a citation raises an error.

It ships as a CLI (am), an MCP server for Claude Code and Cursor, a FastAPI REST server, and a LangChain retriever. Everything is local — SQLite with FTS5 in a .agentic-memory.db file in your repo. MIT licensed.

Two things the name obscures: despite the "memcite chatgpt" searches, this is not a ChatGPT extension — it is repo memory for coding agents. And as of July 2026 it is a brand-new single-maintainer project with no community around it yet.

What problem MemCite solves

Stale memory is worse than no memory.

A hallucination is usually detectable — the agent invents an API that doesn't exist, the import fails, you move on. Stale memory fails silently. Six weeks ago the agent correctly learned "auth tokens are validated in middleware/auth.py". Since then someone moved validation into a service layer. The memory is still there, still confidently retrieved, and the agent now writes a patch against a file that no longer does that job. Nothing errors. The diff looks plausible. You merge it.

Every memory system built on plain embeddings has this problem, because embeddings remember what was said, not whether it is still true. CLAUDE.md has it too — a file full of hand-written project facts that nobody re-verifies is a decaying asset, which is why our guide to structuring CLAUDE.md treats pruning as a maintenance chore rather than a one-off.

MemCite's bet is that memory should behave like a test suite: assertions with sources, re-run before you trust them.

How it works in practice

Every memory carries an evidence object. Four types:

• FileRef — a file plus optional line range. MemCite snapshots the content, so when lines shift it can fuzzily relocate the passage rather than crying stale over a whitespace change.
• GitCommitRef — checks the commit SHA still exists in the repo.
• URLRef — an HTTP reachability check against the cited page.
• ManualRef — a human note, always trusted, because sometimes the source is "the CTO said so in Slack".

On top of that sit the things that make it usable rather than academic: memories are typed (fact, rule, antipattern, preference, decision), scored for importance 0–3, optionally given a TTL so ephemeral notes expire, checked for conflicts against contradictory existing memories, and tracked for adoption so you can see whether the agent is actually using what it stored.

Retrieval is hybrid — SQLite FTS5 keyword search blended with TF-IDF embeddings, weighted 65/35 by default. Validation runs before results are returned, and memories with broken citations get deprioritised rather than deleted, so you can review them instead of losing them.

The CLI mirrors all of it: am add, am query, am validate, am list, am status, am watch (which reads new git commits and surfaces what may have gone stale), am delete.

Setting it up

Base install, then the extra you actually need:

pip install memcite          # core + CLI, Python 3.10+
pip install memcite[mcp]     # MCP server for Claude Code / Cursor
pip install memcite[api]     # FastAPI REST server (am-server)
pip install memcite[langchain]
pip install memcite[cjk]     # Chinese / Japanese / Korean tokenisation

For Claude Code, am claude-setup writes the config for you, or you can drop it into .mcp.json by hand the same way as any other server — see our walkthrough on connecting an MCP server to Claude Code if that file is new to you:

{
  "mcpServers": {
    "agentic-memory": {
      "command": "am-mcp",
      "args": ["--repo", "/path/to/your/project"]
    }
  }
}

That is the standard MCP server config shape, and it exposes ten tools to the agent — memory_add, memory_query, memory_search_context, memory_adopt, memory_validate, memory_compact, memory_metrics, memory_status, memory_list, memory_delete. No API key, nothing leaves the machine.

The piece worth wiring up on day one is the CI hook. MemCite ships a GitHub Action that runs validation on pull requests and fails the build when citations have gone stale. That inverts the usual dynamic: instead of discovering rot when an agent acts on it, the PR that causes the rot tells you.

How it compares to built-in memory

Read the table as scope, not ranking. ChatGPT's memory remembers you — preferences, tone, recurring context — and is managed for you. MemCite remembers a codebase and refuses to remember anything it can't point at. Those solve different problems, and if what you actually want is cross-chat memory inside the ChatGPT UI, MemCite is the wrong tool; use the built-in feature or a browser-extension product like MemoryPlugin.

Against CLAUDE.md, MemCite is complementary rather than competing. Keep conventions and standing instructions in the file where the agent always sees them; put verifiable per-fact knowledge — "this module owns retries", "we dropped the ORM here in commit abc123" — in MemCite where it can rot loudly. If you want a broader look at memory tooling for agents, the tools section of our arsenal covers the alternatives.

Where it falls short

This is where honesty matters more than enthusiasm, because the project is very new.

It is early. The GitHub repo was created in March 2026, reached version 1.0.1 on 5 June 2026, and as of late July 2026 has effectively no stars, no forks and a handful of open issues. That is not a criticism of the code — it is a statement about risk. There is no community to answer your question, no ecosystem of integrations, and a real chance of the project going quiet.

The published performance figures aren't benchmarks. The README quotes a 0.077s query and ~8–10 KB storage per memory — measured over six memories. That tells you the code isn't pathologically slow. It tells you nothing about how FTS5 plus TF-IDF behaves at ten thousand memories on a large monorepo. Assume you'll be the one finding out.

Validation checks the source, not the claim. The author states this plainly: if a memory's content is wrong but the cited file hasn't changed, MemCite reports it valid, with confidence. Citations catch drift, not error. A note that was wrong when written stays wrong and now carries a green checkmark. There's an optional content validator, but the default guarantee is narrower than "your memories are correct".

It adds discipline you have to actually keep. Every memory needs a citation, so casual capture is off the table by design. Teams that won't run am validate in CI will end up with a database of stale-flagged entries nobody reviews — the same rot, now with more machinery.

Privacy and where data lives

Everything is local. Memory goes into .agentic-memory.db, a SQLite file inside the repo you point it at. The MCP server runs on your machine and needs no API key. Search is FTS5 plus TF-IDF, so nothing is sent to an embedding API unless you deliberately install the embedding extra and configure it.

Two practical consequences. First, .agentic-memory.db will contain quotes from your source files — decide early whether it's committed (shared team memory, and now your snippets are in git history) or gitignored (per-developer memory, no sharing). Second, whatever your agent reads still goes to your model provider as context; MemCite governs what gets stored, not what gets sent.

FAQ

Does MemCite work with ChatGPT?

Not directly, despite what the search phrasing suggests. MemCite is distributed as a Python package with an MCP server aimed at Claude Code and Cursor, plus a REST API and a LangChain retriever. There's no ChatGPT browser extension. If you're running an agent that speaks MCP you can wire it in; if you want memory inside the ChatGPT web app, use OpenAI's built-in memory instead.

How is MemCite different from just using a vector database?

A vector store answers "what text is similar to this query". MemCite answers that and "is the source of this claim still saying the same thing". The citation requirement is enforced at write time — add() without evidence raises an error — and revalidation happens at read time. You could build this on top of a vector DB yourself; MemCite is that layer, pre-built and local.

What does MemCite cost?

Nothing. It's MIT licensed, installs from PyPI, stores data in local SQLite, and needs no API key for its default search path. The only cost is indirect: the tokens your agent spends reading retrieved memories, and your time maintaining them.

Should I use MemCite on a production project?

Cautiously. The code is small, readable and MIT licensed, and the local-only design means the blast radius is a SQLite file. But a project this young with no community traction is one you should be prepared to fork or replace. A reasonable trial: run it on one repo for a month with am validate in CI, and watch the adoption metrics to see whether your agent actually uses the memories before you roll it out further.

Does MemCite replace CLAUDE.md?

No. CLAUDE.md is instructions the agent always reads — conventions, commands, hard rules. MemCite is queryable facts with provenance that the agent pulls on demand. Keeping both, with the file kept short and the database carrying the volume, works better than forcing everything into either one.