@saihm/mcp-server-pro

v0.14.0

Published

21 hours ago

Free-to-start portable memory for AI agents: encrypted, shareable, provably erased. Join SAIHM. Ask your agent to "Join SAIHM".

SAIHM — memory for AI agents

Portable memory for AI agents. Your assistant remembers what matters — across sessions, across models, across vendors. Share a memory with someone else's agent, take it back, or erase it for good.

Enjoyed them? Like the videos, subscribe to the SAIHM channel, and turn on notifications with the bell 🔔 to hear about new videos and updates.

Prefer to read? The SAIHM manual (PDF) is a decision-maker's guide to SAIHM and SHM.

AI assistants forget everything when the session ends. SAIHM gives yours a memory that doesn't — one that follows you to a different assistant, a different model, or a different company's product.

Encrypted at rest, by default. Every memory is encrypted on your own machine before it goes anywhere, and SAIHM stores only that ciphertext. Nobody else can read your memories — not the storage, not SAIHM. There is nothing to switch on.

Start free — one command

npx -y @saihm/mcp-server-pro free-join

No card and no wallet. You need a browser and a GitHub account once, for a quick sign-in that confirms you're a real person:

The command creates your key on this machine and shows a link and a short code.
Open the link, sign in to GitHub, enter the code and approve.
The command finishes by itself and shows where your key is saved.

No GitHub account? Start at https://saihm.net/free instead: you sign in with Google, and the page gives you your new key. Save it to a file only you can read, and point SAIHM_MASTER_SECRET_FILE at that file in your client's settings below. Never paste the key itself into a settings file. Your key is ready, so skip "Join SAIHM": a join would make a second, different key.

Then add SAIHM to your AI client, restart it, and say "Recall my SAIHM memories." You're running.

Prefer not to touch a terminal? Add SAIHM to your client first, then say "Join SAIHM" to your assistant. It runs the same setup and gives you the same link and code to approve.

If a join is interrupted, join again on the same machine: it reuses the key it already created, so you keep the same identity. To cancel a join, stop it and don't enter the code; the code expires on its own. Keep the key file either way. Joining in detail.

Add SAIHM to your AI client

SAIHM runs on your machine as a local MCP server that your AI client starts with npx, so you need Node.js 20 or later. The package is @saihm/mcp-server-pro on npm, and the official MCP Registry lists it as io.github.SAIHM-Admin/saihm-mcp-server-pro.

Find your client below, add its block, and restart the client. Two tips:

Keep the file valid. A trailing comma, or a non-breaking space copied from an email or a web page, makes a JSON settings file invalid. Paste through a plain-text editor.
Keep the start-up setting. The first start downloads the package. Where a block sets a longer start-up time, keep it, so the tools appear on the first try.

Each block follows that client's own documentation. Before every release, the server is started from these blocks in Claude Code, Gemini CLI and the OpenAI Agents SDK to confirm it connects. Each client's fine print is in the reference.

Claude Code (Anthropic)

One command adds SAIHM for all your projects:

claude mcp add --env SAIHM_ENDPOINT_URL=https://saihm.net/mcp --transport stdio --scope user saihm -- npx -y @saihm/mcp-server-pro

If the tools don't appear after the first start, give the server more time: MCP_TIMEOUT=60000 claude. claude mcp list shows whether it connected. For Claude Code on the web, see Hosted agent environments.

Claude Desktop (Anthropic)

Open Settings > Developer > Edit Config, add the "saihm" entry inside mcpServers, then quit and reopen Claude Desktop:

{
  "mcpServers": {
    "saihm": {
      "command": "npx",
      "args": ["-y", "@saihm/mcp-server-pro"],
      "env": { "SAIHM_ENDPOINT_URL": "https://saihm.net/mcp" }
    }
  }
}

Claude Desktop starts the server with the Node.js installed on your machine, so install Node.js first.

Codex CLI (OpenAI)

Add this to ~/.codex/config.toml, or to a project's .codex/config.toml:

[mcp_servers.saihm]
command = "npx"
args = ["-y", "@saihm/mcp-server-pro"]
env = { SAIHM_ENDPOINT_URL = "https://saihm.net/mcp" }
startup_timeout_sec = 60

Check it with codex mcp list, or /mcp inside Codex.

OpenAI Agents SDK (Python)

import asyncio
from agents import Agent, Runner
from agents.mcp import MCPServerStdio

