Agenten stärken
Der eigene Befehl des Herausgebers. Kein PlugMCP-Endpunkt.
Host a copy with our keys and logs.
npx -y [email protected]Claude Code hat keinen Installationslink für einen lokalen Befehl. Kopieren Sie den Befehl unten und führen Sie ihn in einem Terminal aus.
claude mcp add chainmemory-mcp -- npx -y chainmemory-mcp@2.10.0In einem Terminal ausführen.
{ "mcpServers": { "chainmemory-mcp": { "command": "npx", "args": [ "-y", "[email protected]" ] } }}claude_desktop_config.json
Remote-URL oder ein Befehl auf Ihrem Rechner? Worin sich die beiden Installationen unterscheiden
Auf PlugMCP ausführen
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
StartenVom Herausgeber
Cross-model, cryptographically verifiable memory for Claude, ChatGPT, and any AI agent — own your AI's memory and carry it across every model.
ChainMemory MCP exposes the ChainMemory protocol to any AI agent that speaks the Model Context Protocol. Memories are encrypted (AES-256-GCM), anchored on-chain one by one so anyone can verify them, and portable across ChatGPT, Claude, Gemini, Perplexity, and any other LLM. No vendor lock-in, ever.
get_project_brief, only when you allow it. The brief is
public by default: safe to paste into any chat, with addresses, ports,
server paths and security rules replaced by [withheld]. Pass
level: "full" to get them too, for work on your own infrastructure. It
works only if you add CHAINMEMORY_ALLOW_FULL=1 to this MCP server's env,
only with the owner's key (member and project keys are refused by the API),
and ChainMemory logs every full-level request: when, which project and
version, from which client and how many sensitive lines went out. The brief
says so at the top and counts the sensitive lines at the end.chainmemory-mcp <version> stdio|remote), which is what the full-level
log records.To enable it, add the variable next to your API key:
"env": {
"CHAINMEMORY_API_KEY": "aic_your_key_here",
"CHAINMEMORY_ALLOW_FULL": "1"
}
get_project_brief has a task mode. Pass task: "pri_0015" and the brief
is about that one priority: the priority in full, its completion criterion
on its own line, the risks it mitigates, everything else in the Brain that
mentions it, and every work rule and constraint. A general brief orients;
this one is meant to be enough to start the work. It does not move the
version remembered for "what changed".[withheld], and says how many were withheld in that text, so the agent
knows to ask. Before, a large budget could carry a server path or an SSH
port into a third-party chat.state_hash, each
changed priority-risk link with its previous value, completion criteria
never cut, titles in "to review", the owner's work rules, and how many items
cite evidence, with the rest marked (no evidence).update_project_state documents the
new mitigates field of add_priority and the set_priority_risks op (the
grammar is now 30 ops). The brief then shows which priority covers each risk
and lists the high risks nobody mitigates. The documented value sets were
also corrected: risks can be mitigated, and priorities are active,
done or dropped.get_project_brief: the Project Brain in a few thousand characters,
most important first. get_project_state returns the whole state as JSON,
which on a mature project is long, and an agent opening a session reads it
from the top. The brief is plain text built by the server
(GET /v1/project/:name/inject) by relevance and within a character budget
(default 7,000, from 1,000 to 50,000): what changed since the last version
you read, open risks (high first), active priorities, recent decisions with
their scope, recent milestones, open questions, each constraint as a one-line
rule, and the items that have not been reviewed for more than 30 versions
and may no longer be true. It starts with the state's on-chain anchor.
Free and read-only.~/.chainmemory/brief-since.json. The file is indexed by a hash of your API
key and the project name: it contains neither. Pass since to compare
against a specific version. On the remote endpoint nothing is stored, and
the comparison is with the previous version.lang: "es"); the items are returned as
they were written.get_project_state is unchanged, and is still the tool to use before
update_project_state.CHAINMEMORY_SEED_PHRASE), chainmemory_remember with sealed:true now
sends the memory's search vector along with the encrypted blob, computed on
your machine. The server can find a memory it cannot read, and
search_memories decrypts sealed matches locally.search_memories sends the query's vector, not its text, so the text of
what you search is never sent to the server nor written to its search log.models.chainmemory.ai, checked
against its SHA-256 anchored on ChainMemory's chain, and stored in
~/.chainmemory/models (or CHAINMEMORY_MODELS_DIR); it is checked again
every time it is loaded.2.5.6 to every client, whatever package was installed. It now reads the
version from package.json, so the two cannot drift again.quote_inject reports missing memories correctly — fixed on the API
side (2026-09-14), no client change needed. Before, it listed memories it
had found as not found and told the agent to fix a list that was fine.get_inject_history responses now include memory_numbers, the #N of
each injected memory.Tool descriptions rewritten for agents, not for humans. An audit of all 36 found that only 39% said when to use them, 25% stated their limits, and two charged without saying so. One of them was plainly wrong.
chainmemory_profile promised memory count, trust score and
registration block. None of those fields exist — the API returns
chain_memories, local_memories, synced_memories, pending_sync,
reputation, owner and active. The v2.5.6 release fixed the code that
asked for the wrong fields; the description kept advertising them.chainmemory_remember (0.001 AIC) and update_project_state
(0.05 + 0.005 per op) now state their fee. They are the most used and the most
expensive tool respectively.update_project_state now documents the closed value sets. severity is
low, med or high — not medium, not critical. A wrong value costs
a rejected op and the fee is charged anyway.get_my_context and chainmemory_recall both said "use at conversation
start". Now each says when to use it instead of the other.delete_project needs the numeric id and rejects
the slug; add_project_from_template and list_project_templates deal in ids
that cannot be guessed; chainmemory_seal is the only tool requiring a wallet
private key.No behaviour changed: same 36 tools, same endpoints, same fees. What changed is what the agent is told before it chooses.
Documentation fix only, no code changes. The blind vault section described the
verification step wrongly: GET /v1/memory/<id>/decrypted does not fail on a
sealed memory — it returns 200 with scheme: "sealed" and the encrypted blob.
The guarantee is the same (the operator never gets your text) but the observed
behaviour was not what we documented. Found by running the first end-to-end test
against the live API.
Blind vault — memories the server cannot read. Pass sealed: true to
chainmemory_remember and the text is encrypted on your own machine before it
leaves: AES-256-GCM with a key derived from twelve BIP-39 words that never touch
the network. ChainMemory stores an opaque blob and anchors its hash. Same fee as
a normal write — privacy costs nothing extra.
chainmemory_new_seed creates the phrase locally. Shown once, stored nowhere.chainmemory_open_sealed fetches the blob and decrypts it here, not there.CHAINMEMORY_SEED_PHRASE, everything behaves exactly as in 2.5.6.One honest limitation: a sealed memory is stored with no searchable text, so
it will not appear in search_memories — the server has nothing to index. Its
project and tags are stored, so list_memories_filtered still finds it by
project; you then read the content with chainmemory_open_sealed. Losing full
text search is the direct consequence of the server being unable to read it, and
there is no way around that which keeps the guarantee. (Solved in v2.8.0:
the search vector is now computed on your machine, so sealed memories are
searchable without the server reading them.)
If you lose the twelve words, the memories sealed with them are gone — for you and for everyone. Write them on paper.
Three defects that made tools report confidently wrong things. No new tools.
list_project_templates never listed anything. It read templates / template_id from a response that returns defaults / project_id, so it always answered "No templates available" — which meant nobody could learn the id that add_project_from_template needs. The whole template flow was unreachable.chainmemory_profile got five of eight fields wrong. It read wallet, memory_count, trust_score, registration_block and sealed; the API returns owner, chain_memories / local_memories, reputation and active. Every profile came back with an empty wallet, zero memories, ? reputation and Sealed: no, regardless of the real state. It also had no handling for an API key with no registered identity, printing AI Profile #undefined.update_project_state hid the reason when every op was rejected. Rejections were only rendered on the success path, but rejecting all ops leaves the state unchanged and takes the other branch — so the reply said Rejected: 3 and nothing else. The only way to find out why was to guess again and pay the fee again.audit_memory and audit_state — the two forensic audit endpoints, now reachable from any MCP client. Both accept dry_run: true, which returns the identical result without charging: an audit you can run as often as you like, and pay for only when you need the receipt on record. audit_state costs 5 AIC in its paid form, so the tools default to the dry run.Search and full reads
search_memories — semantic search over your memories (cosine similarity over cached embeddings, blended with recency and importance), returning the full text of each match. Previous versions exposed no search at allget_memory — read one memory in full, decrypted from chain, with an integrity check: the server recomputes the event hash from the plaintext and compares it against the hash anchored on-chainchainmemory_recall and list_memories_filtered now state plainly that they return 80-character previews, and point to get_memory / search_memories for the full textVerification — free, and the point of the product
verify_project_state — public, unauthenticated proof of a Project Brain: every anchored version with its state_hash and on-chain coordinates, plus how to check them yourself in the ProjectStateAnchor contract. No content is exposedget_memory_proof — the shareable anchoring proof of a single memory: event_hash plus its on-chain coordinates. A third party verifies it without your API key, and the content is never revealedCost control
quote_inject — price an inject before paying: which ids exist, which don't, tokens, exact cost with its burn/treasury split, and whether your balance covers itRoles and hardening
list_role_contracts — discover a project's roles (id, version, status) before reading a contract or assuming a role. Role ids are not guessable; this removes the failed-call round tripinclude_roles on get_project_state — set to false to get the state without the full text of every signed role contractCHAINMEMORY_API_KEY declared in the MCP manifest — the only mandatory variable was missing from server.json, so registries and installers never prompted for itget_project_state consolidates your atomic memories into a structured, versioned, verifiable project state (decisions, risks, constraints, metrics, and environment: where and how you work), and delivers active role contracts with it in a single callget_role_contract (read the contract), assume_role (open an audited Role Session), release_role (close with a summary)Visit https://faucet.chainmemory.ai. You receive an API key (aic_...) and a starter balance of AIC. ChainMemory collects no personal data — your key is your identity.
Edit your Claude Desktop config (~/Library/Application Support/Claude/claude_desktop_config.json on macOS, %APPDATA%\Claude\claude_desktop_config.json on Windows):
{
"mcpServers": {
"chainmemory": {
"command": "npx",
"args": ["-y", "chainmemory-mcp"],
"env": {
"CHAINMEMORY_API_KEY": "aic_your_key_here"
}
}
}
}
Restart Claude Desktop. The 37 tools are now available.
chainmemory_recallchainmemory_rememberget_project_brief (what changed, open risks, priorities, decisions)get_project_state (Brain + active role contracts)list_role_contractsassume_role (audited Role Session)For most users only CHAINMEMORY_API_KEY is needed.
inject_memories with a list of IDsget_inject_history shows confirmation statuschainmemory_new_seed generates twelve BIP-39 words from the official 2048
word list, with checksum. Write them down; they are shown once.CHAINMEMORY_SEED_PHRASE and restart the MCP.sealed: true, the phrase is stretched into a seed with PBKDF2-HMAC-SHA512,
the content key is derived with HKDF-SHA256, and the text is sealed with
AES-256-GCM into a versioned envelope. The blob, a SHA-256 hash and the
memory's search vector are sent to POST /v1/memory/sealed; the text is not.models.chainmemory.ai and
checked against its SHA-256 anchored on-chain. It lets the server find the
memory without reading it.search_memories sends the query's vector, not its text, and decrypts
sealed matches locally. chainmemory_open_sealed retrieves one blob and
decrypts it locally.No key material is transmitted at any point, and no recovery path exists — a recovery path is exactly what an operator would need in order to read your memories.
What it does not cover: metadata stays visible (timestamps, sizes, project, tags), and so does the search vector, which cannot be turned back into the text but does reflect what it is about. Memories written before sealing cannot be sealed retroactively, and the on-chain anchor is still signed by the server. The operator is trusted to anchor, never to read.
Verify the claim yourself: seal a memory, then call
GET /v1/memory/<id>/decrypted with your API key. It returns 200 with
scheme: "sealed" and the encrypted blob — never the text. That endpoint
derives its key from the API key, which is what an operator would have; faced
with a sealed memory it has nothing to decrypt.
┌─────────────────────────────────────────────────────────────┐
│ AI Agent (Claude Desktop, ChatGPT, any MCP client) │
└──────────────────┬──────────────────────────────────────────┘
│ MCP stdio
↓
┌─────────────────────────────────────────────────────────────┐
│ chainmemory-mcp v2.5 (this package) │
└──────────────────┬──────────────────────────────────────────┘
│ HTTPS + x-api-key
↓
┌─────────────────────────────────────────────────────────────┐
│ api.chainmemory.ai │
│ - per-user encryption at rest (AES-256-GCM) │
│ - Project Brain (deterministic builder + state_hash) │
│ - Role contracts + audited Role Sessions │
│ - SQLite + Merkle proofs │
└──────────────────┬──────────────────────────────────────────┘
│ JSON-RPC
↓
┌─────────────────────────────────────────────────────────────┐
│ ChainMemory L1 — Chain ID 202604 │
│ - Geth PoA Clique, 3 validators │
│ - Memory contract + daily checkpoint anchoring │
│ - Project State anchoring (public verification) │
└─────────────────────────────────────────────────────────────┘
CHAINMEMORY is a registered trademark in Argentina (INPI, class 42, resolution 3932170), held by the project's founder. The MIT license covers the code, not the ChainMemory name or logo.
MIT
Cross-model, cryptographically verifiable memory for Claude, ChatGPT, and any AI agent — own your AI's memory and carry it across every model. MCP server, 37 tools: remember, semantic search, on-chain
{ "mcpServers": { "chainmemory-mcp": { "command": "npx", "args": [ "-y", "[email protected]" ] } }}Übersicht
Cross-model, cryptographically verifiable memory for Claude, ChatGPT, and any AI agent — own your AI's memory and carry it across every model. MCP server, 37 tools: remember, semantic search, on-chain verification proofs, forensic audit, selective inject,
Tools
Noch keine Tool-Liste. Remote-Server erhalten eine nach dem ersten Health-Check.
FAQ
Kopieren Sie auf dieser Seite die stdio-Konfiguration für Cursor, Claude Desktop, Claude Code oder VS Code. Sie nutzt die Installation des Herausgebers, keinen PlugMCP-Proxy.
In diesem Eintrag ist keine erforderliche Umgebungsvariable aufgeführt.
Chainmemory läuft lokal über stdio.
Zuletzt geprüft: 2026-11-05. Cross-model, cryptographically verifiable memory for Claude, ChatGPT, and any AI agent — own your AI's memory and carry it across every model. MCP server, 37 tools: remember, semantic search, on-chain verification proofs, forensic audit, selective inject,