We weren’t planning to build this. That’s probably the most honest way to start.

The Backstory

We needed to evaluate the security posture of our network. Nothing fancy - just the usual due diligence. What firmware is running on the router, the access points, the NAS. Are there known vulnerabilities? Public exploits? The kind of thing you’d check before sleeping soundly at night.

If you’ve been around the security scene long enough, you remember the drill. Search NVD. Cross-reference ExploitDB. Maybe check Metasploit modules. Open fifteen tabs. Squint at CVSS scores. Try to figure out if that GitHub PoC from six months ago actually works or if it’s going to curl something to a sketchy IP when you run it.

We’d done this dance enough times over the years - going back to the milw0rm days, if that dates us - that we’d already built our own aggregator. That’s EIP. One place where NVD, ExploitDB, Metasploit, GitHub PoCs, CISA KEV, and EPSS scores all converge. The idea was simple: stop context-switching across a dozen sources and just have the answer.

But the MCP server? That was an accident.

The Moment

We’d been experimenting with the Model Context Protocol - Anthropic’s open standard that lets AI assistants call external tools. We wired up a quick MCP server against the EIP API, tested it, got it working, and then moved on to other things. Left the connector enabled in our Claude setup. Forgot about it.

A few days later, we were doing a firmware review on our network. We had Claude Code helping us work through the network inventory - checking versions, looking up model numbers, the usual. At some point, the agent needed vulnerability data. It saw the EIP MCP connector was still enabled from our earlier tinkering. Without being asked, it started querying the platform. It pulled CVE data for the firmware versions. Checked for public exploits. Cross-referenced EPSS scores. Verified nothing was on CISA’s Known Exploited Vulnerabilities list.

Then it came back with a clean report. No known vulnerabilities with public exploits for any of the firmware versions running on our network.

We sat there for a second. The agent had just done - autonomously, in the background, as part of a larger task - what would have taken us the better part of an afternoon. And it did it because a tool happened to be available.

Cool, we thought. Let’s flesh this out.

What It Became

That throwaway connector is now the EIP MCP Server - a proper implementation that exposes the full platform through 17 structured tools. Any MCP-compatible client gets access to:

  • 354K+ CVEs with CVSS and EPSS scoring
  • 115K+ exploits ranked by quality - Metasploit modules first, then verified ExploitDB, then GitHub PoCs by stars
  • 4,600+ CVEs exploited in the wild from CISA KEV, VulnCheck KEV, and InTheWild.io
  • Ransomware attribution - 565 CVEs with confirmed ransomware campaign use
  • AI analysis of 61K+ exploits - attack type, complexity, reliability, and trojan detection
  • Nuclei templates and recon dorks (Shodan, FOFA, Google) for scanning
  • Pentest report generation with formatted findings

The install is one line:

pip install eip-mcp

Or if you don’t want to install anything, there’s a live remote endpoint you can point any MCP client at directly:

https://mcp.exploit-intel.com/mcp

No API key. No signup. Just connect and query.

What Makes It Different

We’ve seen plenty of “AI + security” demos. Most of them are wrappers around a search bar. What made the firmware review moment click wasn’t just that the data was there - it’s that the agent could reason about it. It didn’t just dump a list of CVEs. It correlated firmware versions with vulnerability data, checked exploit availability, assessed risk, and gave us a conclusion.

That’s the difference between a database and an intelligence platform. The data is structured enough that an AI can actually work with it - filter by severity, check exploitation probability, inspect exploit code, generate findings. It’s not a chatbot searching a website. It’s an agent with genuine access to the underlying data.

Try It

If you’re using Claude Code:

claude mcp add --transport http exploit-intel https://mcp.exploit-intel.com/mcp

If you want the remote endpoint (no install needed), add this to your MCP client config:

{
  "mcpServers": {
    "eip": {
      "type": "streamable-http",
      "url": "https://mcp.exploit-intel.com/mcp"
    }
  }
}

Then ask it something. “What critical vulns affect Fortinet with public exploits?” or “Audit my stack: nginx, postgresql, openssh” or “Show me reliable RCE exploits from this year.” See what comes back.

The MCP page has full setup instructions for Claude Desktop, Claude Code, and Cursor. The landing page on the MCP server itself has the complete tool reference.

What’s Next

Honestly? We’re not sure yet. The firmware review thing was unplanned, and the best features tend to be. We’re seeing patterns emerge - automated triage workflows, pentest report generation, vulnerability monitoring through conversational AI. Some of that will turn into proper features. Some of it will stay experimental.

This project is non-commercial. We’re not selling anything. We built EIP because we missed having an exploit archive that was fast, trustworthy, and rich with context. The MCP server is just the latest expression of that - old-school spirit, modern tooling.

If you build something interesting with it, we’d love to hear about it.