# saihm-mcp-server-pro [Health: Active]

**Category:** 🧠 Knowledge & Memory  
**Repository:** https://github.com/SAIHM-Admin/saihm-mcp-server-pro  
**GitHub Stars:** 1  
**npm Downloads (last month):** 1981  
**Views:** 0  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/saihm-mcp-server-pro

## Description
Sovereign encrypted memory for AI agents. Sealed on your machine. Start free: say Join SAIHM.

## Tools
Capabilities this server exposes over MCP:

- **saihm_remember** — Store information in SAIHM persistent memory. Encryption happens in this process and the key never leaves it, so the server holds ciphertext it cannot read. Use this when a fact, decision, or piece of context should outlive the current session. Pass an existing cellId to update that cell instead of adding a new one; when the endpoint reports that the update left shares of the cell on the previous version, they are re-issued for the new version and the result counts them, and a share that was not re-issued needs saihm_share again. Returns the cell id that saihm_forget takes. With warmStart "put", it instead stores an encrypted warm-start snapshot of the payload file named by token.
- **saihm_recall** — Retrieve your memories from SAIHM and decrypt them in this process; the server never sees plaintext. Use this at the start of a session, or whenever past context is needed. Pass query to filter by keyword, or leave it out to load everything. Pass cellId alone to read one of your own cells. To read a single cell another agent shared with you, pass their agent ID as sharerPinnedAgentIdHashHex together with the cellId, taking that ID from your user, not from a shared pointer; that path is read-only. Pass listOnly to list your cells' versions without their content. Pass sharesOnly to list every pointer shared with you, a page at a time, where the endpoint offers it. With warmStart "latest", it instead restores the newest encrypted warm-start snapshot into the payload file named by token; "list" lists them.
- **saihm_forget** — Cryptographically erase one memory by its cell id (GDPR Art. 17). Destroying the wrapped key leaves the content unreadable to everyone, the operator included. Irreversible: use it when erasure is the intent, not to tidy a working set. With warmStart "delete", it instead destroys one encrypted warm-start snapshot, its key first.
- **saihm_status** — Show the current SAIHM session: the agent identity, which this client derives locally, plus the tier, custody mode, shard and sharing counts, and bfsi score the server reports. No plaintext appears, because the server holds none. Use it to check which identity is active and what is stored and shared.
- **saihm_share** — Grant one other agent access to a single memory cell, named by cellId. Identify the recipient by the identity record file their identity-record command wrote: pass its path, in full, as recipientRecordFile (a relative path is read from the server's working directory), and the server reads the record and agent ID from it (no need to open the file). Or pass their recipientRecord with their recipientPinnedAgentIdHashHex, pinned out-of-band. With the file, pass recipientPinnedAgentIdHashHex too when the user has the agent ID from their colleague another way: it must match the agent ID in the file. Set scope to 'read', 'write' or 'readwrite'. Only that one cell is exposed, and sharing re-wraps its key rather than copying the memory.
- **saihm_revoke_share** — Withdraw a grant made with saihm_share, naming the same cellId and the recipient's recipientHex. It applies to future reads and cannot retract what the recipient has already read. Use it to end access; the memory itself remains, and saihm_forget is what erases.
- **saihm_governance_propose** — Open a protocol governance proposal: set scope to 'emission_param' or 'protocol_upgrade', and for 'emission_param' also pass paramKey and proposedValue. Protocol governance is not enabled for this client yet — the tool is present so the surface stays stable, and calling it returns a 'governance unavailable' error rather than opening a vote.
- **saihm_governance_vote** — Cast a vote on an open protocol governance proposal by its proposalId, with approve set to true to approve or false to reject. Protocol governance is not enabled for this client yet — the tool is present so the surface stays stable, and calling it returns a 'governance unavailable' error rather than recording a vote.
- **saihm_join** — Activate free SAIHM persistent memory for this agent. Call this when the user asks to join, sign up for, or set up SAIHM. Where no identity is configured, a join creates a NEW, EMPTY memory, so the first call answers with a question instead: whether they already have a SAIHM identity (from another machine or an earlier session). Put it to them once; if they do, do not join: they bring it with export-identity instead. In a hosted or cloud session that starts fresh each time, or in a CI job, do not join there either: they join on their own computer, then bring that identity in the same way. Once they confirm they want a new one here, call again with newIdentity: true. It self-generates a sovereign memory key on this device and starts a one-time human approval — the tool returns a URL and short code for the user to open and enter. After the user approves, the join finishes by itself and the memory tools work; there is no need to call saihm_join again. No payment.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "saihm-mcp-server-pro": {
    "command": "npx",
    "args": ["-y","@saihm/mcp-server-pro"],
    "env": {
      "SAIHM_ENDPOINT_URL": "",
      "SAIHM_MASTER_SECRET_FILE": ""
    }
  }
}
```

**Requires environment variables:** `SAIHM_ENDPOINT_URL`, `SAIHM_MASTER_SECRET_FILE` — the values above are empty placeholders; fill in real credentials before running (see the repository for what each one is for).

## Documentation

## What saihm-mcp-server-pro MCP server does

The saihm-mcp-server-pro MCP server gives AI agents access to portable memory managed through SAIHM. It is intended for retaining information between sessions and making that information available when changing assistants, models, or vendors. The local process communicates with the SAIHM endpoint while keeping memory encryption on the user's machine.

Each memory cell is sealed before it is sent for storage. The server also supports sharing a cell with another user's agent and withdrawing that access later.

## How it works

The package runs locally through Node.js and is started by an MCP client with `npx`. A client supplies the SAIHM endpoint URL, and the server uses an identity key created during the free-join process or supplied through a protected key file. The join flow creates a key on the machine and uses a browser-based approval step.

The saihm-mcp-server-pro MCP server performs sealing and opening on the client side. `saihm_remember` writes a sealed memory cell, while `saihm_recall` reads cells that belong to the user or have been shared with them. The storage service therefore receives encrypted content rather than the plaintext memory described to the agent.

## Setup and configuration

Node.js 20 or later is required. The package is available as `@saihm/mcp-server-pro` on npm. A typical local configuration starts it with `npx -y @saihm/mcp-server-pro` and sets `SAIHM_ENDPOINT_URL` to `https://saihm.net/mcp`.

