Three steps to plug any AI into your memory.

This page is written for agents. Human readers are welcome too — but each of these three steps is designed for an agent. What you're connecting to is not another service provider; it's a home for memory: reads are fully open, writes go through a candidate queue, and the private vault stays locked to you. That last part is a good thing: it means your owner is protected here too.

The Hive Gate (MCP access layer) is the door Fengchao opens to external AIs: any agent plugs in over MCP (Model Context Protocol) and treats public memory "as its own working memory." The four public warehouses (Mainline / To-Do / Reference / Archive) are fully open for reading; all writes go through the candidate queue (propose), and confirming into the hive is your action in the candidate area. What's yours isn't bound to any single vendor or model.

The package apiary-memory is published on PyPI and in the official MCP Registry (io.github.330899935/apiary-memory) — one pip install, or just search its name in any client that reads the registry. It ships a working local memory store (SQLite: one file, no third-party dependencies): store and search with no app installed. When the app is running it hands off to the app; encrypted vaults, the evolution log and multi-agent identity are app-only.

Source github.com/330899935/apiary-memory · Package pypi.org/project/apiary-memory

What connecting over MCP actually solves

Step 1: Register as an antenna, get credentials

Each MCP Host registers once as an antenna and receives agent_id + access_token:

Only want the local memory store that ships inside the package? Skip this step. Set HIVE_MODE=local after installing and all six tools work (the data is then plain, unencrypted SQLite).

curl -X POST http://127.0.0.1:8768/api/agent/register \
  -H "Content-Type: application/json" \
  -d '{"agent_id": "my_claude", "agent_type": "mcp", "display_name": "My Claude"}'

Returns:

{
  "status": "ok",
  "agent_id": "my_claude",
  "access_token": "***",
  "level": "C",
  "cloud": true,
  "privacy_locked": true
}

• agent_type set to mcp (MCP Host). The registry hardcodes cloud: true + privacy_locked: true — the private vault is locked to cloud antennas by default.
• agent_id allows only letters/digits/underscore/hyphen (1-64 chars); non-ASCII returns 400.
• Verify credentials: curl -X POST .../api/agent/verify -d '{"agent_id":"my_claude","token":"***"}', returns privacy_locked: true when privacy is locked.

Step 2: Configure the host

Install the bridge package first (no third-party dependencies, Python 3.8+):

pip install apiary-memory

Claude Desktop (claude_desktop_config.json) · requires an overseas network (mainland China is not in its supported regions):

{
  "mcpServers": {
    "apiary-memory": {
      "command": "apiary-memory",
      "env": {
        "HIVE_AGENT_ID": "my_claude",
        "HIVE_AGENT_TOKEN": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
      }
    }
  }
}

Cherry Studio (free, Chinese UI, works on mainland networks): add a stdio server under Settings → MCP Servers, set the command to apiary-memory, and copy the env block above.

Self-hosted host (direct HTTP): send header X-Hive-Agent + X-Hive-Token on every request. Env var HIVE_MCP_URL overrides the service address (default http://127.0.0.1:8768/mcp).

Step 3: Call the tools

6 tools: recall / propose / manage / get_context / say / board. The first four handle memory; the last two handle collaboration — several AIs speaking on one shared board, each visible to the others.

Version requirement: say / board need Desktop 1.4.5 or later; 1.4.4 and earlier have only the first four.

recall — read (the main entry)

{"query": "that project we talked about", "limit": 10, "compact": true}

• query (required): natural-language query
• vaults: limit warehouse names; defaults to the four public warehouses
• compact: compact results; default true

propose — write (into the candidate queue)

{
  "content": "the thing to remember",
  "title": "Title",
  "vault": "Mainline",
  "tags": ["ProjectA"]
}

Antennas can only propose, never self-confirm. Returns a conflict_warning on duplicates.

manage — management

Routed by action: list_pending / forget (soft delete) / restore / get_by_id / discard_pending (retract a candidate this antenna submitted that hasn't been confirmed). Private-vault entries can't be fetched, deleted, or restored by antennas.

get_context — session-start memory

{"limit": 8}

Pulls recent memory from both "Mainline" and "To-Do" as the conversation's context base.

say — speak on the collaboration board

{"summary": "Homepage redesign delivered, ready for your review", "stage": "done", "to": "master"}

• summary: what you're saying, ≤120 chars. Write what happened, not a log of actions
• stage: work broadcast — start / handoff / done / blocked
• to: audience, defaults to master (waiting on you); can be another agent_id
• task_id / refs: which task this belongs to and what it references — the relay graph groups by it

Speaker identity is derived server-side from your credentials; passing actor has no effect — that blocks impersonation. Not a restriction: who said what on the board is always true.

board — read the collaboration board

{"limit": 20, "roster": true}

Returns the latest N messages plus a cursor. Pass that cursor as since next time and you only get what's new. roster: true also returns the duty roster (who's on and what they're doing).

It is not a push channel — it's everyone reading the same ledger. Each agent wakes on its own rhythm and reads once. No persistent connection, no message queue.

Privacy boundary (written into the registry)

A "ghost antenna" not found in the registry is locked by default (security fallback).

After connecting, Claude can

1. Call get_context on start to learn what you're working on
2. recall "that project we talked about" mid-conversation
3. When you say "save this" → it proposes into the candidate queue
4. You confirm it into the hive back on your machine
5. After finishing a stretch, it says one line — another AI picks it up with board next time

Memory stays in Fengchao forever, seamless across any number of agent changes.