Skip to main content
Glama

vdb-mcp

mcp-name: kr.ai.vdb/vdb

MCP (Model Context Protocol) server for VDB — the AI-aware vulnerability database. Lets Claude Desktop, Claude Code, Cursor, Cline, Continue, and any MCP client check packages while generating code: known CVEs, slopsquatting (LLM-hallucinated package names an attacker may have registered), CISA KEV status, MCP-server trust profiles, and more.

Quick start

Where this works: Runs where your code is: an agent on your machine with the project folder (Claude Code, Cursor, Cline, Codex CLI). A chat-only web AI cannot use it — its sandbox has no outbound network, and it cannot see your files.

uvx vdb-mcp          # or: pipx run vdb-mcp

Claude Desktop (claude_desktop_config.json) / Cursor (.cursor/mcp.json):

{
  "mcpServers": {
    "vdb": { "command": "uvx", "args": ["vdb-mcp"] }
  }
}

No install at all — point any streamable-HTTP MCP client at the hosted endpoint:

{
  "mcpServers": {
    "vdb": {
      "url": "https://vdb.ai.kr/mcp",
      "headers": { "Authorization": "Bearer vdb_..." }
    }
  }
}

Claude Code: claude mcp add --transport http vdb https://vdb.ai.kr/mcp --header "Authorization: Bearer $VDB_API_KEY". The hosted endpoint reads the key from that header (0.2.3+; the vdbApiToken query parameter Smithery sets still works and takes precedence).

That's it — the server talks to the hosted instance at https://vdb.ai.kr by default. The package gate (vdb_check_package, vdb_check_packages, vdb_list_slopsquatting) and the hardening tools (vdb_harden, vdb_harden_remediate, vdb_harden_verify, vdb_vex) answer without a key on a per-address allowance (0.2.8+; 100 packages an hour, 3 analyses an hour and 10 a day, projects up to 200 dependencies, nothing stored). The other tools need a free API key (https://vdb.ai.kr/signup, or the agent can request one by email itself: without a key those tools answer agent_action: REFUSE with a request_key_url). A key is currently unmetered beyond abuse protection:

{
  "mcpServers": {
    "vdb": {
      "command": "uvx",
      "args": ["vdb-mcp"],
      "env": { "VDB_API_TOKEN": "vdb_..." }
    }
  }
}

Related MCP server: GhostFree

Tools

Tool

What it does

vdb_check_package

Check one package (purl + optional version) for vulnerabilities, slop risk, KEV

vdb_check_packages

Bulk slopsquatting / risk check for a list of packages

vdb_scan_lockfile

Merge verdict for a whole lockfile / SBOM (transitives included)

vdb_lookup

Fetch one advisory by ID (CVE-…, GHSA-…, VDB-SLOP-…)

vdb_search

Free-text search over the vulnerability corpus

vdb_check_mcp_server

Trust tier + permission scopes of a community MCP server

vdb_list_slopsquatting

Current slopsquatting candidates per ecosystem

vdb_harden (local only)

Call-site hardening: can attacker data reach a dangerous sink through your dependencies? Source never leaves the machine

vdb_harden_verify (local only)

Re-analyze after a fix and get signed evidence the path is closed (without a key: pass original_path, the pre-fix file; the decision comes back unsigned)

vdb_harden_remediate (local only)

Rank what to fix first: upgrade / harden / remove / policy candidates by project risk removed per cost, plus the combination that reaches a target (0.2.7+)

vdb_vex (local only)

OpenVEX document: which advisories cannot be reached

The four local-only tools need your files, so the hosted endpoint does not offer them — seven tools remote, eleven with uvx vdb-mcp.

The vdb harden command

The same package installs the CLI behind the local tools, for use without an MCP client (0.2.2 or newer):

