A native MCP inspector for macOS
Why it won't connect. And what changed since it did.
Point mcpi at an MCP endpoint and get a diagnosis instead of a generic connection error. Once you're in, every contract is recorded — so a reconnect after a release shows exactly what changed, and whether it breaks you.
The app is free: no account, no trial clock. Paid is only the hosted watching.
workspace became required: existing calls without it now fail
the Status enum lost "archived", behind a $ref that itself never changed
tool removed: anything still calling it now gets an error
optional argument added: existing callers are unaffected
description reworded: the contract itself is untouched
The app's built-in sample change. Click a tool: judgement first, evidence second.
Diagnose the connection. Classify the change.
The loud failure in MCP is connecting at all; the quiet one is a server changing underneath you. mcpi is built for both.
Every change, classified
Reconnect after a release and the diff is already there: each contract change judged breaking, compatible, or cosmetic. The same edit means opposite things in an input and an output schema, and $refs are walked — an enum gutted behind an unchanged $ref still surfaces.
Saved servers
Your server library persists: stdio and remote, with arguments, environment, and headers. OAuth tokens live in the Keychain, so reconnecting never means re-authenticating.
Call history & replay
Every call is recorded with its arguments and result. Open one from history and fire it again, unchanged, against today's build.
Collections
The handful of calls you make every time, saved as a sequence and run in one click. A run doesn't stop at the first failure; a smoke test reports everything that broke.
Forms for real schemas
Generated from each tool's input schema, handling what pydantic, schemars, and zod actually emit: nullable idioms, $refs, documented enums. Anything the form can't represent falls back to raw JSON for that field alone, and says so.
Endpoint checker
Paste an MCP URL before you ever connect. Instead of a generic connection error, mcpi reports what is actually there: wrong path, unexpected auth, or a server still speaking a deprecated transport.
Baselines & timeline
Every recorded contract sits on a timeline. Pin the build you certified as v1.2, then diff today's server against it — months and many releases later.
Built the way you'd build it
No cloud between you and your servers. Specifics you can check:
One Rust binary
The UI runs in the system WebView: no Node runtime, no Electron, no bundled Chromium.
A SQLite file on your disk
Servers, snapshots, call history, collections: one local database you can back up, inspect, or delete.
Secrets in the Keychain
OAuth tokens and API keys go to the macOS Keychain, never into the database. The store only records that a secret exists.
One classifier everywhere
The app, the CLI, and this site's server directory all run the same schemadiff crate — a diff means the same thing wherever you read it.
Questions someone always asks
Does mcpi phone home?
No. There is no account, no activation server, no licence check, and no telemetry. The only network traffic mcpi makes is to the MCP servers you point it at.
Which platforms does it run on?
macOS today. The engine is portable Rust with nothing platform-specific in it, but only the macOS build is tested, signed, and supported right now. The page says what exists, not what's imagined.
Why is the app free?
Because inspecting is table stakes: the official inspector is free and good, and charging admission next to it would be a losing argument. What nothing free does is watch a contract over elapsed time and classify what changed. That checking runs on our infrastructure and recurs, so it is the only thing that costs money.
Why should I trust it with my OAuth tokens?
Tokens and API keys go to the macOS Keychain, never into the database; the local store only records that a secret exists. Nothing leaves your machine.
Is it open source?
Yes — the app, the CLI, and the engine crates (the schema differ, the endpoint probe, the client wrapper) are on GitHub under MIT, so the parts that hold your tokens are auditable rather than asserted. What's paid is the half that runs on our infrastructure: the scheduled probing behind Statuspage and Watch.
How will the paid tiers bill?
Through Polar as merchant of record: a proper invoice, with VAT handled. Statuspage is a one-time payment per endpoint — you run a server, you pay once, it stays probed; there is no renewal to forget and nothing to cancel. Watch is a monthly subscription, because the value recurs the way the checking does, and you can cancel any time. Neither ever touches the app — cancelling Watch just stops the hosted checking.