CVE MCP Server provides Claude AI with access to 27 security intelligence tools spanning 21 APIs. This production-grade Model Context Protocol (MCP) server, built in Python, connects Claude Desktop or Claude Code to sources like NVD for CVE details, EPSS for exploitation probability scores, CISA Known Exploited Vulnerabilities (KEV) catalog, MITRE ATT&CK framework, Shodan for network exposure, VirusTotal for malware checks, and GreyNoise for noise filtering. With 518 GitHub stars, the project sits at https://github.com/mukul975/cve-mcp-server, with additional details on its website at https://www.mahipal.engineer/CVE-MCP-Server/.

Security teams often spend hours triaging CVEs by pulling data from multiple sites—NVD for CVSS scores, EPSS for exploit likelihood, CISA KEV for active exploitation flags, GitHub for patches, and VirusTotal for related malware. For a batch of 50 CVEs, this manual process can consume a full day. The server addresses this by enabling Claude to query sources in parallel via stdio-based MCP, compute a composite risk score, and output prioritized recommendations with evidence citations.

Core features

The server exposes 27 MCP-compatible tools to Claude, grouped into vulnerability intelligence, network intelligence, and threat intelligence categories. Key components include:

  • Composite risk engine: Combines CVSS, EPSS, CISA KEV status, and other metrics into a single score for patch prioritization.
  • SQLite caching and audit logging: Stores responses and tracks queries to reduce API calls and enable review.
  • Async HTTP client: Uses httpx with rate limiting and response caching for efficient parallel requests to external APIs.
  • Tool coverage: Handles CVE lookups, EPSS scoring, MITRE ATT&CK tactics mapping, Shodan host searches, VirusTotal file/URL scans, and more across 21 providers.

It relies on libraries like FastMCP for MCP handling, aiosqlite for persistence, Pydantic v2 for data validation, and defusedxml for safe XML parsing. The MIT-licensed code targets Python 3.10+ and runs outbound HTTPS only, with no inbound exposure.

Architecture

The setup follows a client-server model over stdio MCP:

┌─────────────────────────────────────────────────────────────────────┐
│                        Claude Desktop / Claude Code                 │
│                         (MCP Client via stdio)                      │
└──────────────────────────────┬──────────────────────────────────────┘
                               │ Model Context Protocol (stdio)
                               ▼
┌─────────────────────────────────────────────────────────────────────┐
│                        CVE MCP Server (Python)                      │
│  ┌─────────────┐  ┌──────────────┐  ┌───────────────┐              │
│  │  27 MCP      │  │  Composite   │  │  SQLite Cache │              │
│  │  Tools       │  │  Risk Engine │  │  + Audit Log  │              │
│  └──────┬───────┘  └──────┬───────┘  └──────┬───────┘              │
│         │                │                   │                      │
│  ┌──────┴────────────────┴──────��────────────┴─────┐               │
│  │              Async HTTP Client (httpx)            │               │
│  │         Rate Limiter · Response Cache             │               │
└──────────────────────┬───────────────────────────┘               │
                       │ HTTPS (outbound only)
         ┌─────────────┼───────────────────────────┐
         ▼              ▼                           ▼
┌──────────────┐ ┌──────────────┐            ┌──────────────┐
│ VULNERABILITY│ │   NETWORK    │            │   THREAT     │
│ INTELLIGENCE │ │ INTELLIGENCE │            │ INTELLIGENCE │
├───

Claude sends requests via MCP stdio. The server routes them to tools, fetches data asynchronously, caches results, computes risks, and responds. This keeps operations fast even under load.

Getting it running

Start by cloning the repository:

git clone https://github.com/mukul975/cve-mcp-server.git
cd cve-mcp-server

Requires Python 3.10+. The README's Installation section covers dependencies via pip, likely including FastMCP, httpx, aiosqlite, and Pydantic. Set up API keys next—21 sources need credentials stored in a config file (detailed in the API keys setup section). Examples include Shodan tokens, VirusTotal keys, and EPSS access.

Configuration options appear in the dedicated section, allowing tweaks for caching TTL, rate limits, or tool subsets. Launch via the Quick start instructions, typically:

python main.py

This exposes the MCP server over stdio. Pair it with Claude Desktop or Claude Code, which detect and connect automatically. Tests run with pytest (per the Running tests section). For production, monitor SQLite audit logs for query history.

Usage examples

Query Claude directly: "Should we patch CVE-2024-3400?" The server pulls CVSS from NVD, EPSS score, CISA KEV status, Shodan exposures, VirusTotal detections, and MITRE mappings. Claude receives structured data and generates a response like: "High risk (composite score 8.7/10): Actively exploited per CISA KEV, 0.45 EPSS, Palo Alto patch available on GitHub."

Batch triage works too: "Prioritize these 10 CVEs." Parallel queries yield a ranked list with evidence. The risk score factors CVSS base/temp, EPSS probability, KEV flags, and recency—fully explained in the project's Risk score explained section.

Data sources

Tools draw from 21 APIs:

Category Examples
Vulnerability NVD, EPSS, CISA KEV, VulnDB
Network Shodan, GreyNoise, Censys
Threat VirusTotal, MITRE ATT&CK, AbuseIPDB

Full catalog in the Tool catalog section lists all 27, with MCP schemas for Claude integration.

Who this is for

Security analysts, threat hunters, or DevSecOps teams using Claude for triage fit best. If you handle CVE reviews daily and want AI-assisted correlation without browser tab overload, connect this server. It suits self-hosted setups on laptops or servers, assuming API key budgets (free tiers exist for many sources). Teams scripting Claude Code benefit from stdio MCP.

Not ideal for non-Claude users—MCP ties to Anthropic's ecosystem. Beginners without API keys face setup hurdles. It's heavier than basic CVE lookup scripts due to the full toolset and caching.

Security and privacy

Outbound HTTPS only; no ports open. SQLite stores cache and anonymized logs (query IDs, timestamps, no PII). Defusedxml prevents XXE attacks. Rate limiting avoids API abuse. Review the Security and privacy section for audit controls.

Known limitations and roadmap

Docs note rate limits on free API tiers, potential downtime from upstream providers, and US-centric sources. Roadmap covers more tools, Docker images, and Helm charts (per Roadmap section). Troubleshooting addresses common issues like key validation or cache corruption.

Compared to standalone tools like cve-search or EPSS API wrappers, this integrates everything for Claude users but requires MCP knowledge. Lighter alternatives exist for single-source queries, like direct NVD APIs or Trivy for scans. For non-AI workflows, scripts with Vulners.io aggregate similarly without the overhead.

The GitHub repo and website hold full docs, tests, and contribution guidelines. Developers can extend tools via the architecture. If MCP or security APIs feel niche, skip it—otherwise, it streamlines triage for Claude setups. (892 words)

View on GitHub →Official Website →