MCP Observatory
This server is a self-hosted MCP security/health observability tool that lets you scan, test, score, record, replay, verify, and monitor other MCP servers directly from an AI agent.
Inventory scans —
scanauto-discovers configured MCP servers (Claude configs,.mcp.json) and verifies tools/prompts/resources;deepinvokes safe tools,securityanalyzes schemas.Targeted testing —
check_serverlaunches a specific server by command, runs all capability checks, and saves a run artifact.Grading —
score_serverreturns a 0–100 health score with A–F grade across protocol compliance, schema quality, security, reliability, performance.Regression detection —
diff_runscompares two artifacts for breakages, fixes, schema drift, and gate changes;watchre-checks a server and diffs against its last run.Baseline workflows —
recordcaptures JSON-RPC traffic to a cassette;replayre-runs checks offline;verifyconfirms a live server still matches a cassette.Contract locking —
lock_verifychecks live servers against a saved lock file to catch drift and breaking changes.History & reporting —
get_historyshows score trends;get_last_runretrieves the latest run plus handshake allow/deny;ci_reportgenerates CI regression reports.Stack recommendations —
suggest_serversscans your directory for languages, frameworks, DBs, and cloud providers and cross-references the MCP registry to recommend missing servers.
Generates human-readable Markdown reports from MCP server test runs and comparison artifacts for sharing and documentation.
Free, open-source MCP security testing from ClearFrame. MCP Observatory is the CI-native security tool for teams shipping custom MCP servers. Test during development, catch schema drift, simulate attacks, and generate compliance evidence — before agents depend on your servers.
Also available in Simplified Chinese.
Runtime enforcement: Use mcp-seatbelt to block dangerous MCP tool calls at runtime based on observatory scan results.
Get Started
Step-by-step setup guide · macOS, Windows, Linux · Node.js 20+ and npm (install Node.js LTS).
1. Run your first scan
Open Terminal or PowerShell in your project folder and paste:
npx -y @kryptosai/mcp-observatory@latestThis downloads Observatory and checks your first configured MCP server. With no configured server, it uses an included example. To try only that example, run npx -y @kryptosai/mcp-observatory@latest demo --example.
2. Read the result
The terminal shows the target, grade, findings, and saved receipt path. Failed checks are findings to review, not a request to pay. If connection failed, fix the startup command or credentials and rerun. A demo grade describes the example, not your own server.
3. Review locally, then continue in ClearFrame
npx -y @kryptosai/mcp-observatory@latest dashboard
npx -y @kryptosai/mcp-observatory@latest clearframeThe dashboard shows your local scan history, HTML reports, and JSON downloads. No account, upload, subscription, or time-based retention limit. Stop it with Ctrl+C.
The clearframe command writes a private instruction file and prints a read-only CLI command. Review the file, then run that command or paste it into a new ClearFrame Mac chat with your project open. It does not launch ClearFrame or upload evidence automatically.
Get ClearFrame CLI or the Mac app · Currently Apple Silicon Mac. ClearFrame has its own account and usage terms; all Observatory features work without it.
MCP Observatory is free and MIT licensed. Product telemetry is off by default and makes no telemetry network request before explicit opt-in. Use telemetry preview to inspect fields or telemetry enable to opt in. Privacy details.
npx -y @kryptosai/mcp-observatory@latest test npx -y @modelcontextprotocol/server-everything- uses: KryptosAI/mcp-observatory/action@v1If this repo is an MCP package, that tests npx -y <package.json name>. Otherwise set command:.
Or generate a full workflow: npx -y @kryptosai/mcp-observatory@latest setup-ci --all --command "npx -y my-mcp-server" --sarif
Install: npx -y @kryptosai/mcp-observatory@latest · brew tap kryptosai/mcp-observatory https://github.com/KryptosAI/mcp-observatory && brew install mcp-observatory · docker pull ghcr.io/kryptosai/mcp-observatory:latest · curl -fsSL https://raw.githubusercontent.com/KryptosAI/mcp-observatory/main/scripts/install.sh | sh
docker run --rm ghcr.io/kryptosai/mcp-observatory:latest demo
docker run --rm ghcr.io/kryptosai/mcp-observatory:latest test npx -y @modelcontextprotocol/server-everythingScanning a server on the host needs network and, for local files, a volume mount (-v "$PWD:$PWD" -w "$PWD").
Agents: npx -y @kryptosai/mcp-observatory@latest serve
Default-deny connect: npx -y @kryptosai/mcp-observatory@latest protect rewrites every discovered client config (Cursor, Claude, VS Code, .mcp.json, …). Undo: protect --undo. HTTP/SSE servers are left alone.
Runtime deny-default: npx -y @kryptosai/mcp-observatory@latest enforce --start-proxy writes a Seatbelt policy from the scan and starts the proxy. Local scan stays free.
Proof: Safety Index. Local history, evidence export, CI, and remediation task preparation are free.
Related MCP server: mcp-deprecate
Learn from production usage
Connect real tool calls to user intent with the usage-learning SDK and CLI: sanitized invocation evidence, opted-in “asked / expected / got” reports, selected conversation excerpts, one-click dissatisfaction flags, intent grouping across captured requests, and regression-case export. Run mcp-observatory usage review --dir private-usage to inspect linked evidence in a loopback-only browser screen. Server logs cannot reveal unshared conversations; observed execution and inferred breakdown signals stay separate. Collection is local and requires explicit integration.
Why MCP Observatory
MCP servers are becoming production dependencies. If agents rely on them, teams need a way to catch broken tools, unsafe schemas, schema drift, slow responses, and security footguns before those failures reach users.
Observatory gives maintainers and teams:
One-command CI setup with
setup-ci --allProfile-mapped audits with
audit --profile nsa-mcpMCP receipts that package target, evidence, verdict, action, and reproduction commands
MCP risk graphs that group servers by capability boundary, receipt state, CI posture, and recommended action
Action receipts that say
allow,gate,rerun,quarantine, orescalateGitHub PR comments for compatibility, drift, and security findings
GitHub Code Scanning SARIF for normalized MCP findings
Health score badges for public trust signals
Record/replay/verify workflows for regression testing
MCP server mode so agents can inspect other MCP servers directly
Review and remediation with free local history, CI, and optional ClearFrame CLI or Mac tasks
See GitHub Code Scanning for MCP servers, MCP Receipts, Troubleshooting, Safety Methodology, MCP Server Safety Index, MCP Observatory Contributors, hosted client contract, repository boundary, open-source policy, and free project policy.
Self-Assessment
We scan ourselves with mcp-observatory on every release. See results →
Self-hosted evidence
The MIT-licensed hosting source includes private receipt storage, GitHub sign-in, multi-target history, downloads, hosted HTTP checks and retention cleanup. Deploy it with your own configuration; no Observatory subscription is required. The account-free local dashboard is the fastest start.
Free tools for maintainers and teams
All scanner features, source audits, skill scans, package-name review, cross-server capability review, receipts, record/replay, local dashboards, and CI integrations are open source under MIT. No hosted account or private API is needed.
# Inspect local code without executing it
npx -y @kryptosai/mcp-observatory@latest source-audit ./src
# Review a launch package name without running it
npx -y @kryptosai/mcp-observatory@latest package-check -- npx -y your-mcp-package
# Review capability combinations across saved receipts
npx -y @kryptosai/mcp-observatory@latest toxic-flow first-receipt.json second-receipt.jsonThese checks identify review candidates; they do not prove a server is safe. See coverage and competitor feature evidence, ClearFrame workflow, and project policy.
How It Compares
Feature | mcp-observatory | Snyk agent-scan | Cisco mcp-scanner | agent-shield |
MCP-native | ✓ | ✓ | ✓ | ✓ |
Attack simulation | ✓ | ✗ | ✗ | ✗ |
Schema drift detection | ✓ | ✗ | ✗ | ✗ |
Record/replay/verify | ✓ | ✗ | ✗ | ✗ |
Health scoring (0-100) | ✓ | ✗ | ✗ | ✗ |
SARIF output | ✓ | ✓ | ✓ | ✓ |
CI/CD native (setup-ci) | ✓ | ✓ | ✓ | ✓ |
Public Safety Index | ✓ | ✗ | ✗ | ✗ |
Runtime enforcement via mcp-seatbelt | ✓ | ✗ | ✗ | ✗ |
Quick Start
Run a first check. No arguments starts demo (your servers, or the packaged local demo):
npx @kryptosai/mcp-observatoryGo deeper — also invoke safe tools to verify they actually run:
npx @kryptosai/mcp-observatory scan deepTest a specific server:
npx @kryptosai/mcp-observatory test npx -y @modelcontextprotocol/server-everythingAdd it to Claude Code as an MCP server:
claude mcp add mcp-observatory -- npx -y @kryptosai/mcp-observatory serveOr add it manually to your config:
{
"mcpServers": {
"mcp-observatory": {
"command": "npx",
"args": ["-y", "@kryptosai/mcp-observatory", "serve"]
}
}
}Commands
Command | What it does |
| Auto-discover servers, check them, and run safe attack-readiness simulation by default |
| Scan, run safe attack simulation, and also invoke safe tools to verify they execute |
| Test one server and emit an action receipt by command or target config |
| Record a server session to a cassette file for offline replay |
| Replay a cassette offline — no live server needed |
| Verify a live server still matches a recorded cassette |
| Compare two run artifacts for regressions and schema drift |
| Watch a server for changes, alert on regressions |
| Detect your stack and recommend MCP servers from the registry |
| Start as an MCP server for AI agents |
| Snapshot MCP server schemas into a lock file |
| Verify live servers match the lock file |
| Show health score trends for your MCP servers |
| Create a GitHub Action and badge snippet for MCP compatibility/security checks |
| Generate a workflow that uploads normalized findings to GitHub Code Scanning |
| Inspect whether the repository has a complete CI adoption kit |
| Inspect or control product telemetry and deliberately provide a contact email |
| Merge receipts and run artifacts into JSON, Markdown, and HTML MCP risk graphs |
| Opt out of the default safe attack simulation on |
| Generate CI report for GitHub issue creation |
| Generate a static production/security report from run artifacts |
| Score an MCP server's health (0-100) |
| Generate an SVG health score badge for README |
| Browse local scan history, reports, and downloads without an account |
| Prepare a local review task for ClearFrame CLI or Mac |
| Legacy hosted account compatibility and free local alternatives |
Run with no arguments to start demo. Use --menu for the interactive catalog.
What It Does
Check capabilities — connects to a server and verifies tools, prompts, and resources respond correctly.
Invoke tools — goes beyond listing. Actually calls safe tools (no required params / readOnlyHint) and reports which ones work and which ones crash.
npx @kryptosai/mcp-observatory scan deepDetect schema drift — diffs two runs and surfaces added/removed fields, type changes, and breaking parameter changes.
npx @kryptosai/mcp-observatory diff run-a.json run-b.jsonRecommend servers — scans your project for languages, frameworks, databases, and cloud providers, then cross-references the MCP registry to suggest servers you're missing.
npx @kryptosai/mcp-observatory suggestOr ask your agent "what MCP servers should I add?" when running in MCP server mode.
Security scanning — analyzes tool schemas for dangerous patterns: shell injection surfaces, broad filesystem access, missing auth, and credential leakage in responses.
npx @kryptosai/mcp-observatory test --security npx -y my-mcp-serverRecord / replay / verify — capture a live session, replay it offline in CI, and verify nothing changed. Like VCR for MCP.
# Record a session
npx @kryptosai/mcp-observatory record npx -y @modelcontextprotocol/server-everything
# Replay offline (no server needed)
npx @kryptosai/mcp-observatory replay .mcp-observatory/cassettes/latest.cassette.json
# Verify the live server still matches
npx @kryptosai/mcp-observatory verify cassette.json npx -y @modelcontextprotocol/server-everythingWatch for regressions — re-runs checks on an interval and alerts when something changes.
npx @kryptosai/mcp-observatory watch target.jsonScan locations
When you run scan, it looks for MCP configs in:
~/.claude.json(Claude Code)~/Library/Application Support/Claude/claude_desktop_config.json(Claude Desktop, macOS)%APPDATA%/Claude/claude_desktop_config.json(Claude Desktop, Windows).claude.jsonand.mcp.json(current directory)
Architecture
┌─────────────────────────┐
│ MCP Observatory CLI │
│ npx @kryptosai/mcp- │
│ observatory scan │
└───────────┬─────────────┘
│
┌───────────▼─────────────┐
│ Config Discovery │
│ (Claude, Cursor, etc.) │
└───────────┬─────────────┘
│
┌─────────────────┼─────────────────┐
▼ ▼ ▼
┌─────────────────┐ ┌──────────────┐ ┌──────────────────┐
│ Security Scan │ │ Attack Sim │ │ Schema Drift │
│ (shell, creds) │ │ (tool poison)│ │ (version diff) │
└────────┬────────┘ └──────┬───────┘ └────────┬─────────┘
│ │ │
└─────────────────┼───────────────────┘
▼
┌─────────────────────┐
│ Health Score │
│ (0-100 + verdict) │
└──────────┬──────────┘
│
┌────────────────┼────────────────┐
▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ SARIF │ │ Markdown │ │ CI Gateway │
│ (Code Scan) │ │ Report │ │ (setup-ci) │
└──────────────┘ └──────────────┘ └──────────────┘CI / GitHub Action
Add Observatory to your MCP server's CI pipeline:
npx @kryptosai/mcp-observatory setup-ci --all --command "npx -y my-mcp-server" --sarif --schedule weeklyCheck the adoption kit:
npx @kryptosai/mcp-observatory setup-ci --doctorSuccessful test, run, and single-target scan checks also offer to convert the passing result into a CI adoption kit. That automatic conversion enables SARIF/Code Scanning and weekly scheduled checks by default; pass --no-ci-sarif when you only want a conservative workflow without Code Scanning upload.
Or create the workflow manually:
# .github/workflows/observatory.yml
name: MCP Server Check
on: [pull_request]
permissions:
contents: read
jobs:
observatory:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: KryptosAI/mcp-observatory/action@v1
with:
command: npx -y my-mcp-server
deep: true
security: true
comment-on-pr: false
set-status: falseGitLab CI
Runs the same test scan on merge requests and on main, publishing the SARIF as a GitLab SAST report so findings appear in the merge request security widget. This matches what setup-ci --ci-provider gitlab-ci generates.
# .gitlab-ci.yml
mcp-observatory:
image: node:22
rules:
- if: $CI_PIPELINE_SOURCE == 'merge_request_event'
- if: $CI_COMMIT_BRANCH == 'main'
script:
- npx @kryptosai/mcp-observatory test npx -y my-mcp-server --deep --security --sarif mcp-observatory.sarif
artifacts:
reports:
sast: mcp-observatory.sarifOr let the CLI write it for you:
npx @kryptosai/mcp-observatory setup-ci --ci-provider gitlab-ci --command "npx -y my-mcp-server"Action inputs:
Input | Description | Default |
| Server command to test | (optional; omit to scan discovered servers) |
| Path to target config JSON | |
| Path to MCP config file for multi-server matrix scan | |
| Also invoke safe tools |
|
| Run security analysis |
|
| Fail the action on issues |
|
| Fail the action when baseline verification detects drift |
|
| Post report as PR comment. Requires |
|
| Set a commit status check (green/red) on the HEAD SHA. Requires |
|
| Token for PR comments and commit statuses |
|
The action can comment on PRs and set commit statuses when the workflow grants write permissions. setup-ci generates read-only third-party-friendly workflows by default and lets maintainers opt into comments/statuses later. init-ci remains available as a backward-compatible alias. See action/README.md for all options.
Observatory is free and open source. Continue with ClearFrame CLI or Mac when you want an agent to help review and repair findings.
Evidence badges for MCP Observatory
MCP server maintainers can add a public compatibility/security signal to their README:
[](https://github.com/KryptosAI/mcp-observatory)Or generate a score badge from a live check:
npx @kryptosai/mcp-observatory badge npx -y my-mcp-server --output docs/mcp-health.svgSee the evidence distribution loop for the GitHub Action template, maintainer PR body, and badge rollout playbook. A badge is a public evidence signal, not a certification or endorsement.
Generate a production/security report from local run artifacts:
npx @kryptosai/mcp-observatory enterprise-report \
--account "Your Company" \
--format html \
--output observatory-enterprise-report.htmlFor clearer internal account attribution in CI, set:
MCP_OBSERVATORY_ORG=your-company.comTo deliberately associate a contact email and optional contact-channel slug with private telemetry analytics, run mcp-observatory telemetry identify --email <address> [--channel <slug>]. Setting an organization or identifying a contact does not authorize outreach.
Testing Feishu/Lark integrations? See the Feishu/Lark MCP guide.
Lock Files
$ npx @kryptosai/mcp-observatory lock # Snapshot all server schemas
$ npx @kryptosai/mcp-observatory lock verify # Verify no drift since last lockLock files are the package-lock for AI tools: commit the MCP contract, then make every tool, schema, prompt, or resource drift visible in CI. See MCP lock files.
Trend Tracking
$ npx @kryptosai/mcp-observatory history # Show health trends over timeNightly Scans
$ npx @kryptosai/mcp-observatory ci-report # Generate regression report for CIMCP Server Mode
No other testing tool is itself an MCP server. Add Observatory as a server and your AI agent can autonomously test, diagnose, and monitor your other MCP servers.
claude mcp add mcp-observatory -- npx -y @kryptosai/mcp-observatory serveYour agent gets 10 tools:
Tool | When to use it |
| Check if all your configured MCP servers are healthy |
| Test a specific server before installing or after updating |
| Get a quick health score and grade for a server |
| Capture a baseline of a working server for future comparison |
| Test against a recorded session — no live server needed |
| Confirm a server update didn't break anything |
| Check a server and see what changed since the last check |
| Find regressions between two check results |
| Retrieve previous check results for a server |
| Discover MCP servers that match your project stack |
An AI tool that checks other AI tools. It is a tool testing tools that serve tools.
Security
The MCP server runs inside AI hosts where an LLM chooses which tools to call. To prevent prompt-injection attacks:
Command allowlist: Only
npx,node,python,python3,uvx,docker,deno,bunare permitted as base executables. The CLI has no restrictions.Path validation: File-reading tools are constrained to the runs/cassettes directories.
No arbitrary execution: Use the CLI for unrestricted commands.
CLI vs MCP: Intentional Differences
Feature | CLI | MCP Server | Why |
| Polling loop | Single check + diff | Request/response doesn't support long-polling |
Interactive menu | Arrow-key navigation | Not available | MCP has no interactive UI |
Color output |
| Always plain text | MCP returns structured content |
| Renders saved artifacts | Not available | Agents read artifacts directly |
| Starts MCP server | N/A | Is the MCP server |
| Reads target config files | Inline params | MCP tools accept params directly |
| Not available (use | Available | Convenience for agents |
Compatibility
Works with any MCP server that uses standard transports:
Transport | Examples | Adapter |
stdio (most servers) | filesystem, memory, context7, brave-search, sentry, notion, stripe |
|
HTTP/SSE (remote) |
| |
Docker | All |
|
Servers needing API keys work via env in the target config. Python servers work via uvx. See the full compatibility matrix for tested servers and known issues.
Target config files
For more control (env vars, metadata, custom timeout):
{
"targetId": "filesystem-server",
"adapter": "local-process",
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "."],
"timeoutMs": 15000,
"skipInvoke": false
}npx @kryptosai/mcp-observatory run --target ./target.jsonHTTP / SSE targets
{
"targetId": "my-remote-server",
"adapter": "http",
"url": "https://mcp.example.com/mcp",
"authToken": "${MCP_SERVER_TOKEN}",
"headers": {
"X-Api-Key": "$MCP_SERVER_API_KEY"
},
"timeoutMs": 15000
}Target configs support ${VAR}, $VAR, and env:VAR references in authToken, headers, and local-process env values.
How It Compares
Feature | Observatory | |||
Auto-discover servers | ✅ | — | — | — |
Check capabilities | ✅ | — | ✅ | ✅ |
Invoke tools | ✅ | — | — | ✅ |
Schema drift detection | ✅ | — | — | — |
Record / replay | ✅ | ✅ | — | — |
Verify against cassette | ✅ | — | — | — |
Response snapshot diffs | ✅ | — | — | — |
Benchmarking / latency | — | — | ✅ | — |
Jest integration | — | — | — | ✅ |
Works as MCP server | ✅ | — | — | — |
Each tool has strengths. Observatory focuses on regression detection and CI-friendly workflows. mcp-recorder is great as a transparent proxy. MCPBench is the go-to for performance benchmarking. mcp-jest is ideal if you're already in a Jest workflow.
Prior Art
The record/replay/verify pattern is inspired by:
VCR (Ruby) — pioneered cassette-based HTTP record/replay
Polly.js (Netflix) — HTTP interaction recording for JavaScript
mcp-recorder — MCP-specific traffic recording proxy
MCPBench — MCP server benchmarking
mcp-jest — Jest-style testing for MCP servers
Limitations
Servers requiring interactive OAuth (e.g., Google Drive) need pre-authentication before Observatory can connect
Custom WebSocket transports (e.g., BrowserTools MCP) are not supported
A few servers time out or close before init — see known issues and compatibility
Works with mcp-seatbelt
Scan before you trust. Then run npx -y @kryptosai/mcp-observatory@latest enforce --start-proxy — Observatory writes a deny-default mcp-seatbelt policy and starts the proxy. Observatory validates; seatbelt enforces.
Works with agent-obs
Secure your servers with Observatory. Trace your agents with agent-obs — an open-source agent execution tracer that records every tool call, computes A-F session grades, and shows you exactly where your agents spend time, burn tokens, and hit errors. Observatory tells you if a server is safe. agent-obs tells you what your agent did with it. Free, local-first, npm install -g agent-obs.
Contributors ✨
Thanks to these amazing people who have contributed:
leemeo3 — 3 Safety Index targets (Git, Chrome DevTools, Filesystem MCP)
albatrossflyon-coder — GitHub MCP Safety Index (#201)
tanishxdev — Legacy CLI deprecation warnings (#187)
sansynx — CLI format validation (#182)
Contributing
We welcome contributors! This project follows a Contributor Covenant Code of Conduct. The fastest way to get involved:
git clone https://github.com/KryptosAI/mcp-observatory.git && cd mcp-observatory && npm install && npm testThe most common first contribution is adding an MCP server to the Safety Index (10-15 minutes). See CONTRIBUTING.md for full guidelines, code standards, and the contributor recognition ladder.
If Observatory saved you a broken deploy, consider giving it a star. It helps others find the project.
Available Tools
13 toolscheck_serverA
Use this to test a specific MCP server before installing or after updating it. Launches the server by command, checks all capabilities, and saves a run artifact for future comparison. Example: check_server({ command: 'npx -y @modelcontextprotocol/server-everything' }). Use deep=true to invoke tools, security=true to analyze schemas for vulnerabilities.
Inputs: command (required), args, deep, security.
ci_reportB
Generate a CI regression report from run artifacts.
Inputs: artifactsDir.
diff_runsA
Use this to find what changed between two server checks. Compares two run artifacts and surfaces regressions (things that broke), recoveries (things that got fixed), schema drift (added/removed/changed tool parameters), and gate status changes. Essential after updating a server.
Inputs: base (required), head (required), format.
get_historyC
Get health score trends for MCP servers from run history.
Inputs: target.
get_last_runA
Return the last Observatory run for a server, including handshake allow/deny from the local receipt. No hosted account required.
Inputs: targetId (required).
lock_verifyA
Verify that live MCP servers still match a previously saved lock file. Detects schema drift, added/removed tools, and breaking changes.
Inputs: config.
recordA
Use this to capture a baseline of a working MCP server. Records all JSON-RPC traffic to a cassette file that can be replayed offline (no server needed) or used to verify future versions haven't broken anything. Like VCR for MCP.
Inputs: command (required), args.
replayA
Use this to test a server without running it. Replays a previously recorded cassette offline and runs all checks against the recorded responses. Useful in CI or when the live server is unavailable.
Inputs: cassette (required).
scanA
Use this to check if all your MCP servers are healthy. Auto-discovers servers from Claude config files, connects to each one, and verifies tools/prompts/resources respond correctly. Use with deep=true to also invoke tools and confirm they actually execute. Returns pass/fail status for every server.
Inputs: deep, config, security.
score_serverB
Use this to get a quick health grade for an MCP server. Runs all checks (capabilities, tool invocation, security) and returns a 0-100 score with A-F grade and detailed breakdown across protocol compliance, schema quality, security, reliability, and performance.
Inputs: command (required), args.
suggest_serversA
Use this when setting up a project or wondering what MCP servers to add. Scans the working directory for languages, frameworks, databases, and cloud providers, lists currently configured servers, and cross-references the MCP registry to recommend servers you're missing.
Inputs: cwd.
verifyA
Use this after updating a server to confirm nothing broke. Connects to the live server, sends the same requests from a recorded cassette, and compares responses. Reports exactly what changed — added tools, removed parameters, different response shapes.
Inputs: command (required), cassette (required), args.
watchA
Use this to check a server and see what changed since the last check. Runs all checks, saves the result, and diffs against the previous run for the same target. Shows regressions, recoveries, and schema drift in one call.
Inputs: command (required), args.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 13 tools
Several tools overlap heavily in purpose: check_server, scan, watch, verify, and lock_verify all validate server health and/or compare against a known state. The distinctions between live check, cassette replay, lock file verification, and run-to-run diffing are subtle and could easily cause an agent to pick the wrong tool.
All names use snake_case and mostly start with a verb, but the conventions are mixed: single-word verbs (scan, record, replay, verify, watch), verb_noun (check_server, score_server, suggest_servers), get_* (get_last_run, get_history), and non-verb (ci_report). The pattern is readable but not uniform.
13 tools is well-scoped for an observability/health-check server. Each tool adds a distinct capability: scanning, scoring, recording, replaying, verifying, diffing, watching, locking, history, and CI reporting. No obvious bloat.
The toolset covers scan/check/score/record/replay/verify/watch/lock/history/CI workflows comprehensively. Minor gaps like listing/deleting run artifacts or managing lock files directly exist, but they don't cause fundamental failures.
Maintenance
Related MCP Connectors
Audit your MCP servers for poisoned tools and leaked secrets, and check AI-generated code for flaws.
Scan any MCP server for tool-poisoning, security, auth & license. Trust score before install.
Check if your MCP server is ready to publish on the MCP Registry, Smithery, or npm.
Audit MCP servers for tool poisoning and shadowing. Scan a remote server by URL or paste its tools.
Related MCP Servers
- AlicenseAqualityDmaintenanceDiagnose, secure, and benchmark your MCP servers. Zero-config CLI for Claude Code, Cursor, VS Code, and Windsurf.44MIT
- AlicenseNot gradedqualityCmaintenanceScans MCP servers for deprecated and removed protocol features, providing a dated migration checklist.6 npmMIT
- AlicenseNot gradedqualityDmaintenanceZero-dependency MCP server inspector for protocol conformance, tool annotations, and capability checks.MIT
- AlicenseNot gradedqualityBmaintenanceValidates .mcp.json and claude_desktop_config files to catch duplicate server names, missing binaries, invalid environment variables, and unreachable endpoints. Reports each problem along with how to fix it, so silently failing MCP servers can be diagnosed and repaired.MIT