Vet – MCP Server Security Registry

TL;DR

TL;DR: Vet is a free security registry and CLI that audits MCP servers and AI tools before you install them — trust scores, permission maps, and verification for over 136,000 tools.

Source and Accuracy Notes

⚠️ This section is MANDATORY. All links must be verified from actual source, not guessed.

• Project page: getvet.ai
• Source repository: github.com/getvetai/cli
• License: MIT (verified via GitHub API license.spdx_id)
• HN launch thread: news.ycombinator.com/item?id=47276621
• Source last checked: 2026-06-28 (commit main branch)

The Problem: Blind-Installing MCP Servers

MCP servers execute with significant system access — file I/O, shell commands, network calls, database queries. Yet most are installed without any security review. You read a README, maybe a tweet, and run npx or npm install -g. You’re trusting the author completely.

The MCP ecosystem has no built-in mechanism to answer the basic question: “Is this server safe to install?”

Vet was built to answer that question directly.

What Is Vet?

Vet is an open-source security registry and CLI tool for AI skills and MCP servers. At its core is a database of over 136,000 AI tools and MCP servers, each with a trust score, permission breakdown, and security report. The CLI lets you audit any package — npm, GitHub repo, or local file — against this registry in seconds.

The registry is free to browse at getvet.ai. A free API key unlocks programmatic access to tool schemas.

Verification Levels

Vet assigns every tool in the registry a verification level:

| Level | Badge | Meaning | |-------|-------|---------| | L2 | ✅ Verified | Installs, boots, tools discovered and tested | | L1 | 🔍 Boots | Installs and boots successfully | | L0 | ⚠️ Indexed | Cataloged, not yet verified |

This gives you an at-a-glance signal before you run anything.

Setup Workflow

Install the CLI

npm install -g @getvetai/cli

Or run without installing:

npx @getvetai/cli scan .

Scan an npm package

vet scan @modelcontextprotocol/server-filesystem

This checks the registry first for instant results. If the package is in Vet’s database, you get its trust score, permissions, and security notes immediately.

Request a deep scan

If a package isn’t in the registry yet, request a deep scan from Vet’s backend:

vet scan @modelcontextprotocol/server-filesystem --deep

Scan a GitHub repo

vet scan https://github.com/modelcontextprotocol/servers

Audit a local project

Vet can discover all MCP configurations in a project directory and audit every tool at once:

vet audit ./my-project

Auto-discovers configs from: Claude Desktop, Cursor, VS Code, Windsurf, Cline, Zed, Continue, OpenClaw.

Strict mode — fails the build if any tool is unverified or flagged:

vet audit --strict

Search the registry from CLI

vet find "browser automation"
vet find "database access" --limit 20
vet find "file management" --type mcp

What Vet Detects

Permission categories:

• Shell execution
• File I/O
• Network access
• Browser control
• Database queries
• Crypto operations

Security issues:

• Destructive commands
• Remote code execution vectors
• Dynamic eval usage
• Credential patterns in code
• Elevated privilege requests

MCP-specific analysis:

• Tool parameter analysis
• Transport detection (stdio / HTTP / SSE)
• Runtime environment detection
• Environment variable requirements
• API key dependencies
• Docker dependencies

Deeper Analysis

Why This Matters for AI Tooling

MCP servers are composable by design. A single agent might run 5–10 servers simultaneously, each with file system or network access. The attack surface is the sum of all servers. If one is malicious or simply poorly written, your agent’s context — which often includes conversation history, secrets, and workspace files — is exposed.

Traditional package managers (npm, PyPI) verify package integrity but not behavior. Vet’s innovation is mapping what a tool actually does at runtime: what files does it read, what network calls does it make, what system resources does it touch?

The Registry Is Open

You don’t need an account to browse getvet.ai or use basic scan results. API access (free tier available at getvet.ai/dashboard) unlocks bulk schema fetching and programmatic integration into CI pipelines.

The CLI itself is MIT-licensed and the registry data is browsable. This is a genuine open security resource, not a hosted-only SaaS with a locked dataset.

Practical Evaluation Checklist

• Install the CLI: npm install -g @getvetai/cli
• Scan your most-used MCP server: vet scan @modelcontextprotocol/server-filesystem
• Audit your current project: vet audit .
• Run in strict mode before committing: vet audit --strict
• Get an API key at getvet.ai/dashboard for CI integration
• Subscribe to new L2 verifications for tools you depend on

Security Notes

• Vet performs static analysis and registry lookup — it does not execute the tools it scans
• Deep scans (--deep) are performed in an isolated environment on Vet’s infrastructure
• Trust scores reflect community verification progress, not a security guarantee
• Always review the permission map yourself for high-stakes environments
• The registry accepts community contributions for new tool verification

FAQ

Q: Does Vet run the MCP server to analyze it? A: No. The basic scan uses static analysis and registry lookup. Deep scans run in an isolated sandbox environment, not on your machine.

Q: How does Vet get its trust scores? A: Trust scores are based on verification level (L0/L1/L2), community reports, and automated security checks. Higher verification levels and no reported issues produce higher scores.

Q: Can I self-host Vet’s registry? A: The CLI works offline with --offline for local-only analysis. The full registry-backed checks require access to getvet.ai’s backend.

Q: What MCP clients does Vet support? A: The vet audit command auto-discovers MCP configurations from Claude Desktop, Cursor, VS Code, Windsurf, Cline, Zed, Continue, and OpenClaw.

Q: Is the API free? A: Yes, a free tier is available at getvet.ai/dashboard with rate-limited access to tool schemas and bulk lookups.

Conclusion

Vet solves a real and growing problem: the MCP ecosystem ships tools with broad system access and no standardized security signal. With a free registry of 136K+ tools, a local-first CLI, and verification levels you can reason about, Vet brings the trust infrastructure that npm and PyPI never built for AI agents.

If you run MCP servers in any workflow, vet scan before npm install is a habit worth building.