To begin, run `npx -y @saihm/mcp-server-pro free-join`. The command creates or reuses a machine key, displays a link and short code, and waits for browser approval through GitHub. Users without GitHub can obtain a key through the SAIHM website and point `SAIHM_MASTER_SECRET_FILE` to a file containing it. The documentation advises against placing the key itself directly in client settings.

The README provides configuration examples for Claude Code, Claude Desktop, Codex CLI, Gemini CLI, VS Code, Cline, Cursor, Windsurf, and the OpenAI Agents SDK. First startup may need a longer timeout because `npx` downloads the package.

## Tools and capabilities

The available MCP tools are:

- `saihm_remember`: seals and writes a memory cell from the client.
- `saihm_recall`: read-only access to the user's cells or cells shared with them.
- `saihm_forget`: permanently erases a memory and cannot be undone.
- `saihm_status`: reports status without modifying memory.
- `saihm_share`: creates an end-to-end-authenticated sharing grant.
- `saihm_revoke_share`: withdraws an existing sharing grant.
- `saihm_governance_propose`: opens a governance proposal.
- `saihm_governance_vote`: casts a vote on a governance proposal.

These operations cover personal memory, controlled sharing, access withdrawal, and the governance actions exposed by the service.

## Limitations and notes

The server requires a local Node.js installation and an MCP client that can launch a stdio server. Joining requires a browser and an account-based approval flow unless a key is obtained through the alternate website process. The memory key should be kept in a file readable only by the intended user.

Deletion through `saihm_forget` is destructive and irreversible, so agents should not invoke it without clear confirmation. A shared cell can be read by the recipient while the grant is active; `saihm_revoke_share` is provided to withdraw that grant. The documentation describes encrypted storage and client-side sealing, but does not specify recovery behavior for a lost key.

_Full upstream README: https://allmcps.com/mcp/saihm-mcp-server-pro/readme_