APEX PSI MCP Server
<p align="center"><img src="https://raw.githubusercontent.com/kawal393/apex-psi-mcp-server/main/assets/apex-psi-icon.png" alt="APEX PSI mark: a check inside a hexagonal seal" width="96" height="96"></p>
# APEX PSI MCP server
[](https://mcprush.com/to/apex-psi-mcp?ref=badge)
> **Apex PSI is not a tool and not a product. It is the verification substrate — the layer beneath proof. It does not judge. It does not certify. It only remembers.** This server is one application built on that layer.
Machine-readable setup for agents and directory scrapers: [llms-install.md](https://github.com/kawal393/apex-psi-mcp-server/blob/main/llms-install.md).
One config line gives any MCP-capable agent (Claude, Cursor, Qoder, Cline, Windsurf, and the rest) five evidence tools: `seal`, `verify`, `anchor`, `cite`, `verify_chain`.
A seal records the SHA-256 hash of a decision, document or artefact in a public append-only ledger and returns a receipt. Anyone can look that hash up again — free, forever, with no account, no key and no cooperation from us.
**What a receipt proves:** that this exact content existed at this timestamp, and has not changed since.
**What it never proves:** that the content is true. A seal is an audit trail, not a verdict.
## Tools
| Tool | What it actually does |
|------|-------------|
| **seal** | Writes the record's SHA-256 hash to the ledger and returns a receipt carrying an Ed25519 signature over the Merkle leaf, an ML-DSA-65 post-quantum signature, and — when a slot is available — an LMS-W4-SHA256 signature. The receipt's own `algorithm` field states which of those it got. |
| **verify** | Looks a hash (or a whole receipt) up in the ledger and reports whether it is present and unchanged. Integrity, not truth. |
| **anchor** | Reads the Bitcoin/OpenTimestamps anchoring state of the ledger's pending Merkle roots. Pass `action: "anchor"` explicitly to request that pending roots be submitted — an anchor is confirmed only when a real block is found. |
| **cite** | Turns a receipt into a citation (APA, BibTeX, MLA) that points at a public, independently checkable record. |
| **verify_chain** | Recomputes each hash's presence and Merkle continuity across a chain of receipts. A recomputation result, not an opinion. |
## Install
Add to your MCP client config:
```json
{
"mcpServers": {
"apex-psi": {
"command": "npx",
"args": ["-y", "apex-psi-mcp"]
}
}
}
```
Or locally: `npm install apex-psi-mcp`.
## Prove it works in two minutes
1. Ask the agent: *"Seal the sentence 'hello psi' with APEX PSI."*
2. Take the `decision_hash` from the receipt and paste it into the public verifier:
<https://www.ai-governance-standard.com/verify>
If the site returns the record, the seal is real. You never had to trust this server, our npm
package, or our word — which is the entire point of the protocol.
## Limits, stated plainly
Free use needs no account and no key: **20 operations per minute and 100 per day**, enforced per
server instance — a flood guard rather than a subscription quota. Above that, an API key raises the
ceiling; capacity is priced, **the finding never is**. Verification itself is unlimited and free:
running the verifier locally costs nothing at all —
[`apex-psi-verifier`](https://www.npmjs.com/package/apex-psi-verifier) on npm,
[`psi-verifier`](https://pypi.org/project/psi-verifier/) on PyPI.
## Make the seal unavoidable: the execution gate
The five tools above are available to an agent, but nothing in MCP makes an agent call them. An
agent that never calls `seal` leaves no gap in the ledger — the ledger stays complete and says
nothing about that action. If your agent can move money, send a request or write to a system, that
gap is the whole problem.
So this package also ships a **gate**: a small module that seals first and acts second, inside the
process that performs the side effect.
```js
import { createGate, createNotarySealer } from "apex-psi-mcp/gate";
const gate = createGate({ sealer: createNotarySealer(), label: "payments-bot" });
const { value, receipt } = await gate.run(
() => payments.transfer({ amount: 500, to: "acct-42" }),
{ tool: "transfer", amount: 500, to: "acct-42" },
);
```
If the seal fails, `payments.transfer` is never called — the gate throws `GateClosedError`. A gate
with no sealer configured refuses every action, because a gate nobody configured must not look like
a gate that is working.
What the gate does and does not do, stated plainly:
- It enforces the **order**: the receipt exists before the action runs.
- It cannot reach a process that never routes its side effect through it.
- It cannot attest what a model did inside a GPU; the receipt covers the action as you declared it
and the order in which the two happened.
- `createLocalSealer()` seals into an in-process hash chain with no network and no account — a local
permit, not a ledger receipt. `createNotarySealer()` returns a ledger receipt.
The same gate exists in the Python runtime as `apex_psi.ExecutionGate`. The two implementations
fingerprint the same bytes: `fingerprint({"b":1,"a":[1,2],"c":"x"})` is
`95c12ab4ca0e8f3c485ea1b1b1a2b24976d07180baf5ecad0d81b5bbaf07532b` in both, and a CI check on each
side pins that number.
## Configuration
Environment variables (both optional):
- `APEX_API_BASE` — override the notary endpoint. Default:
`https://qhtntebpcribjiwrdtdd.supabase.co/functions/v1`
- `APEX_API_KEY` — raises the daily ceiling for a workload. Never required to seal or verify.
## What this server does not do
- It does not store your content. Only the hash leaves your machine.
- It does not certify, grade, score or approve anything.
- It exposes no edit or delete path: the interface this server uses is write-once sealing plus
read-only lookup. The check that matters is yours to run — re-verify any receipt at any time, and
any change shows up as a failed lookup.
- It is not a legal opinion, and no court has agreed to accept a receipt in advance.
## Links
- **Protocol and standard:** <https://www.ai-governance-standard.com>
- **Public verifier:** <https://www.ai-governance-standard.com/verify>
- **Machine-readable summary for AI answers:** <https://www.ai-governance-standard.com/llms.txt>
- **npm:** <https://www.npmjs.com/package/apex-psi-mcp>
## License
MIT
TDQS
Scored across 5 tools
Each tool has a clearly distinct purpose: seal creates a receipt, verify checks a receipt, audit checks chain integrity, anchor handles Bitcoin anchoring, and cite formats citations. There is no overlap or ambiguity between any of the tools.
All tool names are single lowercase verbs (audit, seal, verify, anchor, cite) following a consistent pattern. This naming is uniform and predictable, making it easy for an agent to understand the action each tool performs.
Five tools is an appropriate number for this focused domain. Each tool covers a necessary operation without redundancy, and the scope is neither too thin nor too heavy.
The tool set covers the full lifecycle of a sealed receipt: creating (seal), verifying (verify), auditing (audit), anchoring to Bitcoin (anchor), and citing (cite). Since the ledger is immutable, update/delete operations are not expected, and no obvious gaps exist.