Memory Hive

Apiary Memory MCP

At a glance

Two entry points — and they are not the same

python -m hive_mcp does not work — this package has no __main__.py.

The pip package has no GUI and never pops a dialog. When an agent calls propose, the entry goes into a local candidate queue and stays there. Nothing enters the hive until a human runs apiary-memory-cli list and then approve . If you want a window, use the macOS or iOS app.

Not to be confused with

Also known as: Apiary Memory · 记忆蜂巢 · Memory Hive · 蜂巢 ·

apiary-memory on PyPI · io.github.330899935/apiary-memory on the MCP Registry (from v0.2.0).

Your agents can search what you have confirmed and propose what they think you should keep; only you can confirm it. Everything lives in one file on your own disk, and nothing is sent anywhere.

It runs on its own. A working SQLite memory store ships inside this package — no account, no cloud, no daemon, no dependencies.

pip install apiary-memory

Desktop app, no terminal: download apiary-memory-0.2.1.mcpb and double-click it.

Measured on 2026-10-27, on one MacBook with the Hive running locally — script and raw output in bench/:

*Retrieval used each entry's own title as the query — an easy set. It shows the index is complete and ranks correctly on exact terms, not how well it answers a question asked in your own words. Run bench/bench_search.py on your own Hive.*

What you get without the app

A complete, if modest, memory server. On a machine with nothing else installed:

Storage is SQLite at ~/.memory-hive/hive.db by default. Search is lexical — character bigrams for Chinese, words for Latin script — so it ranks well when the words overlap and finds nothing when they do not. There are no embeddings and no vector index. Every response says "mode": "local" so you can always tell which engine answered.

Without the app, the database is plain SQLite: it is not encrypted. That is stated here rather than discovered later — see Honest limits.

What the app adds

Apiary Memory for macOS is the same design with the expensive parts built: eight vaults with four of them locked behind a PIN (Argon2id-wrapped key, AES-256 at rest), a daily evolution log, multi-agent identity management, and a UI for reading and confirming. It also answers MCP itself, with richer ranking.

If the app is running, this package uses it and leaves the local file alone. If it is not, the local store answers. You do not have to choose up front:

One rule holds in every mode: if the app is running and answers with an error, that error is returned unchanged. Falling back on a refusal would write your memory into a second database while your client believed it had reached the app. Silent data forking is worse than an error message, so a reply from the app is final. The fallback fires on a connection failure, and on nothing else.

Measured on the app

The numbers below come from the macOS app's local HTTP service on one MacBook — not from this package's SQLite store, which is a different engine over a different dataset. Mixing the two would be the usual benchmark trick, so they are kept apart.

Measured 2026-10-29 against the live service. The hit-rate queries were each entry's own title — the easy case. It shows the index is complete; it does not show that free-form questions land. A separate pilot using plainly-phrased questions found the right entry in the top 5 only twice out of roughly a dozen, which is the biggest known weakness of this version.

The four encrypted vaults are excluded from the count because they are unreadable by design. A load test at 1,000,000 synthetic entries gave 0.6 s warm search, 5.3 GB RSS and a 1.0 GB index — see bench/ for the script and raw output.

Install

pip install apiary-memory        # the server: apiary-memory (was memory-hive-mcp)

the human's CLI: apiary-memory-cli (was memory-hive-mcp-cli)

Python 3.8 or newer. There is nothing else to install — the package uses only the standard library, and sqlite3 is part of it.

From a checkout:

git clone https://github.com/330899935/apiary-memory

cd apiary-memory PYTHONPATH=src python -m hive_mcp.stdio

Connect a client

Any MCP host that can run a stdio command will work. The minimum is the command; everything else is optional.

Claude Desktop — ~/Library/Application Support/Claude/claude_desktop_config.json:

{

"mcpServers": { "apiary-memory": { "command": "apiary-memory", "env": { "HIVE_MODE": "local" } } } }

Cursor — ~/.cursor/mcp.json, same mcpServers shape.

Any host that only speaks HTTP — start the app and point it at http://127.0.0.1:8768/mcp with the headers X-Hive-Agent and X-Hive-Token. This package is the stdio path; the HTTP endpoint belongs to the app.

Two ways to connect

There are two doors onto the same memory. Which one you use depends on where your AI runs, not on what it can do.

Behind both doors is the same home: what a local AI stores today, a web AI can read tomorrow — and the other way round. Swap in a hundred AIs; there is still one memory, and it is on your disk.

The web (HTTP) door

An AI running on the web cannot reach your Mac. So the Desktop app opens a channel outwards. In the app, open AI Connect · Web (HTTP), pick one of three levels, and copy the address:

If local works, do not open a tunnel. That is what the app tells you, and it is our advice here too: if local is enough, do not open the door onto the street.

Three things to know before you connect:

1. Once connected, the AI can read your memory. It gets what it asks for, within what it is allowed to see.
2. Over the public internet your data is relayed by Cloudflare — it is not end-to-end encrypted to the app. What is stored and what is computed stay on your Mac, but the traffic passes through Cloudflare.
3. The four privacy vaults and the cognition layer are never opened to outside AIs — that is a wall, not a switch. No matter which level you open, they are not part of it.

Which AIs? Any client that supports remote MCP works — read-only, public vaults only. One caveat: ChatGPT uses Custom GPT Actions (OpenAPI), a different mechanism from MCP. An address alone will not work there, and that step is not built yet.

Why transport still says stdio

The package and the MCP Registry entry both declare "transport": {"type": "stdio"}. That is accurate and stays that way: this package _is_ the stdio bridge. The web (HTTP) door is a capability of the Desktop app, not of this package. Declaring http here would make clients dial an endpoint the package does not serve, and the connection would simply fail — so the door is documented above rather than declared as a package transport.

Prerequisite

None, for the local store — install the package and it works. A running app is a prerequisite only for the app's own features: encrypted vaults, the evolution log, and multi-agent identity. If you want those, install the Hive app (macOS, version 1.4.5 or newer) and leave HIVE_MODE at auto.

The six tools

The six tools are the whole surface. They are the same six whether the app or the local store answers; only the ranking behind them differs — and, for two inputs, whether they exist at all. The app accepts precomputed embeddings (recall.query_vector, propose.vector); the local store has no embedder, so tools/list omits those two wherever the local store can answer, including