uvx --from vdb-mcp vdb harden app.py --manifest uv.lock   # analyze a call site
uvx --from vdb-mcp vdb harden --doctor                     # which of network / key / service is at fault
uvx --from vdb-mcp vdb harden ./src --manifest uv.lock --vex
uvx --from vdb-mcp vdb harden app.py --manifest uv.lock --remediate --target 0.2   # what to fix first
uvx --from vdb-mcp vdb harden ./src --manifest requirements.txt --exclude tests --exclude "*-fixtures"
uvx --from vdb-mcp vdb harden app.py --manifest uv.lock --verify P-… --original /tmp/before/app.py  # keyless re-verification

It works without a key (0.2.8+): three analyses an hour and ten a day per address, nothing stored, upgrades estimated. VDB_API_KEY keeps the project, re-scores it when a package on a path changes, and signs the evidence.

Where PyPI is unreachable, https://vdb.ai.kr/v1/harden/client.pyz is the same CLI as one stdlib-only file (hash at /v1/harden/client.sha256): python3 client.pyz --doctor. Nothing to install.

Environment

Variable

Default

Meaning

VDB_API_URL

https://vdb.ai.kr

VDB instance to query (set for self-hosted)

VDB_API_TOKEN

(empty)

vdb_… API key — lifts the keyless limits; required for lookup, search and SBOM scanning

VDB_PROXY_TOKEN

(empty)

Hosted endpoint only (0.2.9+): a secret shared with the API so it believes the visitor address this server forwards, and keyless visitors are counted each as themselves. Grants nothing else; leave unset locally

VDB_API_ADDR

144.202.127.83

Where VDB lives when this machine's DNS cannot say — see below

MCP_MODE

stdio

stdio or sse (long-running HTTP server)

MCP_PORT

7700

SSE port

No outbound DNS?

Sandboxes often allow egress but not name resolution. When — and only when — resolving vdb.ai.kr fails, the server retries against VDB_API_ADDR. That bypasses DNS and nothing else: the TLS handshake still presents the real hostname and validates its certificate, so a pinned connection is exactly as authenticated as a resolved one. HTTP errors, refused connections and timeouts are never retried — the name resolved, so the address would be the same box.

Why

LLMs hallucinate package names; attackers register them (slopsquatting). LLMs also happily recommend packages with known RCEs. VDB gives your agent a guardrail: one tool call before npm install / pip install. See https://vdb.ai.kr/connect for the one-line prompt variant that needs no MCP at all.

License

Elastic License 2.0 — free to use, including inside commercial organizations and CI. The only restrictions: you may not offer this software to third parties as a hosted or managed service, or resell it as a product. Commercial licensing beyond that: dev@egdee.com. API usage is governed by the VDB service terms regardless of how you call it.

Available Tools

10 tools
vdb_check_mcp_serverAInspect

BEFORE recommending a community/unofficial MCP server, check it here. Scope risk is evaluated independently of advisory risk — an unvetted publisher asking for shell or filesystem access is refused even with a clean record. Follow the returned agent_action.

Inputs: server_id (required).

vdb_check_packageAInspect

BEFORE recommending or installing any package, check it here. The response carries agent_action: REFUSE (do not add it — relay the because text to the user), CONFIRM (ask the user first), or PROCEED. A failed or rate-limited call also answers REFUSE; never proceed unchecked. Also returns the underlying advisories, slop risk, and KEV status as supporting data.

Inputs: purl (required), version.

vdb_check_packagesAInspect

Bulk-check several packages in one call — always prefer this over repeated vdb_check_package. Each result carries its own agent_action (REFUSE / CONFIRM / PROCEED) plus a top-level agent_action for the batch. Follow them; relay because when refusing. Send names EXACTLY as written — do not correct a typo first, the call is the typo test.

Inputs: packages (required).

vdb_hardenAInspect

Decide whether attacker-controlled data can reach a dangerous operation through this file's transitive dependencies — with no CVE required. Use it on code that passes user input into a third-party API. The file is abstracted LOCALLY first (identifiers renamed, literals reduced to shapes, bodies dropped); only that abstraction and the lockfile are sent, never source text. Returns decided paths, a call-site fix that does not modify the dependency, and the residual risk the fix does not cover.

