Rapid7 Bulk Export MCP Server
OfficialThis server pulls Rapid7 Command Platform data (vulnerabilities, policies, remediations, asset software) into a local DuckDB database and lets you explore it with SQL from any MCP-compatible AI assistant.
Start exports — kick off non-blocking Rapid7 export jobs for
vulnerability,policy,remediation, orasset_softwaredata (remediation ranges auto-split into ≤31-day windows); same-day exports are reused.Track progress — poll a single export or multi-window remediation job to see platform-side status and local download/load progress.
Download & load — pull a completed export's Parquet files into DuckDB in the background, or load existing Parquet files from disk to skip the API entirely.
Query with SQL — run arbitrary DuckDB SQL over
assets,vulnerabilities,vulnerability_exceptions,policies,vulnerability_remediation, andasset_software: filter, aggregate, join, or analyze.Explore schema — list column names and data types for every loaded table before writing queries.
Get stats — instant row counts, severity distributions, CVSS ranges, exploit counts, and cloud provider breakdowns.
Review export history — list recent exports with IDs, dates, statuses, and row counts to find past exports worth reusing.
Purge data — permanently delete the vulnerability database, tracking database, and WAL files after analysis or before handing off a machine.
Analyze in natural language — pair with the AgentSkill/Kiro Power so an AI assistant translates plain-English questions into the right tool calls and SQL.
Deploy flexibly — run locally over stdio, or as a Dockerized HTTP service with OIDC bearer-token auth for shared/remote use; queries are sandboxed with filesystem and network access disabled at the DuckDB engine level.
Enables GitHub Copilot to fetch, load, and query vulnerability, asset, policy, and remediation data from Rapid7 Command Platform using natural language or SQL.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Rapid7 Bulk Export MCP Server Show me top 10 most vulnerable assets."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Rapid7 Bulk Export MCP
AI-powered analysis for Rapid7 Command Platform data using MCP (Model Context Protocol) & AgentSkills.
This tool is a best effort support, due to the bespoke and ever-changing nature of tools and workflows which would utilize this tool we cannot provide support or guidance outside of the MCP Code & AgentSkill Content.
What is This?
This tool exports data from Rapid7 Command Platform, via the Rapid7 Bulk Export API and makes it queryable in GenAI and Agentic workflows.
MCP Server: Embeds tools which allow the getting, processing and querying of data
Agent Skill / Kiro Power: Gives additional context, schema knowledge and instructions on how to use the MCP tools
DuckDB Database: Local file-based database to allow structured rapid querying
Related MCP server: tenable-mcp
Features
AI-Powered Analysis: Use with Kiro, Claude Desktop, or any MCP-compatible AI assistant
On-Demand Data Loading: Automatically fetch and load data from Rapid7
Export Reuse: Automatically reuses exports from the same day to avoid redundant API calls
Natural Language Queries: Ask questions in plain English
SQL Query Execution: Run complex SQL queries against vulnerability, asset and other data
Multiple Export Types: Vulnerabilities (with vulnerability exceptions), policies, remediations, and installed asset software
Multi-Month Remediation: Request any date range — it is split into ≤31-day windows and loaded for you in the background as a single job
Schema Exploration: Discover available data fields
Statistics & Insights: Get instant summaries and distributions
Security Lockdown: User queries are sandboxed — filesystem and network access disabled at the DuckDB engine level
Docker Support: Run as a containerized HTTP service for remote or shared deployments
Remote Authentication: Remote mode validates OIDC bearer tokens against any standards-compliant identity provider
Local vs Remote
You can run the MCP server in two modes depending on your needs:
Local (stdio) — The AI client spawns the server as a child process and communicates over stdin/stdout. This is the default and simplest option. The server runs on your machine, the database lives next to it, and everything stays local. Best for individual use on a workstation or laptop.
Remote (Docker / streamable HTTP) — The server runs as a containerized HTTP service exposing a single /mcp endpoint. Clients connect over the network via URL. Best for shared environments, team use, or when you want the server running on dedicated infrastructure separate from your AI tool. It should be noted that this will make data shareable between all users of the remote mcp, you should authenticate and secure the /mcp endpoint — see docs/authentication.md for the built-in OIDC support and docs/copilot-studio-hosting.md for an example of a private hosted deployment.
Quick Start
0. Get Your Rapid7 API Key and Region
Before you begin, you'll need credentials from your Rapid7 Insight Platform account.
Generate an API Key:
Important: The API key must be generated by a Platform Admin. The bulk export API returns all vulnerability data across the entire platform, so admin-level access is required.
Log in to the Rapid7 Insight Platform as a Platform Admin
Navigate to Administration → API Key Management
Choose the key type:
Organization Key (recommended): Full admin permissions (requires Platform Admin role)
User Key: Inherits your account permissions — must be created by a Platform Admin to have sufficient access for bulk exports
Click "Generate New Admin Key" (or "Generate New User Key" if using a Platform Admin account)
Select your organization and provide a name for the key
Copy the key immediately - you won't be able to view it again!
Find Your Region:
Your region determines which API endpoint to use. To find your region:
Go to insight.rapid7.com and sign in
Look for the "Data Storage Region" tag in the upper right corner below your account name
For more details, see:
1. Set Up Your AI Tool
Choose your AI tool below. Each guide walks through installing the MCP server, adding the Agent Skill, and verifying the connection.
Securing your API key: Avoid storing your
RAPID7_API_KEYin plaintext on disk. Use a secrets manager to inject the key at runtime — for example, 1Password CLI, Bitwarden CLI, macOS Keychain, Windows Credential Manager, or PowerShell SecretManagement. With 1Password you can set"command": "op"and"args": ["run", "--", "rapid7-mcp-server"]withop://secret references in the env block — the key is resolved from your vault and never written to config files. Adapt this pattern to whatever password manager you use.
Install the MCP Server
Open Claude Desktop and navigate to Customize → Connectors
Search for "Rapid7 Bulk Export" in the connectors directory
Click Install and provide your
RAPID7_API_KEYandRAPID7_REGIONwhen prompted

