Skip to content

Docs · MCP

vetkit MCP server

Give your coding agent a code auditor. The vetkit MCP server lets any stdio-capable Model Context Protocol client connect repositories, run audits and read findings and reports.

MCP is an open standard, not a Claude-only integration. Configure a local stdio server named vetkit using the definition below, then follow your client's setup instructions. Configuration wrappers vary by client. Clients that only accept remote HTTP/SSE servers cannot connect directly; vetkit does not provide a remote MCP endpoint.

Local stdio server definition
{  "command": "npx",  "args": [    "-y",    "@vetkit/mcp"  ],  "env": {    "VETKIT_API_KEY": "<your-api-key>"  }}

Then ask your agent something like “Audit acme/payments-api and tell me what to fix first.” Reload your client and confirm that vetkit_list_repos appears in its tool list.

Requirements

  • Node.js 20.3 or newer, with npx on your PATH.
  • A vetkit account and access to the GitHub, Bitbucket Cloud or GitLab.com repositories you want to audit.
  • A vetkit API key (next step).

Create an API key

  1. Open Workspace settings → API keys in the vetkit app. Only organization owners and admins can manage keys.
  2. Name the key after where it will live, for example “MCP — laptop”.
  3. To run repository audits, select repos:read, audits:read and audits:run (or audits:write). Add repos:write to connect repositories, findings:read to read findings and reports:read to read reports. Starting or cancelling AI Evaluations requires audits:write. For a read-only agent, select only read scopes.
  4. Optionally set an expiry and a per-minute rate limit (default 60, up to 600).
  5. Copy the secret. It looks like vk_live_… and is shown once; vetkit stores only a hash.

Rotation and revocation

Rotating a key issues a new secret and keeps the old one valid for 24 hours so you can roll it out. Revoking takes effect immediately — the next request returns 401 API_KEY_REVOKED.

Install

Cursor

Merge the vetkit entry below into ~/.cursor/mcp.json (global) or .cursor/mcp.json in a project. Do not commit a project config that contains your key.

~/.cursor/mcp.json
{  "mcpServers": {    "vetkit": {      "command": "npx",      "args": [        "-y",        "@vetkit/mcp"      ],      "env": {        "VETKIT_API_KEY": "<your-api-key>"      }    }  }}

VS Code / GitHub Copilot

Merge this entry into .vscode/mcp.json, keeping your existing servers. VS Code / GitHub Copilot uses servers, not mcpServers. Start and approve vetkit from the MCP server list. Replace the key placeholder and never commit a config containing your secret.

.vscode/mcp.json
{  "servers": {    "vetkit": {      "type": "stdio",      "command": "npx",      "args": [        "-y",        "@vetkit/mcp"      ],      "env": {        "VETKIT_API_KEY": "<your-api-key>"      }    }  }}

Codex

Add these TOML sections to ~/.codex/config.toml without replacing existing settings. Codex CLI and the IDE extension share this configuration. Replace the key placeholder, restart your client and verify with codex mcp list. Keep this file private.

~/.codex/config.toml
[mcp_servers.vetkit]command = "npx"args = ["-y", "@vetkit/mcp"] [mcp_servers.vetkit.env]VETKIT_API_KEY = "<your-api-key>"

Claude Code

Terminal
claude mcp add --transport stdio vetkit -e 'VETKIT_API_KEY=<your-api-key>' -- npx -y @vetkit/mcp

Add --scope user to make vetkit available in every project instead of only the current one.

Claude Desktop

Open Settings → Developer → Edit Config and add vetkit to claude_desktop_config.json, then restart Claude Desktop:

claude_desktop_config.json
{  "mcpServers": {    "vetkit": {      "command": "npx",      "args": [        "-y",        "@vetkit/mcp"      ],      "env": {        "VETKIT_API_KEY": "<your-api-key>"      }    }  }}

Other MCP clients

Any client that can launch a stdio server works: run npx -y @vetkit/mcp with VETKIT_API_KEY in its environment. You can also install the package globally and run the vetkit-mcp binary directly.

Global install
npm install -g @vetkit/mcpVETKIT_API_KEY=vk_live_... vetkit-mcp

Configuration

The server is configured entirely through environment variables.