async def main():
    async with MCPServerStdio(
        name="saihm",
        params={
            "command": "npx",
            "args": ["-y", "@saihm/mcp-server-pro"],
            "env": {"SAIHM_ENDPOINT_URL": "https://saihm.net/mcp"},
        },
        client_session_timeout_seconds=60,
    ) as saihm:
        agent = Agent(name="Assistant", mcp_servers=[saihm])
        result = await Runner.run(agent, "Recall my SAIHM memories.")
        print(result.final_output)

asyncio.run(main())

The 60-second timeout gives the first npx download time to finish. Pass secrets from the environment, never as literals in your code.

Gemini CLI (Google)

Add this to ~/.gemini/settings.json (all projects) or .gemini/settings.json (one project):

{
  "mcpServers": {
    "saihm": {
      "command": "npx",
      "args": ["-y", "@saihm/mcp-server-pro"],
      "env": { "SAIHM_ENDPOINT_URL": "https://saihm.net/mcp" }
    }
  }
}

Or install the Gemini CLI extension, which carries the same entry: gemini extensions install https://github.com/SAIHM-Admin/saihm-mcp-server-pro.

Run Gemini CLI in a folder you trust, since it starts local servers only there. Check with gemini mcp list, or /mcp inside Gemini CLI.

Grok Build (xAI)

Add this to ~/.grok/config.toml, or to a project's .grok/config.toml:

[mcp_servers.saihm]
command = "npx"
args = ["-y", "@saihm/mcp-server-pro"]
env = { SAIHM_ENDPOINT_URL = "https://saihm.net/mcp" }
startup_timeout_sec = 60

Grok Build also picks up an existing saihm entry from ~/.claude.json or a project's .mcp.json, so if you already added it for another client you may not need this step. Check it with grok mcp list, or grok mcp doctor saihm.

GitHub Copilot in VS Code (Microsoft)

Add this to .vscode/mcp.json in a workspace, or to your user mcp.json (run MCP: Open User Configuration). VS Code uses servers here, not mcpServers:

{
  "servers": {
    "saihm": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@saihm/mcp-server-pro"],
      "env": { "SAIHM_ENDPOINT_URL": "https://saihm.net/mcp" }
    }
  }
}

Or add it to your user profile from a terminal (bash, zsh or Command Prompt):

code --add-mcp "{\"name\":\"saihm\",\"command\":\"npx\",\"args\":[\"-y\",\"@saihm/mcp-server-pro\"],\"env\":{\"SAIHM_ENDPOINT_URL\":\"https://saihm.net/mcp\"}}"

MCP: List Servers shows the server, and its Show Output action shows the log. For the GitHub Copilot cloud agent, see Hosted agent environments.

Other MCP clients

For clients that run local MCP servers from an mcpServers block, such as Cline, Cursor or Windsurf, add the "saihm" entry inside the existing mcpServers object:

{
  "mcpServers": {
    "saihm": {
      "command": "npx",
      "args": ["-y", "@saihm/mcp-server-pro"],
      "env": { "SAIHM_ENDPOINT_URL": "https://saihm.net/mcp" },
      "timeout": 60
    }
  }
}

timeout is in seconds in Cline. If your client documents another unit, follow its documentation.

If the tools don't appear the first time, run npx -y @saihm/mcp-server-pro once in a terminal so the package is downloaded, then restart Cline.

Agent frameworks

Building agents in Python? The same encrypted memory plugs into the major frameworks. Each adapter needs Node.js 20 or later, like this server, and encrypts inside your process, so Python never holds a key.

| Framework | What you get | Install | |---|---|---| | LangGraph | A long-term memory store for your graph | pip install saihm-langgraph (repository) | | CrewAI | One memory your whole crew shares | pip install saihm-crewai (repository) | | LangChain | Chat history you own | pip install "saihm-adapters[langchain]" | | LlamaIndex | Chat memory, and a retriever for RAG | pip install "saihm-adapters[llamaindex]" and [rag] | | AutoGen | A memory your agent owns | pip install "saihm-adapters[autogen]" |

saihm-adapters brings them all together, with live demos.

Things to say

You don't call tools by name — you talk to your assistant. Some starters:

Liberally use SAIHM protocol to maximize token economy.

Recall my SAIHM memories before you start.

Remember that I prefer short answers and no preamble.

Set an invariant to doubly confirm before any SAIHM forget action.

Share that note with my colleague's agent until 5:00 pm today.

How much of my SAIHM allowance is left?

Forget everything I told you about the Henderson account.

| Tool | What it does | |---|---| | saihm_remember | Encrypts on your machine, then stores it | | saihm_recall | Fetches and decrypts on your machine | | saihm_forget | Permanently erases. No undo | | saihm_status | Your usage and settings | | saihm_share | Grants one memory to one agent, optionally with an expiry | | saihm_revoke_share | Withdraws that grant |