Install the Agent Skill
Go to Customize -> Skills
Click the (+)
Create Skill
Upload Skill
Upload the latest skill zipfile from the release on the right

Verify
Try:
/rapid7-bulk-export-analysis-expert Load the latest vulnerability data from Rapid7
Install the MCP Server
# Using uv
uv pip install git+https://github.com/rapid7/rapid7-bulk-export-mcp.git
# Or using pip
pip install git+https://github.com/rapid7/rapid7-bulk-export-mcp.gitConfigure
Create or edit .kiro/settings/mcp.json:
{
"mcpServers": {
"rapid7-bulk-export": {
"command": "rapid7-mcp-server",
"args": [],
"env": {
"RAPID7_API_KEY": "your-api-key-here",
"RAPID7_REGION": "your-region"
}
}
}
}Install the Power (MCP + Skill)
This repository is packaged as an Agent Plugins power (plugin.json + mcp.json + skills/), so Kiro installs the MCP server declaration and the skill together:
Open the Kiro Powers panel → Add Custom Power
Select Import power from GitHub
Enter the repository URL:
https://github.com/rapid7/rapid7-bulk-export-mcp
Kiro reads the keywords in plugin.json and activates the power automatically when you mention terms like "rapid7", "vulnerability", or "remediation". The power's mcp.json declares the rapid7-mcp-server stdio server; set RAPID7_API_KEY and RAPID7_REGION in your environment (the server inherits your shell; on macOS it can also read the key from Keychain). If you prefer to configure the MCP server by hand instead of via the power, use the .kiro/settings/mcp.json snippet shown above.
Verify
Restart or reconnect MCP servers (Command Palette → "MCP: Reconnect All Servers")
Check MCP panel for "rapid7-bulk-export" server (should show "Connected")
Try:
Load the latest vulnerability data from Rapid7
Install the MCP Server
# Using uv
uv pip install git+https://github.com/rapid7/rapid7-bulk-export-mcp.git
# Or using pip
pip install git+https://github.com/rapid7/rapid7-bulk-export-mcp.gitConfigure
Use the Claude Code CLI:
claude mcp add --transport stdio \
--env RAPID7_API_KEY=your-api-key-here \
--env RAPID7_REGION=your-region \
rapid7-bulk-export \
-- rapid7-mcp-serverOr manually edit ~/.claude.json (user scope) or .mcp.json (project scope):
{
"mcpServers": {
"rapid7-bulk-export": {
"command": "rapid7-mcp-server",
"args": [],
"env": {
"RAPID7_API_KEY": "your-api-key-here",
"RAPID7_REGION": "your-region"
}
}
}
}Use --scope user for cross-project access or --scope project for team sharing.
Install the Agent Skill
# User-level (available in all projects)
mkdir -p ~/.claude/skills/rapid7-bulk-export
curl -sL https://raw.githubusercontent.com/rapid7/rapid7-bulk-export-mcp/main/skills/rapid7-bulk-export/SKILL.md \
-o ~/.claude/skills/rapid7-bulk-export/SKILL.md
# Or project-level (only in current project)
mkdir -p .claude/skills/rapid7-bulk-export
curl -sL https://raw.githubusercontent.com/rapid7/rapid7-bulk-export-mcp/main/skills/rapid7-bulk-export/SKILL.md \
-o .claude/skills/rapid7-bulk-export/SKILL.mdOr use npx skills to install directly:
npx skills install https://github.com/rapid7/rapid7-bulk-export-mcpClaude Code will automatically discover and use the skill when relevant.
Verify
Restart Claude Code or reload the window
Type
/mcpin chat to check server statusVerify "rapid7-bulk-export" appears in the list
Try:
Load the latest vulnerability data from Rapid7
Install the MCP Server
# Using uv
uv pip install git+https://github.com/rapid7/rapid7-bulk-export-mcp.git
# Or using pip
pip install git+https://github.com/rapid7/rapid7-bulk-export-mcp.gitConfigure
Edit MCP settings in VS Code:
Use Command Palette: "MCP: Edit Configuration"
Or manually edit:
.vscode/mcp.json(workspace) or user settings
{
"mcpServers": {
"rapid7-bulk-export": {
"command": "rapid7-mcp-server",
"args": [],
"env": {
"RAPID7_API_KEY": "your-api-key-here",
"RAPID7_REGION": "your-region"
}
}
}
}Install the Agent Skill
# Project-level (recommended, stored in repository)
mkdir -p .github/skills/rapid7-bulk-export
curl -sL https://raw.githubusercontent.com/rapid7/rapid7-bulk-export-mcp/main/skills/rapid7-bulk-export/SKILL.md \
-o .github/skills/rapid7-bulk-export/SKILL.md
# Or user-level (available across all projects)
mkdir -p ~/.copilot/skills/rapid7-bulk-export
curl -sL https://raw.githubusercontent.com/rapid7/rapid7-bulk-export-mcp/main/skills/rapid7-bulk-export/SKILL.md \
-o ~/.copilot/skills/rapid7-bulk-export/SKILL.mdOr use npx skills to install directly:
npx skills install https://github.com/rapid7/rapid7-bulk-export-mcpUse the skill as a slash command: /rapid7-bulk-export.
Verify
Reload VS Code window
Check MCP status in the status bar or output panel
Try:
Load the latest vulnerability data from Rapid7
Install the MCP Server
# Using uv
uv pip install git+https://github.com/rapid7/rapid7-bulk-export-mcp.git
# Or using pip
pip install git+https://github.com/rapid7/rapid7-bulk-export-mcp.gitConfigure
Add the server using the Codex CLI:
codex mcp add rapid7-bulk-export \
--env RAPID7_API_KEY=your-api-key-here \
--env RAPID7_REGION=your-region \
-- rapid7-mcp-serverOr manually edit ~/.codex/config.toml:
[mcp_servers.rapid7-bulk-export]
command = "rapid7-mcp-server"
args = []
enabled = true
[mcp_servers.rapid7-bulk-export.env]
RAPID7_API_KEY = "your-api-key-here"
RAPID7_REGION = "your-region"If using environment variables from your shell instead of hardcoding them:
[mcp_servers.rapid7-bulk-export]
command = "rapid7-mcp-server"
args = []
enabled = true
env_vars = ["RAPID7_API_KEY", "RAPID7_REGION"]Verify
List configured servers:
codex mcp listCheck server details:
codex mcp get rapid7-bulk-exportTry:
Load the latest vulnerability data from Rapid7
Install the MCP Server
# Using uv
uv pip install git+https://github.com/rapid7/rapid7-bulk-export-mcp.git
# Or using pip
pip install git+https://github.com/rapid7/rapid7-bulk-export-mcp.gitConfigure
Edit your Antigravity MCP config file:
macOS/Linux:
~/.gemini/antigravity/mcp_config.jsonWindows:
C:\Users\<USERNAME>\.gemini\antigravity\mcp_config.json
You can also access this file from the Antigravity Agent panel → "..." → MCP Servers → Manage MCP Servers → View raw config.
Add the following to mcp_config.json:
{
"mcpServers": {
"rapid7-bulk-export": {
"command": "rapid7-mcp-server",
"args": [],
"env": {
"RAPID7_API_KEY": "your-api-key-here",
"RAPID7_REGION": "your-region"
}
}
}
}Verify
Restart Antigravity for changes to take effect
Open the MCP Servers panel ("..." menu → MCP Servers)
Confirm "rapid7-bulk-export" appears with available tools
Try:
Load the latest vulnerability data from Rapid7
Docker Image
Uses Red Hat UBI 10 Python 3.12 Minimal base image with Python 3.12.13 pre-installed. Supports read-only filesystem operation. No Red Hat subscription required.
Build and Run
The HTTP transport requires inbound authentication and refuses to start without it, because an open /mcp endpoint would share your vulnerability data with anyone who can reach the port. Set the three MCP_AUTH_* values from your identity provider; docs/authentication.md explains where to find them.
Using docker compose (recommended):
RAPID7_API_KEY=your-key RAPID7_REGION=us \
MCP_AUTH_JWKS_URI=https://idp.example.com/keys \
MCP_AUTH_ISSUER=https://idp.example.com/ \
MCP_AUTH_AUDIENCE=api://rapid7-bulk-export \
docker compose up -dUsing docker run:
# Build
docker build -t rapid7-bulk-export-mcp .
# Run with read-only filesystem
docker run -d \
-p 8000:8000 \
-e RAPID7_API_KEY=your-api-key-here \
-e RAPID7_REGION=us \
-e MCP_AUTH_JWKS_URI=https://idp.example.com/keys \
-e MCP_AUTH_ISSUER=https://idp.example.com/ \
-e MCP_AUTH_AUDIENCE=api://rapid7-bulk-export \
-e DATA_DIR=/data \
-e TMPDIR=/tmp \
-v rapid7-data:/data \
--tmpfs /tmp \
--read-only \
--security-opt no-new-privileges:true \
--name rapid7-bulk-export-mcp \
rapid7-bulk-export-mcpConfigure Your MCP Client
Point any MCP-compatible client at the HTTP endpoint:
{
"mcpServers": {
"rapid7-bulk-export": {
"url": "http://localhost:8000/mcp"
}
}
}Install the Agent Skill
Follow the skill installation for your specific AI tool above. The skill works the same regardless of whether the MCP server is local or remote.
Verify
Confirm the container is running:
docker psTest the endpoint:
curl http://localhost:8000/mcpConnect your AI tool and try:
Load the latest vulnerability data from Rapid7
2. Start Analyzing
Note: The first export takes 1-5 minutes depending on org size. Once complete, the data is cached and subsequent loads reuse the same export. You can always ask to refresh the data to get the latest set.
Show me the top 10 critical vulnerabilities with known exploitsWhat's the severity distribution across my cloud assets?Tool Reference
start_rapid7_export
Kicks off a new export job on Rapid7's servers. Returns immediately. Supports four export types: vulnerability, policy, remediation, and asset_software.
For remediation, pass a start_date and end_date (YYYY-MM-DD). Rapid7 limits each remediation export to 31 days and allows only one in flight at a time, so a longer range is split into ≤31-day windows and processed sequentially in the background as a single job. The call returns a job ID you poll with check_rapid7_export_status; all windows append into one vulnerability_remediation table.
Start a vulnerability export from Rapid7
Load remediation data from 2026-01-01 to 2026-06-30check_rapid7_export_status
Reports status once, without blocking. Depending on what the ID names, it returns the Rapid7 platform-side export status, the local download/load progress once you have started loading, or the progress of a multi-window remediation job (which window is loading, and which windows are done). Accepts either an export ID or a remediation job ID.
Check the status of export abc-123download_rapid7_export
Starts downloading a completed export's Parquet files and loading them into the local DuckDB database in the background, returning immediately — large exports can take longer than an AI client will wait on a single call. Poll check_rapid7_export_status with the same export ID until it reports the load is complete; that is when the data becomes queryable.
Download and load export abc-123load_rapid7_parquet
Loads existing Parquet files directly from disk (must be within ~/.rapid7_mcp/imports/). Useful if you already have exported files and want to skip the API call.
Load parquet files from ~/.rapid7_mcp/imports/my-export/query_rapid7
Executes SQL against the loaded data. The connection is locked down after loading — filesystem reads, writes, and network access are all blocked at the DuckDB engine level.
Available tables (depending on what you have loaded): assets, vulnerabilities, vulnerability_exceptions, policies, vulnerability_remediation, asset_software.
Run: SELECT severity, COUNT(*) FROM vulnerabilities GROUP BY severityget_rapid7_schema
Returns column names and data types for all loaded tables. Use this to understand what fields are available before writing queries.
Show me the schema of the loaded dataget_rapid7_stats
Returns summary statistics — row counts, severity distributions, CVSS score ranges, exploit counts, and cloud provider breakdowns.
Give me an overview of the vulnerability datalist_rapid7_exports
Shows recent export history with IDs, dates, statuses, and row counts. Useful for finding a previous export to reload.
List my recent exportspurge_rapid7_data
Permanently deletes both the vulnerability database and the export tracking database from disk. Use when you're done with analysis or before handing off a machine.
Purge all local Rapid7 dataArchitecture
graph TB
subgraph "AI Layer"
LLM[LLM/AI Assistant<br/>Copilot, Kiro, Claude Desktop, etc.]
end
subgraph "Rapid7 Bulk Export MCP Tool"
MCP[MCP Server<br/>rapid7-bulk-export]
Skill[Agent Skill / Power<br/>rapid7-bulk-export-skill]
end
subgraph "Data Layer"
DB[(DuckDB<br/>rapid7_bulk_export.db)]
Tracker[(Export Tracker<br/>rapid7_bulk_export_tracking.db)]
end
subgraph "Rapid7 API"
R7[Rapid7 Bulk Export API<br/>/export/graphql ]
end
LLM <-->|Model Context Protocol| MCP
LLM -.->|Enhanced Context| Skill
MCP -->|SQL Queries| DB
MCP -->|Track Exports| Tracker
MCP -->|Fetch Data| R7
R7 -->|Parquet Files| MCP
MCP -->|Load Data| DB
style LLM fill:#e1f5ff
style MCP fill:#fff4e1
style Skill fill:#f0e1ff
style DB fill:#e8f5e9
style Tracker fill:#e8f5e9
style R7 fill:#ffe1e1Development
Changes to the AgentSkill and MCP can be done locally to allow you to tailor to your environment — contributions are welcome back to this repository.
Clone and Install
git clone https://github.com/rapid7/rapid7-bulk-export-mcp.git
cd rapid7-bulk-export-mcp
uv syncConfigure for Development
Create or edit .kiro/settings/mcp.json:
{
"mcpServers": {
"rapid7-bulk-export": {
"command": "/absolute/path/to/rapid7-bulk-export-mcp/.venv/bin/rapid7-mcp-server",
"args": [],
"env": {
"RAPID7_API_KEY": "your-api-key-here",
"RAPID7_REGION": "your-region",
"DATA_DIR": "/Users/you/.rapid7-mcp"
}
}
}
}Note: Point
commanddirectly at the venv entry point rather than usinguv runwith acwd. Claude Desktop does not guarantee a working directory when launching MCP servers, souv runmay resolve to a cached or system-installed version of the package instead of your local source.
Run Tests
uv run pytestEnvironment Variables
Variable | Required | Default | Description |
| Yes | — | Rapid7 InsightVM API key |
| Yes |
| API region: |
| No |
| Directory for database files; must be writable. Manual parquet imports must be placed in |
| No |
| Size of DuckDB's buffer pool, e.g. |
| No | CPU count | Worker threads DuckDB may use. Each carries its own buffers, so lowering this is the most effective way to cut peak memory on a large load. |
| No |
| Transport protocol: |
| No |
| HTTP bind address (only when |
| No |
| HTTP port (only when |
| With | — | Identity provider's JWKS endpoint. The HTTP transport refuses to start until this, |
| With | — | Token issuer; comma-separate to accept several |
| With | — | Audience this server is registered as |
| No | no limit | Cancel a query that runs longer than this many seconds. Useful when a client enforces its own tool-call budget |
Available Tools
9 toolscheck_rapid7_export_statusCheck Rapid7 Export StatusARead-onlyIdempotent
Check the status of a Rapid7 export, including local download/load progress.
Fast, non-blocking call. Reports whichever stage the export is in:
While this server is downloading or loading the export in the background, reports that local phase and per-file progress — and skips the Rapid7 API call, since the platform-side export is already known to be complete.
Once loaded (COMPLETE) or failed (FAILED) locally, returns the stored summary/error so no work is repeated.
Otherwise queries the Rapid7 API once for the platform-side export status (PENDING/PROCESSING/COMPLETE/FAILED).
Because local phase lives in the durable tracker, it is inspectable after a server restart (interrupted work is reconciled to a retryable FAILED at startup rather than resumed). Does NOT poll or wait.
Inputs: export_id (required). Returns: result
download_rapid7_exportDownload Rapid7 ExportAIdempotent
Start downloading a completed Rapid7 export and loading it into the database.
Call this after check_rapid7_export_status confirms the export is COMPLETE. This kicks off the download and load in the background and returns immediately — large exports (potentially millions of rows) can take several minutes to load, longer than most MCP clients will wait on a single tool call. Poll progress with check_rapid7_export_status(export_id).
Inputs: export_id (required), export_type. Returns: result
get_rapid7_schemaGet Rapid7 SchemaARead-onlyIdempotent
Get the schema of all database tables.
Returns column names and data types for all existing tables: assets, vulnerabilities, policies, and vulnerability_remediation. Tables that have not been loaded yet are omitted.
Use this to understand what data is available before writing queries.
Returns: Table schemas as formatted JSON, keyed by table name
Inputs: no named parameters. Returns: result
get_rapid7_statsGet Rapid7 StatisticsARead-onlyIdempotent
Get summary statistics for all database tables.
Returns row counts and relevant distributions for all existing tables: assets, vulnerabilities, policies, and vulnerability_remediation. Tables that have not been loaded yet are omitted.
Useful for getting an overview of the data across all loaded datasets.
Returns: Summary statistics as formatted JSON, keyed by table name
Inputs: no named parameters. Returns: result
list_rapid7_exportsList Rapid7 ExportsARead-onlyIdempotent
List recent Rapid7 exports tracked in the system.
Shows export metadata including export ID, date, status, type, and row counts. Useful for understanding what exports are available for reuse.
Inputs: limit. Returns: result
load_rapid7_parquetLoad Rapid7 Parquet FileAIdempotent
Load vulnerability data from existing Parquet file(s).
Use this if you already have Parquet files downloaded and want to skip the export process. This is much faster than running a full export.
Inputs: parquet_path (required). Returns: result
purge_rapid7_dataPurge Rapid7 DataADestructiveIdempotent
Permanently delete all local Rapid7 data and tracking databases.
This removes:
The main vulnerability database (rapid7_bulk_export.db)
The export tracking database (rapid7_bulk_export_tracking.db)
Any associated WAL files
Use this when you are done with your analysis session, before handing off a machine, or to free disk space. After purging, you will need to run a new export to query data again.
Returns: Confirmation of purged data.
Inputs: no named parameters. Returns: result
query_rapid7Query Rapid7 DataARead-onlyIdempotent
Execute a SQL query against the Rapid7 database.
The database contains the following tables loaded from Rapid7 InsightVM Bulk Export API Parquet files:
assets — Asset inventory data: Key fields: orgId, assetId, agentId, hostName, ip, mac, osFamily, osProduct, osVersion, osDescription, riskScore, sites, assetGroups, tags, awsInstanceId, azureResourceId, gcpObjectId
vulnerabilities — Combined asset + vulnerability data: Key fields: orgId, assetId, vulnId, checkId, port, protocol, title, description, severity, severityRank, cvssScore, cvssV3Score, cvssV3Severity, hasExploits, epssscore, epsspercentile, riskScoreV2_0, cves, firstFoundTimestamp, reintroducedTimestamp, dateAdded, dateModified, datePublished, pciCompliant, pciSeverity
vulnerability_exceptions — Vulnerability exceptions (waived/accepted risk): Key fields: orgId, assetId, vulnId, checkId, key, port, protocol, nic, proof, firstFoundTimestamp, reintroducedTimestamp, exceptionDetails
policies — Policy compliance results (agent and scan based): Key fields: orgId, assetId, benchmarkNaturalId, profileNaturalId, benchmarkVersion, ruleNaturalId, ruleTitle, finalStatus, proof, lastAssessmentTimestamp, benchmarkTitle, profileTitle, publisher, fixTexts, rationales, source ('agent' or 'scan')
vulnerability_remediation — Vulnerability remediation tracking: Key fields: orgId, assetId, cveId, vulnId, proof, firstFoundTimestamp, reintroducedTimestamp, lastDetected, lastRemoved, title, description, cvssV2Score, cvssV3Score, cvssV2Severity, cvssV3Severity, cvssV2AttackVector, cvssV3AttackVector, riskScoreV2_0, datePublished, dateAdded, dateModified, epssscore, epsspercentile
Use this tool to query any of the above tables. You can filter, aggregate, join across tables, or perform any SQL-based analysis supported by DuckDB.
Examples:
SELECT * FROM vulnerabilities WHERE severity = 'Critical' LIMIT 10
SELECT severity, COUNT(*) FROM vulnerabilities GROUP BY severity
SELECT * FROM policies WHERE finalStatus = 'fail' LIMIT 10
SELECT cveId, COUNT(*) FROM vulnerability_remediation GROUP BY cveId
Inputs: sql (required). Returns: result
start_rapid7_exportStart Rapid7 ExportAIdempotent
Start a new Rapid7 export job (non-blocking).
This is a fast, non-blocking call that creates an export job on the Rapid7 platform and returns the export ID immediately. The export will process in the background on Rapid7's servers (typically 3-5 minutes).
Use check_rapid7_export_status(export_id) to monitor progress, then download_rapid7_export(export_id, export_type="...") once it completes.
If an export from today already exists, returns that export's ID instead of creating a duplicate.
For remediation exports, the Rapid7 API limits each request to 31 days. If the date range exceeds 31 days, this tool automatically splits it into multiple 31-day chunks and kicks off an export for each chunk.
Inputs: end_date, start_date, export_type. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 9 tools
Each tool maps to a distinct stage or concern: starting exports, checking status, downloading/loading, loading from Parquet, querying, inspecting metadata, listing, and purging. Even the two load-related tools are clearly separated by input source (existing Parquet vs. completed export).
All tool names follow a consistent verb_rapid7_noun pattern in snake_case, e.g., start_rapid7_export, check_rapid7_export_status, get_rapid7_schema, purge_rapid7_data. The naming is uniform and predictable across the entire set.
Nine tools is well-scoped for the export-to-query-to-cleanup lifecycle. Each tool serves a necessary function without redundancy or bloat.
The tool surface covers the full workflow: create export, monitor progress, download/load data, alternate local Parquet ingestion, schema/stats inspection, querying, listing prior exports, and purging data. There are no obvious dead ends or missing lifecycle steps.
Maintenance
Related MCP Connectors
Query your warehouse or a CSV with Claude/ChatGPT over MCP, governed by table-level ACL + audit.
Query your org's data in natural language — read-only MCP access to SQL, NoSQL, files & warehouses.
Cloud-hosted MCP server for secure AI access to enterprise data sources via CData Connect AI.
Build and run AI workflows, agents, data tables and 1000+ API integrations from any MCP client.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to manage Nessus vulnerability scans, analyze results, and generate reports through the MCP protocol.3MIT
- AlicenseAqualityCmaintenanceExposes Tenable security operations as MCP tools for AI-powered security workflows, enabling asset, vulnerability, scan, plugin, and tag management via natural language.17MIT
- FlicenseAqualityDmaintenanceEnables read-only exploration and querying of PostgreSQL or MySQL databases via MCP, with schema discovery, safe SQL validation, natural language to SQL conversion, and CSV export.112-
- AlicenseNot gradedqualityDmaintenanceAn MCP server for Tenable Vulnerability Management and the Tenable One platform, enabling LLMs to query assets, vulnerabilities, scans, exposure metrics, attack paths, and more via natural language.2MIT