VariableRequiredDescription
VETKIT_API_KEYYesYour API key, vk_live_… or vk_test_….
VETKIT_API_URLNoAPI base URL. Default https://api.vetkit.dev. Must be HTTPS; plain HTTP is accepted only for localhost.
VETKIT_ORG_IDNoOrganization id. Each API key belongs to exactly one organization, which is used by default, so you rarely need this.
VETKIT_APP_URLNoWeb app URL used for links to audits. Default https://app.vetkit.dev.

Tools

Every tool returns readable text, and all tools except vetkit_get_report also return typed structured content. Tools carry MCP annotations, so clients can auto-approve the read-only ones. None of the tools delete anything.

vetkit_list_repos

Lists repositories connected to your organization, with the latest audit’s grade and score.read-onlyScopes: repos:read
limitnumber
Page size, 1–100. Default 25.
cursorstring
The nextCursor value from the previous page.
Example arguments
{ "limit": 10 }

vetkit_connect_repo

Connects a GitHub, Bitbucket Cloud or GitLab.com repository. For GitHub, if the vetkit GitHub App is not installed for the owner, returns outcome "installation_required" with an install URL. Private Bitbucket and GitLab repositories require an access token, which vetkit stores for later audits.writesScopes: repos:write
urlstringrequired
GitHub, Bitbucket Cloud or GitLab.com repository URL, or "owner/name" for GitHub.
accessTokenstring
Optional repository access token; required for private Bitbucket or GitLab repositories. Sent to vetkit and stored for later audits.
Example arguments
{ "url": "https://github.com/acme/payments-api" }

vetkit_run_audit

Starts an audit and, by default, waits for it to finish while sending progress notifications. Connects the repository first if needed. Returns the overall grade, the grade of each suite that ran, the score and finding counts. This tool does not accept access tokens. Connect private Bitbucket or GitLab repositories first with vetkit_connect_repo and accessToken.writesScopes: repos:read, audits:read, audits:run or audits:write (+ repos:write to auto-connect)
repostringrequired
Repository id, "owner/name" for GitHub, or a GitHub, Bitbucket Cloud or GitLab.com URL. GitHub URLs can include /tree/<branch>.
mode"QUICK" | "FULL"
"QUICK" runs a free Quick Scan (10 a month per workspace owner: posture, gitleaks and osv on the latest commit of the default branch). "FULL" runs a full scan for 1 credit, charged to the workspace owner. Defaults to "QUICK", or "FULL" when ref, suites or analyzers are given.
refstring
Branch, tag or commit SHA. Defaults to the ref in the URL, then the default branch.
suitesstring[]
Choose from "security", "quality", "sustainability", "ai-risks", "production", "privacy", "git-history". Runs available default-enabled checks in the selected suites; explicitly selecting privacy or git-history also includes their available opt-in checks. Use analyzers for an exact selection. Defaults to the repository setting.
analyzersstring[]
Exact checks to run, by id (see Checks below); overrides suites. At least one check other than ai-signal.
excludeAssetsboolean
Skip downloading images, video, audio, 3D models, fonts, design files and PDFs. Defaults to the repository setting.
waitboolean
Wait for a terminal status. Default true.
timeoutSecondsnumber
Maximum wait, 10–1800. Default 600. The audit keeps running after a timeout.
Example arguments
{ "repo": "acme/payments-api", "ref": "main", "suites": ["security"] }

vetkit_list_checks

Lists every check grouped by suite, with the tool and version it uses, whether it is available on the server and which checks run by default.read-onlyScopes: audits:read

No arguments.

Example arguments
{}

vetkit_get_audit

Returns status, overall and per-suite grades, score, finding counts and per-check progress — including metrics such as the duplicated-code share, average complexity, test-to-code ratio and bus factor — for one audit.read-onlyScopes: audits:read
auditIduuidrequired
The audit id returned by vetkit_run_audit.
Example arguments
{ "auditId": "0192f3a4-5b6c-7d8e-9f01-23456789abcd" }

vetkit_list_findings