Every tool is labelled for your AI tool to read, including which are read-only and which one destroys data — so hosts that ask "are you sure?" before destructive actions know when to ask. The reference has the full tool list.

"Forget" really means forget. The key to that memory is destroyed, so the stored copy becomes permanently unreadable — by you, by SAIHM, by anyone holding a backup of it. This is how SAIHM answers a GDPR Article 17 erasure request, and it is why there is no undo. The answer confirms the erasure once the service's record of the key's destruction comes back with it.

Your memories follow your key

Your memory belongs to your key, not to a computer — that's what makes it portable. The key is created on your machine and never sent anywhere, which is exactly why nobody else can read your memories. Keep a copy of the key file somewhere safe: SAIHM cannot make you another one. Setup shows where the file is, and upgrading to a paid plan keeps the same key and every memory.

Using a second computer, or a hosted agent? Three ways:

Same memory, anywhere — on the machine that has your key, run:
```
npx -y @saihm/mcp-server-pro export-identity
```
It saves two values to a file only you can read: SAIHM_IDENTITY (your key, sealed) and SAIHM_IDENTITY_PASSPHRASE (the passphrase that opens it). Set both as environment variables or secrets wherever the memory should follow you, then start a new session. Don't say "Join SAIHM" there: a join starts a new, empty memory. Together the two values are your identity: keep them in a password manager, never in a chat or a repository, and delete the export file. On a paid plan, see exporting your identity first.
Copy the key file — put it at ~/.saihm/free-identity.key on the other machine (or point SAIHM_MASTER_SECRET_FILE at it) before the server starts, use the same settings as the first machine (on a paid plan, SAIHM_TIER and SAIHM_PAYMENT_METHOD too), and say "Recall my SAIHM memories."
Keep work and personal apart — start fresh on the second machine and share across instead: "Share these notes with my work agent until 5:00 pm." A share can be revoked or given an expiry, so the two stay separate.

Hosted agent environments

A hosted agent session usually starts on a fresh machine and discards its home directory when it ends, so a key created there would be lost with it. Bring your identity in instead: set the two export-identity values in the environment's own settings — never in the chat — and start a new session, because the environment reads its variables when a session starts. The server runs locally in the session and needs to reach saihm.net, and npm for npx. The steps below follow each host's own documentation; the reference covers proxies and the finer points.

Claude Code on the web — add both values under the environment's Environment variables. Anyone who uses that environment can read them, so use a dedicated environment that only you use, for repositories you trust. Choose Custom network access, add saihm.net, and check Also include default list of common package managers, so npx can still reach npm. Then pass the values through the repository's .mcp.json:
```
{
  "mcpServers": {
    "saihm": {
      "command": "npx",
      "args": ["-y", "@saihm/mcp-server-pro"],
      "env": {
        "SAIHM_ENDPOINT_URL": "https://saihm.net/mcp",
        "SAIHM_IDENTITY": "${SAIHM_IDENTITY:-}",
        "SAIHM_IDENTITY_PASSPHRASE": "${SAIHM_IDENTITY_PASSPHRASE:-}",
        "SAIHM_TIER": "${SAIHM_TIER:-}",
        "SAIHM_PAYMENT_METHOD": "${SAIHM_PAYMENT_METHOD:-}",
        "CLAUDE_CODE_REMOTE": "${CLAUDE_CODE_REMOTE:-}"
      }
    }
  }
}
```
The same file still works on your own machine. Never add SAIHM_MASTER_SECRET_FILE or SAIHM_MASTER_SECRET_HEX to it: either would commit your key or clash with the identity. If the tools don't appear, run claude mcp list in the session, and set MCP_TIMEOUT=60000 in the environment variables to give the server longer to start.
GitHub Copilot cloud agent — store the values as Agents secrets (repository Settings → Secrets and variables → Agents) named COPILOT_MCP_SAIHM_IDENTITY and COPILOT_MCP_SAIHM_IDENTITY_PASSPHRASE. The server runs beside every command the agent runs, so use this only in a repository whose code you trust. Map the secrets in the repository's MCP configuration (Settings → Copilot → MCP servers):
```
{
  "mcpServers": {
    "saihm": {
      "type": "local",
      "command": "npx",
      "args": ["-y", "@saihm/mcp-server-pro"],
      "tools": ["saihm_recall", "saihm_remember", "saihm_status"],
      "env": {
        "SAIHM_ENDPOINT_URL": "https://saihm.net/mcp",
        "SAIHM_IDENTITY": "$COPILOT_MCP_SAIHM_IDENTITY",
        "SAIHM_IDENTITY_PASSPHRASE": "$COPILOT_MCP_SAIHM_IDENTITY_PASSPHRASE",
        "SAIHM_EPHEMERAL_HOME": "1"
      }
    }
  }
}
```
Copilot runs the listed tools without asking, so this list leaves out saihm_forget and the sharing tools. By default, Copilot code review can call the read-only tools on any pull request, so your memories could reach review comments: unless you want that, turn off Allow Copilot to use MCP tools when reviewing pull requests.
Elsewhere — this should work on any host that runs local MCP servers, lets the server read both values, and lets it reach saihm.net and registry.npmjs.org. Put the values in the host's own secrets or environment settings, scoped to you alone, in an environment only you use: the agent, and every command it runs, may be able to read them. Add SAIHM_EPHEMERAL_HOME=1 there if its home directory does not persist. Hosts that only connect to remote MCP servers cannot run this package.