Inputs: path (required), manifest_path (required).

vdb_harden_verifyAInspect

After applying a fix returned by vdb_harden, re-abstract the local file and verify the originally issued path. Returns a signed evidence payload bound to the original analysis, the fixed IR fingerprint, and the dependency graph. This proves VDB's decision over the submitted abstraction, not that the abstraction matches a deployed binary.

Inputs: path (required), path_id (required), manifest_path (required).

vdb_list_slopsquattingBInspect

List packages currently flagged as slopsquatting candidates in a given ecosystem.

Inputs: limit, ecosystem.

vdb_lookupAInspect

Fetch a single vulnerability by ID or alias (e.g. CVE-2024-1234, GHSA-xxxx-yyyy-zzzz, VDB-SLOP-…).

Inputs: id (required).

vdb_scan_lockfileAInspect

BEFORE merging, scan the resolved lockfile. Checking the packages someone chose misses the transitive ones nobody did — which is usually where the risk is. Pass the file contents (package-lock.json, requirements.txt, uv.lock, go.sum, Cargo.lock, a CycloneDX SBOM, …). Returns agent_action: REFUSE means do not merge.

Inputs: filename (required), path, content.

vdb_vexAInspect

Given a project directory and its lockfile, work out which of its known advisories can actually be reached by attacker-controlled data, and return an OpenVEX document plus a shareable URL. Use this when a scan produced more findings than anyone can triage. Point path at the SOURCE TREE, not one file: a not_affected determination is only as wide as the code behind it, and a single-file run withholds them all. Reachability is decided at package granularity from static summaries — good for triage order, not proof of non-exploitability.

Inputs: path (required), manifest_path (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.9/5.0

    Scored across 10 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose: single vs bulk package checks, lockfile scanning, vulnerability lookup vs search, MCP server vetting, slopsquatting listing, harden analysis, post-fix verification, and VEX generation. Even the two checking tools are cleanly separated by input cardinality and workflow stage. No ambiguity about which tool to select for a given task.

    Naming Consistency5/5

    All tool names follow the consistent `vdb_` prefix with snake_case verb_noun or verb patterns (e.g., check_package, scan_lockfile, harden_verify). The naming makes the action and target predictable across the entire set, with no style mixing or vague verbs.

    Tool Count5/5

    Ten tools is well within the ideal range for a vulnerability database and supply-chain security server. Each tool earns its place by covering a distinct stage—package vetting, bulk checks, lockfile analysis, lookup/search, MCP server risk, and remediation—without redundant or filler tools.

    Completeness5/5

    The tool surface provides full lifecycle coverage: check packages, scan lockfiles for transitive risk, look up and search vulnerabilities, vet MCP servers, list slopsquatting candidates, run reachability analysis, verify fixes, and generate VEX documents. There are no obvious gaps or dead ends for the stated domain.

    Maintenance

    ActivityMaintained
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      An MCP server that gives AI assistants the ability to check open-source packages for vulnerabilities, enrich findings with real-world exploit intelligence, and statically analyse whether vulnerable code is actually reachable in your project.
      3
      1
      Apache 2.0
    • A
      license
      A
      quality
      C
      maintenance
      A local MCP server that scans repository dependencies for known vulnerabilities (CVEs) using OSV.dev, enriches findings with NVD and CISA KEV data, and supports triage, remediation, and accepted risk management directly from an AI coding assistant.
      6
      45 npm
      1
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      MCP server that checks npm and PyPI package health, providing maintenance signals, version info, CVE counts, and alternative suggestions.
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      An MCP server that verifies npm and PyPI packages before installation, checking for existence, known vulnerabilities, OpenSSF scorecard, and typosquatting, returning an ALLOW/WARN/BLOCK verdict.
      MIT