Parallel Memory MCP — Git skill for Claude Code

parallel-memory-mcp

A memory MCP server for agents that run in parallel — and a benchmark showing what the alternatives lose when they do.

Writes are serialised by SQLite, not by luck. Observations are mirrored into [graphify](https://github.com/Graphify-Labs/graphify) memory docs, so `graphify --update` and `graphify reflect` read them with no changes on their side.

The measurement

Twenty writes issued at once. `kept` is how many survived; every store reported success for all twenty, and none raised.

case	@modelcontextprotocol/server-memory	graphify memory docs	this repo
20 writes, strictly one at a time	20 / 20	—	20 / 20
20 distinct writes at once	1 / 20	20 / 20	20 / 20
same question, same instant	1 / 20	1 / 20	20 / 20
questions sharing a 50-char prefix	—	1 / 20	20 / 20
error responses / raised exceptions	0	0	0

Reproduce it yourself — see [`bench/`](bench/).

Why each number comes out that way

**server-memory** (v2026.8.31) loses almost everything the moment writes overlap. Every mutation is a whole-graph read-modify-write:

async createEntities(entities) {
    const graph = await this.loadGraph();   // read the entire file
    graph.entities.push(...newEntities);
    await this.saveGraph(graph);            // write the entire file back
}

There is no lock anywhere in the file. The write itself is atomic — a temp file plus `rename(2)`, and the source says so — but atomicity is not isolation. Two overlapping calls both load the same graph and the second one's save erases the first one's work. Nothing errors, because from each caller's side nothing went wrong. It is also stdio-only, so "just run one shared process" is not available as a workaround, and even a single agent issuing two tool calls concurrently hits it.

This is a reference implementation of the protocol. Read it as one.

**graphify** does much better, by construction: one markdo