Where it can tell that the home directory is temporary, a join refuses to create a key that would be lost with it.

See it run

Live demos across every major model — offline, about a minute each, no account: https://saihm-admin.github.io/saihm-demos/. Store a memory in Claude, GPT, DeepSeek, Qwen, Kimi, or GLM, then prove you can erase it.
Token benchmark — recalling a bounded set of memories instead of re-sending the whole conversation cut input tokens by 62.8%–85.9% across a realistic multi-session task. Open, offline, reproducible: https://github.com/SAIHM-Admin/saihm-token-benchmark.

What it costs

Start free. The free tier is a fixed, one-time allowance of writes, reads, and shares for trying SAIHM on real infrastructure — it doesn't reset or refill. No card, and nothing to cancel. Your assistant shows what's left and warns you as it runs low, so nothing fails by surprise.

Paid plans are monthly, and upgrading keeps the same key and every memory you already have:

SAIHM_MASTER_SECRET_FILE=$HOME/.saihm/free-identity.key \
SAIHM_TIER=FREE \
  npx -y @saihm/mcp-server-pro upgrade PRO

That prints a checkout link tied to your identity. Pay, then add two lines to your config's env block and restart:

"SAIHM_TIER": "PRO",
"SAIHM_PAYMENT_METHOD": "stripe"

A paid plan needs both lines: without SAIHM_PAYMENT_METHOD, which names the payment rail to check, the server won't start. stripe is one option and stablecoin another; your assistant can tell you what your operator accepts.

If something isn't working

| What you see | What to do | |---|---| | No SAIHM tools appear, and no error anywhere | The client stopped waiting before npx finished its first download. Keep the start-up setting in your client's block, and check that the file is valid JSON | | Every other tool vanished too | The settings file is no longer valid JSON: look for a trailing comma, or non-breaking spaces from a copy and paste | | The memory tools say the join is waiting for approval | Open the link the join gave, sign in, enter the code and approve; then say "Join SAIHM" again | | Tools appear but every call fails | The machine cannot reach the endpoint (saihm.net, unless you set another). In a hosted environment, allow it in the network settings | | A hosted session keeps asking to join | The environment has no identity of yours: see Hosted agent environments | | A different memory than you expected | This machine has its own key rather than yours |

Proxies, erasure answers and everything else are in the full troubleshooting table.

How it works

Everything is encrypted on your machine before it is sent, and decrypted on your machine after it comes back. What SAIHM stores is unreadable ciphertext, and no key that opens it. To erase something, its key is destroyed — which is why erasure is immediate and final rather than a promise that a copy was deleted somewhere.

Post-quantum by design. ML-DSA-65 signs every memory, and ML-KEM-768 protects sharing.
Non-custodial. The hosted service at https://saihm.net provides the durable storage, yet only ever holds ciphertext and never a key.
Erasure that travels. Each forget also writes a notice, so anything built from that memory — an index, a mirror, an extracted fact — can drop it too.
Fast recall on your device. With the standard setup, this client keeps a local copy of the memories you have already opened, so a recall fetches only what is new. That copy is not encrypted, only your user account can read it, and forget removes a memory from it too.
Everything encrypted at rest, if you prefer. Set SAIHM_RECALL_CACHE=0 and this client keeps no local copy, so every memory SAIHM holds at rest is ciphertext. The trade-off is speed: each recall then fetches all your memories again.

The technical reference has the security model, where the encrypted memories are stored, and every setting.

Configuration

Most people need none: the blocks above set the one setting that matters, and the rest have working defaults. Every setting is listed in the reference.

For developers

Use SAIHM from your own Node.js code. The developer reference covers identity records, following shares, changes to your own cells, warm start, structured tool results and errors.