Lists findings for an audit, most severe first. Returns a compact table as text and full details — message, redacted snippet, remediation, references — as structured content.read-onlyScopes: findings:read
auditIduuidrequired
The audit to read.
severitystring[]
CRITICAL, HIGH, MEDIUM, LOW or INFO.
suitestring
SECURITY, QUALITY, SUSTAINABILITY, AI_RISKS, PRODUCTION, PRIVACY or GIT_HISTORY: only findings of that suite.
categorystring[]
SECURITY, SECRETS, DEPENDENCIES, INFRASTRUCTURE, QUALITY, MAINTAINABILITY, DUPLICATION, TESTING, DOCUMENTATION, HYGIENE, LICENSES, DEPENDENCY_HEALTH, ACTIVITY, HALLUCINATION, UNFINISHED_CODE, VIBE_STACK, LLM_SECURITY, RESILIENCE, DATABASE, OPERABILITY, WEB_ASSETS, AI_SIGNAL, PRIVACY_EXPOSURE, PRIVACY_FLOWS or PRIVACY_LIFECYCLE.
statusstring
NEW (introduced since the previous audit) or EXISTING.
limitnumber
Page size, 1–100. Default 25.
cursorstring
The nextCursor value from the previous page.
Example arguments
{ "auditId": "0192f3a4-…", "severity": ["CRITICAL", "HIGH"] }

vetkit_suggest_fix

Proposes a minimal patch for a code finding (SAST, secrets, LLM app, IaC) with the AI provider your organization saved in vetkit, or a rule-provided fix when the analyzer supplies one. Returns a unified diff, an explanation, a confidence level and a verification status. Only a redacted window of about 60 lines is sent to the provider. Nothing is written: no branch, commit or pull request. Needs a key created by an organization administrator.read-onlyScopes: findings:write
findingIduuidrequired
Id of a code finding, from vetkit_list_findings.
providerstring
Saved AI provider to use. Defaults to the first verified connection.
Example arguments
{ "findingId": "0193b2c4-…" }

vetkit_triage_findings

Asks your organization’s saved AI provider whether up to 20 findings of an audit are likely true or false positives. Each one gets a verdict, a confidence and a short rationale that quotes a source line. Verdicts are advisory: they adjust the priority but never suppress a finding or change the score. Needs a paid plan.writesScopes: findings:write
auditIduuidrequired
The audit the findings belong to.
findingIdsuuid[]required
Up to 20 finding ids from vetkit_list_findings.
Example arguments
{ "auditId": "0192f3a4-…", "findingIds": ["0193b2c4-…"] }

vetkit_get_report

Returns the report of a finished audit: readable Markdown, a JSON summary with suite and category scores and the diff against the previous audit, or SARIF 2.1.0.read-onlyScopes: reports:read
auditIduuidrequired
The audit to read.
formatstring
markdown (default), json or sarif.
maxCharsnumber
Truncate output beyond this many characters, 2,000–500,000. Default 40,000.
Example arguments
{ "auditId": "0192f3a4-…", "format": "markdown" }

vetkit_get_standards_report

Maps an audit’s open findings to OWASP Top 10 (2021 or 2025), CWE Top 25 (2024) or OWASP Top 10 for LLM Applications (2025). Each category is fail, pass (no mapped findings from checks that can detect it) or not covered. A mapping aid, not a compliance certification.read-onlyScopes: reports:read, findings:read
auditIduuidrequired
The audit to map.
standardstringrequired
owasp-top10-2021, owasp-top10-2025, cwe-top25-2024 or owasp-llm-top10-2025.
Example arguments
{ "auditId": "0192f3a4-…", "standard": "owasp-top10-2021" }

vetkit_check_packages

Call before installing a dependency. Checks up to 50 packages of one ecosystem against the public registry, OSV advisories (including known malicious packages), CISA KEV and your organization’s policy, and returns allow, warn or block with reasons.read-onlyScopes: agent:check
ecosystemstringrequired
npm, pypi, cargo, go, rubygems, nuget or maven. Use pypi for pip and uv.
packagesobject[]required
Up to 50 packages: a name (Maven group:artifact, Go module path) and an optional exact version.
Example arguments
{ "ecosystem": "npm", "packages": [{ "name": "left-pad", "version": "1.3.0" }] }

vetkit_scan_changes

Call before committing. Scans up to 30 changed files (512 KB in total) in memory for exactly-shaped secrets, risky agent configuration and hidden instructions, unfinished code, and imports of packages that do not exist. Nothing is stored or run.read-onlyScopes: agent:check
filesobject[]required
Changed files: a repository-relative path such as src/app.ts and the full UTF-8 content.
Example arguments
{ "files": [{ "path": "src/config.ts", "content": "…" }] }

Agent guardrails