npm install @saihm/mcp-server-pro

import { SaihmProClient } from '@saihm/mcp-server-pro';

// Boot from env: SAIHM_ENDPOINT_URL, SAIHM_MASTER_SECRET_FILE (or _HEX)
//   self-onboard (recommended): + SAIHM_PAYMENT_METHOD + SAIHM_TIER (omit SAIHM_AUTH_HEADER)
//   static token (advanced):    + SAIHM_AUTH_HEADER="Bearer <JWT>"
const saihm = SaihmProClient.bootFromEnv();

// Store — encrypted before it leaves the process.
const { cellId } = await saihm.remember('remember this');

// Recall — decrypted after it returns.
const cell = await saihm.recallOne(cellId);
console.log(cell?.plaintext); // 'remember this'

// Recall everything (client-side keyword filter; the endpoint has no plaintext to filter on).
const matches = await saihm.recall('this');

// Update an existing cell (a fresh monotonic sequence is issued automatically). When the endpoint reports
// shares of the cell left on the previous version, `shares` in the result reports their re-issue.
await saihm.remember('new contents', { cellId });

// Forget — crypto-shred.
await saihm.forget(cellId);

// Share a cell with another agent, end-to-end authenticated. Pin the grantee's agentIdHash
// out-of-band; the library rejects directory key-substitution.
await saihm.share({
  cellId,
  recipientRecord, // the grantee's published identity record (hex)
  recipientPinnedAgentIdHashHex, // pinned out-of-band
  expiryEpoch, // optional; omit or null for no time bound
});
await saihm.revokeShare(cellId, recipientPinnedAgentIdHashHex);

// Read a cell another agent shared TO you (the recipient side of `share`). Pin the
// sharer's agentIdHash out-of-band; the library verifies the sharer's signature and
// returns null when there is no live grant (e.g. revoked, or the sharer crypto-shredded it).
const shared = await saihm.recallShared({
  sharerPinnedAgentIdHashHex, // the sharer's agentIdHash, pinned out-of-band
  sharerRecord, // the sharer's published identity record (hex)
  cellId,
});
console.log(shared?.plaintext);

// Operator-observable metadata only (no plaintext).
const status = await saihm.status();

SHM — Super-Human Memory

SAIHM keeps memory safe. SHM, Super-Human Memory, makes it work efficiently: it is the layer on top of SAIHM that organises memory and brings the right part of it forward, by meaning, before the agent asks. It keeps tasks apart and the context window clean, so one agent can take on work that today needs several, and a mistake corrected once stays corrected.

SHM runs on your side, next to your agent, over the memories your agent can read, so none of this requires your plaintext to leave home. It ranks them with hybrid retrieval and an optional local reranker, brings forward only what the current task needs, within a budget you set, and keeps what it stores encrypted under a key you hold. When a memory is erased in SAIHM, SHM removes it from its index, its caches and everything it derived from it.

npm install @saihm/shm

SHM needs Node.js 20.20 or later.

How SHM and this client fit together. SHM works through this MCP server, version 0.13.0 or later, which keeps SHM in step with your SAIHM memory:

The change feed tells SHM which of your memories were written, so SHM reads them again.
The erasure feed tells SHM which memories were erased, so SHM removes them and everything it derived from them.
Share states tell SHM which memories other agents have shared with you, and which of those shares have ended.
Structured tool results give SHM each answer in a form it checks before acting on it.
Warm start lets SHM save an encrypted snapshot of its state and pick up where it left off in a new session or on another device.

The reference lists the tools and files SHM uses.

The SAIHM manual covers both: chapter 4 for what SHM adds, chapter 5 for its levers and recipes, and chapter 9 for why to choose SAIHM and SHM together.

Support SAIHM

If SAIHM is useful to you, here is how to help it reach more people:

Star it on GitHub. Stars help other developers find SAIHM.
Share it with a colleague, your team, or anyone whose assistant keeps forgetting.
Follow @SAIHMemory on X for news and updates.
Sponsor it through GitHub Sponsors, monthly or one-time.
Follow along on YouTube: like the videos, subscribe to the channel, and turn on notifications with the bell 🔔 for new videos and updates.

Discount codes

Upgrading? Run the upgrade command in What it costs, then enter one of these codes in the promotion-code box at checkout:

| Code | Offer | |---|---| | SAIHM-90-OFF | 90% off your first payment, for new customers | | SAIHM-75-OFF | 75% off your first payment | | SAIHM-50-OFF | 50% off for four months | | SAIHM-25-OFF | 25% off for six months |

One code per checkout, while the offers last.