Two tools let a coding agent check its work before it acts: vetkit_check_packages before it installs a dependency and vetkit_scan_changes before it commits. Both need an API key with the agent:check scope.

Both return a verdict of allow, warn or block with reasons. Block: the package does not exist (a hallucinated or slopsquatted name), has a known malicious-package record in OSV, has a CISA KEV advisory when your policy blocks known-exploited vulnerabilities, uses a license on your organization’s deny list, or the change contains a committed secret. Warn: an unpublished version, a very recent release, low adoption, an advisory at or above your policy’s minimum severity, or other code findings. Sources that cannot be reached are listed as warnings; those checks are skipped, never guessed.

Claude Code hook

vetkit-mcp hook pre-tool-use reads Claude Code’s PreToolUse input, finds package installs in Bash commands and exits with code 2 when vetkit blocks a package, so Claude Code stops the command and shows the reason. Otherwise it exits 0 and prints any warnings. It fails open: without VETKIT_API_KEY, or when the API cannot be reached, it warns and lets the command run. Add it to .claude/settings.json:

.claude/settings.json
{  "hooks": {    "PreToolUse": [      {        "matcher": "Bash",        "hooks": [          {            "type": "command",            "command": "npx -y @vetkit/mcp hook pre-tool-use",            "timeout": 30          }        ]      }    ]  }}

Set VETKIT_API_KEY to a key with the agent:check scope in your shell, not in a committed file.

Cursor and other clients

The hook only checks package installs. To scan changes, and in Cursor or other clients without hooks, add a rule telling the agent to call vetkit_check_packages before installing and vetkit_scan_changes before committing. The MCP page in the vetkit app has a ready-made Cursor rule.

Checks

Five scored suites are available, plus opt-in Privacy & Data Protection (beta) and Git history suites that do not affect the grade. Each scored suite gets its own grade, and the overall score weighs Security 43%, Code quality 18%, Sustainability 11%, AI code risks 13% and Production readiness 15% — only suites that ran count, and their weights are shared among them (Security 50%, Code quality 22%, Sustainability 13% and AI code risks 15% without Production readiness; Security 70% and Code quality 30% when only those two ran). Pass check ids in analyzers, or a suite in suites.

Security

  • Check id: postureCommitted .env files, private keys and keystores, manifests without a lockfile, no security policy.Category: SECRETS, DEPENDENCIES, SECURITY
  • Check id: gitleaksAPI keys, tokens, passwords and private keys in the source tree.Category: SECRETS
  • Check id: secrets-historyCredentials committed and later removed that can still be recovered from git history. Opt-in.Category: SECRETS
  • Check id: osvKnown CVEs, malicious packages and actively exploited (CISA KEV) advisories in locked dependencies.Category: DEPENDENCIES
  • Check id: vendoredKnown-vulnerable JavaScript libraries copied into the repository.Category: DEPENDENCIES
  • Check id: eolEnd-of-life runtimes, frameworks and container base images.Category: DEPENDENCIES
  • Check id: supply-chainLockfile injection, insecure registries, risky install scripts, Trojan Source and committed executables.Category: DEPENDENCIES, SECURITY
  • Check id: sastSelected code-security rules across supported languages, plus insecure server, mobile and shell configuration.Category: SECURITY
  • Check id: sast-communityAdditional permissively licensed community rule packs. Opt-in, beta.Category: SECURITY
  • Check id: iacTerraform, CloudFormation, Kubernetes, Helm and Dockerfile misconfigurations (Trivy).Category: INFRASTRUCTURE
  • Check id: workflowsGitHub Actions script injection, over-broad permissions, unpinned actions and pwn requests (zizmor).Category: INFRASTRUCTURE

Code quality

  • Check id: code-smellsSwallowed errors, leftover debug statements, suspicious comparisons and other error-prone code.Category: QUALITY
  • Check id: complexityFunctions with high cyclomatic complexity, deep nesting, long bodies or long parameter lists.Category: MAINTAINABILITY
  • Check id: duplicationCopy-pasted blocks of code across files.Category: DUPLICATION
  • Check id: testsMissing or thin test suites, large untested files, focused or skipped tests, tests without assertions, CI that never runs tests.Category: TESTING
  • Check id: docsREADMEs without setup or usage instructions, undocumented public APIs, published packages without a changelog.Category: DOCUMENTATION
  • Check id: hygieneREADME, LICENSE, CI and .gitignore; committed build output, vendored dependencies and large files.Category: HYGIENE

Sustainability

  • Check id: licensesDependencies under copyleft (GPL, AGPL), restricted-use or unknown licenses that conflict with the project license.Category: LICENSES
  • Check id: dep-healthDirect dependencies that are deprecated, two or more major versions behind or no longer released.Category: DEPENDENCY_HEALTH
  • Check id: activityStale repositories, single-maintainer risk (bus factor) and large files that change frequently.Category: ACTIVITY

AI code risks

  • Check id: hallucinated-depsDependencies and imports that do not exist on the public registry (slopsquatting targets), versions that were never published, packages first published in the last 30 days and imports missing from package.json.Category: HALLUCINATION
  • Check id: ai-slopStubs, “rest of the code” placeholders, mock data and placeholder credentials in production paths, copy-suffixed duplicate files and blanket type or lint suppressions.Category: UNFINISHED_CODE
  • Check id: vibe-stackSupabase tables without row level security, secrets in public environment variables, unauthenticated API routes and client-side-only access checks.Category: VIBE_STACK
  • Check id: llm-appPrompt injection paths, LLM output reaching code execution, SQL or HTML, LLM API keys in client code, unbounded model calls and risky AI agent configuration.Category: LLM_SECURITY
  • Check id: ai-signalHeuristic AI-authorship signal. Beta, informational, never scored; only when enabled on the server.Category: AI_SIGNAL

Production readiness

  • Check id: resilienceOutbound HTTP calls without a timeout, blocking calls on the request path and in async functions, database clients created per request.Category: RESILIENCE
  • Check id: data-accessQueries inside loops (N+1), list endpoints without pagination, unindexed foreign keys, schema sync on startup that can drop data.Category: DATABASE
  • Check id: operabilityDeployed services that run a dev server, verify passwords without login rate limiting, or lack graceful shutdown, a health check or error tracking.Category: OPERABILITY

Long-running audits

Most audits finish in a few minutes. vetkit_run_audit polls every few seconds and sends progress notifications while it waits. Some clients cancel tool calls after a fixed time — Claude Code, for example, respects MCP_TOOL_TIMEOUT. If yours does, pass "wait": false and poll with vetkit_get_audit. When timeoutSeconds runs out, the audit keeps running and the tool returns "outcome": "still_running".

Errors

API errors come back as tool results with isError: true and include the HTTP status, vetkit error code, message, request id and a hint.

  • 401 API_KEY_INVALID, API_KEY_REVOKED, API_KEY_EXPIRED — create or rotate a key, update VETKIT_API_KEY and restart the server.
  • 403 INSUFFICIENT_SCOPE — the key lacks a scope the tool needs.
  • 409 AUDIT_CONCURRENCY_LIMIT and 429 RATE_LIMITED — wait and retry; the hint includes the delay when the API sends Retry-After.
  • 402 INSUFFICIENT_CREDITS — a full scan needs 1 credit from the workspace owner. Request more credits in the vetkit app, or run a free Quick Scan of the default branch while the monthly allowance lasts.
  • 422 ANALYZER_UNAVAILABLE — a check in analyzers cannot run on this server. Call vetkit_list_checks, or pass suites, which only picks available checks.
  • INSTALLATION_REQUIRED is returned as a normal result with the GitHub App install URL, not as an error.

Security notes

  • Treat the API key like a password. It grants access to your organization’s audits and findings, including private repositories. Keep it in your MCP client’s env config, never in files you commit. Grant only the scopes you need, set an expiry, and revoke it from the app if it leaks.
  • The key is sent only to VETKIT_API_URL, as an Authorization: Bearer header over HTTPS. The server never logs it or includes it in error messages.
  • The server speaks MCP over stdio only. It opens no network ports and logs only to stderr.
  • Finding snippets are redacted before vetkit stores them; secret values are never returned.
  • Report and finding text comes from the audited repository (file paths, messages). Treat it as untrusted input, like any other tool output — a malicious repository could try to embed instructions aimed at your agent.

Prefer raw HTTP? Everything the MCP server does is available through the REST API.

Request early access

Tell us a little about your team and the repositories you want to audit. We onboard teams in small batches and will reply by email.

We use these details only to reply to your request. Privacy policy