Back to Browse

Echelongraph MCP Server

Developer ToolsModerate5.6MCP RegistryLocalRemote
Free

Server data from the Official MCP Registry

CVE, KEV, EPSS, SBOM and advisory lookups; per-CVE exposure from Shodan data (© Shodan). Keyless.

About

CVE, KEV, EPSS, SBOM and advisory lookups; per-CVE exposure from Shodan data (© Shodan). Keyless.

Remote endpoints: streamable-http: https://mcp.echelongraph.io/mcp

Security Report

5.6
Moderate5.6Moderate Risk

The EchelonGraph CVE MCP server is keyless, read-only, and makes outbound requests only to the EchelonGraph API (app.echelongraph.io by default) to answer tool calls, which fits its stated purpose. No hardcoded credentials, shell execution, or data exfiltration patterns appear in the reviewed code. The review is partial because the source is truncated, so the remaining tool modules were not inspected. Supply chain analysis found 10 known vulnerabilities in dependencies (0 critical, 8 high severity). Package verification found 1 issue.

4 files analyzed · 15 issues found

Security scores are indicators to help you make informed decisions, not guarantees. Always review permissions before connecting any MCP server.

Permissions Required

This plugin requests these system permissions. Most are normal for its category.

HTTP Network Access

Connects to external APIs or services over the internet.

env_vars

Check that this permission is expected for this type of plugin.

File System Read

Reads files on your machine. Normal for tools that analyze or process local data.

system_info

Check that this permission is expected for this type of plugin.

What You'll Need

Set these up before or after installing:

Override the API base URL (self-host or proxy).Optional

Environment variable: ECHELONGRAPH_API_BASE

Per-request timeout in milliseconds. A slower answer is reported as a failed lookup, not as empty data.Optional

Environment variable: ECHELONGRAPH_API_TIMEOUT_MS

How to Install & Connect

Available as Local & Remote

This plugin can run on your machine or connect to a hosted endpoint. during install.

Documentation

View on GitHub

From the project's GitHub README.

EchelonGraph MCP server

CVE and internet-exposure data for Claude, Cursor, VS Code, Cline, and any MCP client, straight from EchelonGraph's free public feed.

It exposes EchelonGraph's CVE Pulse (NVD + MITRE-CNA pre-NVD + CISA-KEV + EPSS + GitHub GHSA, fused into one score) plus a per-CVE internet-exposure footprint: how many internet-facing services (distinct ip:port) EchelonGraph's KEV-exposure radar has on record running a version that maps to the CVE. Exposure counts are derived from Shodan data. Shodan data is owned by Shodan, which holds its copyright (© Shodan).

Its 16 tools look up one CVE (record, exploit code and fixed versions, how it is fixed as its sources state it, EPSS history, vendor advisories, exposure footprint), list CISA's newest KEV additions, check whether a product or package version is affected, check an SBOM or a project's lockfiles, and read a CWE and its CVEs. Every result says how it was measured (state, measured_at, method, coverage, freshness, notes), so a model cannot mistake an outage or an unassessed lookup for an all-clear.

It also serves five prompts, ready-made workflows a client can show as slash commands (triage_cve, kev_weekly_brief, am_i_affected, sbom_review, workload_triage; see "Prompts"), two resources (echelongraph://methodology and echelongraph://sources) and one resource template (cve://{cve_id}; see "Resources").

Free and keyless: no API key, no auth, read-only. The server makes no request other than the API call a tool needs to answer.

Quick start

The local server runs through npx and needs Node.js 20 or later; nothing is installed globally. Claude Desktop's one-click extension, below, needs neither. Add one of the blocks below to your client, quit it fully and reopen it, then ask: "Is CVE-2023-44487 actively exploited, and how many exposed services does EchelonGraph's radar have on record for it?"

Claude Desktop

Three ways in. The first two need no Node.js: a one-click extension that runs the server on your machine, and a custom connector to the hosted endpoint. The third runs the server through npx.

1. Install in Claude Desktop (one click, no Node.js). The link downloads echelongraph-mcp.mcpb, a Claude Desktop extension. Open it, or in Claude Desktop choose Settings → Extensions → Advanced settings → Install Extension and pick it, then choose Install. Claude Desktop runs the server with the Node.js it ships and writes its own configuration: no PATH and no JSON to edit. To update, install the next release's bundle the same way. Every new release on GitHub carries the bundle (releases up to 2.6.5 do not), built from the release's tag by the workflow that publishes the npm package, and signed with a SLSA build-provenance attestation. To check a download: gh attestation verify echelongraph-mcp.mcpb --repo echelongraph/echelongraph-mcp.

2. Custom connector (no install). Claude Desktop uses your claude.ai account's connectors: Customize → Connectors → + Add → Add custom connector. Name it EchelonGraph, paste https://mcp.echelongraph.io/mcp, choose No sign in, and add it. A connector added on claude.ai shows up in Claude Desktop too, and the plan rules are claude.ai's (see "Remote (no install)" below).

3. Local server through npx.

  1. Check Node.js. In Terminal (macOS) or PowerShell (Windows), run node -v. It must print v20 or later. If it prints an older version or command not found, install the LTS release from https://nodejs.org, or on macOS with Homebrew run brew install node.

  2. Open the config file in a plain-text editor. Settings → Developer → Edit Config shows claude_desktop_config.json (macOS: ~/Library/Application Support/Claude/claude_desktop_config.json; Windows: %APPDATA%\Claude\claude_desktop_config.json). Open it in a plain-text editor such as VS Code, Notepad or nano. TextEdit on macOS turns " into curly quotes (“ ”) when Smart Quotes is on, and the JSON then breaks without an error: turn it off under Edit → Substitutions → Smart Quotes, or use another editor.

  3. Merge, do not replace. The file usually exists already and holds Claude Desktop's own settings (for example a "preferences" object). Keep everything in it. Add an "mcpServers" key at the top level, next to the keys already there; if "mcpServers" is already there, add the "echelongraph" entry inside it. Mind the comma between entries. The result looks like this, with your own settings where preferences is:

    {
      "preferences": {
        "…": "the settings already in your file stay as they are"
      },
      "mcpServers": {
        "echelongraph": {
          "command": "npx",
          "args": ["-y", "echelongraph-mcp"]
        }
      }
    }
    

    To check that the file parses, run this in Terminal (macOS):

    node -e "JSON.parse(require('fs').readFileSync(process.argv[1], 'utf8'))" "$HOME/Library/Application Support/Claude/claude_desktop_config.json"
    

    or this in PowerShell (Windows):

    node -e "JSON.parse(require('fs').readFileSync(process.argv[1], 'utf8'))" "$env:APPDATA\Claude\claude_desktop_config.json"
    

    No output means valid JSON. A SyntaxError means the file is broken (often curly quotes or a missing comma); ENOENT means there is no file at that path yet.

  4. Quit fully, then reopen. Closing the window leaves the old config loaded. On macOS choose Claude → Quit Claude (⌘Q); on Windows right-click the Claude icon in the system tray and choose Quit. The first start can take longer while npx downloads the package.

  5. Check that it worked. Settings → Developer lists echelongraph as running, and the tools menu in the chat box lists EchelonGraph's tools, the ones under "Tools" below. Then ask the question at the top of this section.

Troubleshooting Claude Desktop
  • spawn npx ENOENT (or the server shows as failed). On macOS, an app opened from the Dock does not get your shell's PATH, so Claude Desktop cannot find npx where Homebrew (Apple silicon: /opt/homebrew/bin; Intel: /usr/local/bin) or nvm put it. Run which npx in Terminal, then give Claude Desktop that absolute path as "command", and the folder it is in as PATH under "env" (npx starts node from that same folder). With Homebrew on Apple silicon:

    {
      "mcpServers": {
        "echelongraph": {
          "command": "/opt/homebrew/bin/npx",
          "args": ["-y", "echelongraph-mcp"],
          "env": { "PATH": "/opt/homebrew/bin:/usr/bin:/bin" }
        }
      }
    }
    

    With nvm, use the full path which npx prints (JSON does not expand ~). Then quit fully and reopen. On Windows, install Node.js with the installer from nodejs.org, which adds npx to the system PATH, then quit Claude Desktop fully and reopen it.

  • The server does not appear at all. The file is not valid JSON (a missing comma, or curly quotes), or the app was not fully quit: see steps 2 to 4.

  • Logs. macOS: ~/Library/Logs/Claude/mcp-server-echelongraph.log (this server's output) and ~/Library/Logs/Claude/mcp.log (connections). Windows: %APPDATA%\Claude\logs\, with the same file names.

Claude Code

claude mcp add --transport stdio echelongraph -- npx -y echelongraph-mcp

Add --scope user before the -- to make it available in every project, or --scope project to share it through the project's .mcp.json. Claude Code hands the model each result's structuredContent, which this server holds to 30,000 characters unless a call passes full: true (see "Long answers"); MAX_MCP_OUTPUT_TOKENS (25,000 tokens by default) is the cap Claude Code applies to a tool's output, and raising it lets a full: true answer through.

Cursor

~/.cursor/mcp.json (every project) or .cursor/mcp.json (one project):

{
  "mcpServers": {
    "echelongraph": {
      "command": "npx",
      "args": ["-y", "echelongraph-mcp"]
    }
  }
}

VS Code

.vscode/mcp.json in the workspace (VS Code's key is servers, not mcpServers):

{
  "servers": {
    "echelongraph": {
      "command": "npx",
      "args": ["-y", "echelongraph-mcp"]
    }
  }
}

or from a terminal:

code --add-mcp '{"name":"echelongraph","command":"npx","args":["-y","echelongraph-mcp"]}'

Windsurf, Cline and other clients

Clients that read an mcpServers block (Windsurf's mcp_config.json, Cline's MCP settings, and most others) take the same block as Cursor above.

Remote (no install)

The same 16 tools, five prompts, two resources and one resource template are served over Streamable HTTP at:

https://mcp.echelongraph.io/mcp

Keyless, no sign-in, stateless; both protocol eras. The hosted endpoint is in service: https://mcp.echelongraph.io/health answers {"status":"ok","version":…} with the package version it runs.

  • claude.ai (Free, Pro, Max, Team and Enterprise plans): Customize → Connectors → + Add → Add custom connector. Name it EchelonGraph, paste the URL, choose No sign in, and add it. On Team and Enterprise an Owner adds it for the organization first, and each member then connects it. Free plans allow one custom connector.

  • Claude Code:

    claude mcp add --transport http echelongraph https://mcp.echelongraph.io/mcp
    
  • Cursor (mcp.json):

    { "mcpServers": { "echelongraph": { "url": "https://mcp.echelongraph.io/mcp" } } }
    
  • VS Code (.vscode/mcp.json):

    { "servers": { "echelongraph": { "type": "http", "url": "https://mcp.echelongraph.io/mcp" } } }
    
  • Windsurf (mcp_config.json):

    { "mcpServers": { "echelongraph": { "serverUrl": "https://mcp.echelongraph.io/mcp" } } }
    

The hosted endpoint runs this package's code (dist/http.js, below) against the same public API, so its answers are the npm package's answers ("Privacy" says what it logs).

Tools

Every tool is read-only (readOnlyHint: true) and declares a title and an outputSchema. The example questions are ones a client can answer with that tool alone.

ToolTitleWhat it answersExample question
cve_summaryCVE feed summaryCounts of active CVEs by severity band, the count with no severity band from any source (summary.none, sent again as summary.unscored: CVEs not yet scored, not a rating of None), the same CVEs counted by NVD's severity label, as provenance (summary.nvd_critical to summary.nvd_none), the rejected (withdrawn) records outside the total (summary.rejected), and when the feed was last updated.How many critical CVEs does the feed hold, and when was it last updated?
search_cvesSearch CVEsSearch/filter CVEs (severity, min CVSS, text, sort) with EchelonGraph scores and score_assessed; page with limit and offset; the note names each row not yet scored.Find critical CVEs that mention Tomcat with a CVSS of 9 or more.
get_cveCVE detailOne CVE's record: CVSS v3 and (when scored) v4, the EchelonGraph score and its confidence, whether EchelonGraph has scored it (score_assessed), EPSS, CISA-KEV status and known ransomware use and, for a KEV-listed CVE, CISA's own text relayed verbatim (kev_required_action, the action CISA requires of US federal civilian agencies, not EchelonGraph's advice; kev_short_description; kev_notes_urls), the GitHub GHSA id, references, and its published, modified and updated_at times.What are CVE-2024-3094's CVSS, EPSS and CISA-KEV status?
cve_exposureInternet exposure for one CVEInternet-exposure footprint for a CVE: exposed service count (distinct ip:port, exposed_hosts) + hosting-country/product breakdown, from the KEV-exposure radar.How many exposed services does EchelonGraph's radar have on record for CVE-2023-44487?
exposure_radarExposure radar totalsAggregate totals across the exposure radars: services running CISA-KEV CVEs; unauthenticated data stores and observability UIs, found through Shodan (LeakIX when Shodan query credits run low) and then confirmed by EchelonGraph's own identified check, which is not a pure read (on Redis it names its client; on ClickHouse its query lands in the server's query log); leaked credentials; shadow AI; and MCP servers found in EchelonGraph's own Certificate Transparency feed, by RFC 9728 verdict, protocol era and transport. Every number is labelled by what it counts, and a field the tool cannot label is left out and named.How many unauthenticated data stores has EchelonGraph's radar confirmed?
kev_recentRecent CISA KEV additionsThe CVEs CISA has added to its Known Exploited Vulnerabilities catalog, newest first (kev_added_date), from EchelonGraph's copy of the catalog, polled from CISA every 5 minutes: due date, vendor, product, known ransomware use, EchelonGraph's severity, CVSS, EPSS and eg_kev_tier, and our_first_seen_kev. Filter by date range, ransomware and vendor; page with limit and next_cursor. Dated by last_successful_fetch_at, our last successful fetch of CISA's feed; the filters travel as request headers, never in the URL.Which CVEs has CISA added to KEV since 1 September, and which have known ransomware use?
epss_historyEPSS change history for one CVEHow one CVE's EPSS score has changed, as EchelonGraph recorded it: one point per recorded change (series_kind change_only), never a daily series, with the value now; complete_since, from when every change is a point (before it the record misses changes, so a missing point there does not mean unchanged, and the series is never called complete); coverage, which FIRST score dates the record holds and which it misses (days_missing, days_partial, days_in_progress); and series_starts_at, when recording began; before it a missing point means not recorded, not unchanged.How has CVE-2023-44487's EPSS score changed, as EchelonGraph recorded it?
check_affectedAm I affected? (product or package at a version)Whether a product (its NVD CPE product token) or a registry package (ecosystem and package) at a given version is affected by known CVEs, from the matcher behind echelongraph.io/am-i-affected: assessed first (false: not evaluated, with not_assessed_reason, and a count of 0 then is not "not affected"), the matching CVEs with kev_listed, ransomware, epss_score, effective_score and score_assessed (a registry match also fixed_in, the lowest version above it that no affected interval of the record holds, with fixed_in_detail when it moved past an overlapping interval, or null with fixed_in_reason, which is not a finding that no fix exists), and CVEs it cannot decide counted as undetermined_count, never as safe. What you look up travels in request headers, never in the URL.Is openssl 3.0.0 affected by known CVEs? Is lodash 4.17.15 on npm?
check_sbomCheck purls or an SBOM against the advisory corpusA dependency list checked against EchelonGraph's advisory corpus (OSV.dev records and CVE records' CNA purls), one verdict per component: affected, not_affected, undetermined or not_assessed, each with its not_assessed_reason. Each row names the package its advisories were looked up by (matched_package) and how (matched_via: upstream where a deb, apk or alpine purl's upstream qualifier names the source package, which is how Debian and Alpine file advisories, else purl_name), and each match carries fixed_in, the lowest version above the component's that no affected interval of the record holds (fixed_in_detail names any overlapping interval it moved past), or null with fixed_in_reason. Pass up to 2,000 distinct purls, in a list of at most 10,000 entries, or a CycloneDX JSON or SPDX JSON document: the purls are read from it by the MCP server and only they are sent to the API, in POST bodies of at most 200 each; the document itself is not sent on. Run from npm, the server is on your machine; over the hosted endpoint (mcp.echelongraph.io) it is EchelonGraph's, and the document is the request body. At the API's per-component rate limit (429), the tool waits out its Retry-After, within 50 seconds a call; past that it answers what it has, with the purls not sent counted in coverage.not_sent, the reason in coverage.not_sent_reason, and the list in data.not_sent_purls (whole with full: true; a DATA CUT can cut it), never dropped silently. A deb, apk or rpm purl without a distro qualifier naming its release is not assessed (distro_release_unknown): EchelonGraph does not guess one. Only not_affected is clean. No ranking, no score.Check this CycloneDX SBOM against the advisory corpus.
scan_manifestCheck a lockfile against the advisory corpusA project's lockfiles or pinned manifests checked against the same advisory corpus, one verdict per dependency, through check_sbom's batch route, 50-second budget and Retry-After waits. Pass files, 1 to 20 of filename and content, up to 5,000,000 characters in all; the format is read from the filename, or set by format. Read: requirements.txt (only == and === pins; extras and markers stripped), go.mod (require, // indirect included, after replace and exclude), package-lock.json and npm-shrinkwrap.json (v1 to v3), Cargo.lock, Gemfile.lock (platform suffixes stripped), composer.lock (a leading v stripped), poetry.lock and gradle.lockfile. package.json, pyproject.toml, Pipfile, Gemfile, Cargo.toml, composer.json and build.gradle hold ranges and are refused, naming the lockfile to pass; go.sum is refused, as it lists module versions the build does not select; pom.xml, yarn.lock and pnpm-lock.yaml are not read yet. The MCP server reads the files into purls and only the purls are sent to the API; filenames and file contents are not sent on. Run from npm, the server is on your machine; over the hosted endpoint (mcp.echelongraph.io) it is EchelonGraph's, and the files are the request body. data.results holds one row per distinct purl, each match with kev_listed, epss_score and fixed_in. data.not_checked lists a call's first 2,000 entries not sent, each with its file, line and reason: version_unpinned (a range such as django>=4), version_unresolved, local_path, vcs_source or unsupported_line; coverage.not_checked_by_reason counts all, and none is clean. A call of over 40,000 lines or 300,000 JSON or TOML values, or a filename over 1,024 characters, is refused (invalid_input), and over the hosted endpoint one that with its body would hold over 30 MiB. A file that holds no version this tool can check answers not_assessed without calling the API. Only not_affected is clean. No ranking, no score.Check this package-lock.json against the advisory corpus.
cve_intelCVE weakness, exploits and packagesWeakness, exploit code and detection checks (a Nuclei template, or a GitHub repository the API serves as a checker, checks whether a system is affected; it is not necessarily exploit code, and the note counts them apart), affected packages and fixed versions for one CVE, from EchelonGraph's per-CVE enrichment: cwes, exploits (at most 10, verified first) with exploits_total, exploits_capped, exploits_by_kind and exploits_by_status, affected_packages, fixed_versions and timeline. Each affected_packages row carries fixed_branches, every affected range of the package with its fix (introduced, and fixed or, where no fix is on record, last_affected), each naming the OSV record that published it (advisory_id, source) and in that record's order: an installed version's fix is the first fixed above it that no range of its row holds (the fixed of the range that holds it, moved past any range that still holds that version; none past a range without fixed), compared in the ecosystem's version order. fixed_version is one range's fix, kept for compatibility, not the fix for every range; fixed_branches is null where a package's ranges were never loaded, and [] where no version range is on record, which is not a finding that no fix exists. verified_status is the label stored with each reference, not a guarantee that the exploit works. An empty exploits list is not evidence that no public exploit exists; a section the API could not read is named in coverage.sections_failed, never relayed as an empty list.Is there public exploit code for CVE-2021-44228, and which versions fix it?
cve_remediationHow one CVE is fixedHow one CVE is fixed, as its sources state it, in one answer; every text is relayed as its source states it, untested by EchelonGraph: cisa (for a KEV-listed CVE, CISA's required_action, due_date, short_description and notes_urls, verbatim; CISA directs the action at US federal civilian agencies, and it is not EchelonGraph's advice), fixed_branches (each affected package with every affected range and its fix), vendor_remediations (each vendor advisory naming the CVE, at most 20, with its remediation_state and the items it lists for the CVE, each with kind, the vendor's own category: vendor_fix, workaround, mitigation, no_fix_planned, none_available or other, or may be no_fix_planned if Cisco's summary says none will be released), fix_references (references NVD or the CNA tagged Patch or Mitigation), patches, coverage and failed_sections, with fix_status, the API's fix-status rule that CVE Pulse pages show. Given the installed ecosystem, package and version (all three or none), it also answers installed (that version's verdict) and fixed_in: the first version above it that no affected range on record holds, or null with fixed_in_reason. remediation_state none_in_source or not_parsed, and an empty list, are not a finding that no fix exists. A REJECTED CVE answers not_assessed.How is CVE-2021-44228 fixed, as its sources state it?
get_cweCWE and its CVEsOne CWE (weakness class) and the CVEs classified under it: name and description from the MITRE CWE catalog EchelonGraph embeds, total, and one page of 50 cves, ordered as order states (CISA-KEV-listed first, then EchelonGraph score). A total of 0 says that no CVE in EchelonGraph's feed is classified under that CWE, not that none exists.Which CVEs are classified under CWE-79, CISA-KEV-listed first?
vendor_advisories_for_cveVendor advisories for one CVEThe vendor-published advisories (Microsoft MSRC, Red Hat, Cisco, Palo Alto Networks, GitHub GHSA and the other feeds EchelonGraph polls) that name one CVE, newest first, at most 20, each with remediation_kinds and remediation_state (not_parsed: EchelonGraph does not read that vendor's remediation, which is not a finding of none).Which vendor advisories name CVE-2024-3400?
get_vendor_advisoryVendor advisory detailOne vendor advisory in full: description, severity, cve_ids and the subset with a CVE record here (known_cve_ids), affected_products, remediation and references, and remediations, each remediation the vendor lists with its kind (the vendor's own category, or may be no_fix_planned if Cisco's summary says none will be released), verbatim text and URL, with remediation_state.Show one of those advisories in full: affected products, remediation and references.
search_vendor_advisoriesSearch vendor advisoriesSearch vendor advisories by text (title, description, vendor, advisory ID, products, CVE IDs), vendor, severity and whether they name a CVE. The search text is sent in a request header, never in the URL.Search vendor advisories for FortiOS, critical severity only.

The three vendor-advisory tools relay vendor_published_at (the vendor's date), our_first_seen_at (when EchelonGraph first recorded the advisory) and withdrawn (the vendor rescinded it; the note names each one, and the search leaves them out).

Each also relays every vendor's window in coverage (vendor_windows, or vendor_window for the detail): the advisories held, the earliest and latest vendor_published_at among them, held_since, feed_held_since, history_backfill and history_scope. An advisory published before its vendor's held_since may not be held, nor, where a vendor's history read covers only part of its advisories (history_scope reviewed: GitHub's), one outside that part published before its feed_held_since. vendor_advisories_for_cve lists in vendors_not_fully_held each vendor absent from its answer that may not hold every advisory for the CVE ID's year: no advisory from such a vendor is not a finding that it published none (how each window is read). Each window also carries last_success_at and collection_state; while a vendor's is not ok, the note names it and says which of its advisories may not be held.

Every figure is as fresh as the last check that produced it. The CVE feed is polled from its sources on a schedule. Each radar has its own schedule and refreshes only while it runs, and exposure_radar's freshness gives each radar's last completed check (last_run_at) where the API serves one.

How each tool reads its answer

What each tool relays, field by field, and what each number counts, is in the pages below, which ship in the package's docs/ folder:

  • How cve_summary reads its counts: summary.none counts CVEs not yet scored, not CVEs rated None, and summary.nvd_critical to summary.nvd_none count by NVD's severity label (or a pre-NVD label standing in), as provenance.
  • How get_cve and search_cves read the EchelonGraph score: score_assessed: false is not yet scored, never a score of 0.
  • What patch_available says, and the evidence patch_evidence names, the CVE record's own fix statement among it (cna_solution, description_fix): false means no fix evidence is on record, not that no fix exists.
  • How cve_exposure counts: a count of ip:port services, not machines, inferred from banner versions in a sample of Shodan data, and for a CVE outside the radar's tracked set NOT ASSESSED: its 0 is not a measurement.
  • How exposure_radar counts: every number of its five radars, each labelled by what it counts.
  • How check_affected decides: read assessed before count; a registry match's fixed_in is the lowest version above it no affected interval of the record holds, or null with fixed_in_reason.

Prompts

Ready-made workflows a client can show as slash commands. Each prompt names the tools to call, in order, and tells the model to read every result's state, measured_at, method, coverage and notes: not_assessed is never reported as clean, a count of 0 under assessed: false is never "not affected", and each figure cites its measured_at. A prompt makes no API request.

PromptArgumentsWhat it asks the model to do
triage_cvecve_idget_cve (with CISA's due date, kev_due_date, when the CVE is KEV-listed), cve_intel, vendor_advisories_for_cve, epss_history and cve_exposure, then a decision template: exploited, likelihood, reachable, patch, deadline, decision. The patch line gives each affected range with its fix from cve_intel's fixed_branches; where a package has none, it gives fixed_version as what cve_intel records for the package, one per package (the advisory's last range's as a rule), never as the fix for every affected branch, and points to get_cve's references tagged Vendor Advisory or Patch for a branch's fix.
kev_weekly_briefdays (1 to 365, default 7)Work out the start date from days, page through kev_recent from it 50 rows a page, and write a brief grouped by vendor with ransomware flags and due dates.
am_i_affectedproduct, or ecosystem and package; versioncheck_affected, read assessed before count, with the not-assessed wording.
sbom_reviewsbom (CycloneDX or SPDX JSON text, up to 5,000,000 characters)Pass the document to check_sbom (and, once more, the purls a rate limit or the time budget left unsent: data.not_sent_purls, or, where the text or a DATA CUT cuts that list, the document's purls from the position and in the order its note gives), read each component's ecosystem, package and version from its purl, as check_sbom maps them (every purl type it maps, and deb, apk, alpine and rpm by a distro qualifier naming a Debian, Ubuntu or Alpine release; any other is unknown, and given no fixed version; a deb, apk or alpine purl with an upstream qualifier as the source package that qualifier names, the row's matched_package when its matched_via is upstream, which the fix list names beside the purl), look up each affected CVE with get_cve and cve_intel, and write a fix list ordered by CISA-KEV listing, then EPSS, then score, each key stated. Where the text keeps a match, its fixed version is the match's fixed_in alone, the lowest version above the installed one that no affected interval of the record holds; a null fixed_in is written "no fix on record" with its fixed_in_reason as given, not a finding that no fix exists (one a DATA CUT left without its reason is never called no fix), and no fixed version is read from prose (match_reason, fixed_in_reason). Where the text keeps no match for the component, or a match has no fixed_in, a fixed version is given only above the installed version: the first fixed above it that no range of the cve_intel row's fixed_branches holds, else, for a package without fixed_branches, cve_intel's fixed_version, one per package (the last range's), which need not be the fix on the component's branch; otherwise the line says the results give no fixed version for that branch and points to the CVE's advisory.
workload_triagesource (optional: kubernetes, github_actions or images; default: all three are described)Rank your own pods, CI job containers or images: list the workloads and decide their exposure with your own tools, make an SBOM of each image digest, and pass check_sbom the purls alone (no workload, namespace, image, registry name, credential or exposure label is sent; the image's own pkg:oci/pkg:docker purl is left out). Rows are ordered by CISA-KEV listing, then caller-asserted exposure (unknown is never sorted with not exposed), then EPSS, then score, each key stated. A row whose matches a DATA CUT capped is read with its matches_truncated (its KEV-listed and ransomware CVE IDs), and each CVE kept without its match, or a match without a field it ranks by, is read from get_cve; past 30 CVEs it stops calling get_cve. not_assessed rows are counted and never reported as clean. The prompt takes no workload data.

Resources

Two resources, which resources/list lists, and one resource template, which resources/templates/list lists (a client reads cve://CVE-2024-3400, for example):

ResourceWhat it holds
echelongraph://methodologyWhat each envelope field and state value means, and how each tool measures (Markdown).
echelongraph://sourcesWhat the API reports about its feeds when the resource is read: the NVD poller's interval, last_poll_at, poll_count and poll_errors, all of the one instance that answered (from /api/v1/public/cves/summary; the two counts are that instance's since it last started, zeroed on every restart, never the feed's reliability), and the CISA KEV catalog's last successful fetch and method (from /api/v1/public/kev/recent). It names the feeds no endpoint reports a schedule for, and states none for them (JSON).
cve://{cve_id}One CVE as get_cve returns it: the structured result, envelope and record, as JSON. Past 30,000 characters of JSON, data is cut as get_cve's first text block is, data_truncated is true, truncated names each list cut, and a note starting DATA CUT says what the cut leaves out; get_cve's structuredContent.data holds the record whole with full: true. An ID that is not a CVE ID is refused before any request; a CVE the API has no record of is not found.

What a result means

Every tool answers in one of two shapes, so a model reading the result cannot mistake an outage for an all-clear:

  • Success — the first text block is the API's JSON verbatim (cut to fit 30,000 characters when it is longer: see "Long answers" below); the second is a one-line note saying the call succeeded, which base URL answered, and what it found; the third is the structured result as JSON, less what the first two already say (below). When the feed genuinely holds nothing for the query the note says so in words ("we looked and found nothing … not a lookup failure"), because a measured zero is a measurement. The exceptions to verbatim are cve_summary, which leaves out a poller field the answer sends in a JSON type other than its outputSchema's (or a poller that is neither a JSON object nor null) and names it in the note, and exposure_radar: each radar is cut to the fields docs/exposure-radar.md lists, and each kev_exposure.newest_kev row gains an exposure_state. Its shadow_ai counts are regrouped as that page says, and its poller block carries only running and last_run_at, or is dropped when it carries no real completion time. The block's other fields describe the server instance that answered, not the radar. Its last_run_at is when the radar's leader last completed a Certificate Transparency (crt.sh) cycle, and its running is true only when that was within 30 minutes of the answer. When running is true, the note says the radar's leader last completed a cycle at that time; when it is false, the note says no cycle has completed since that time; when last_run_at is absent, the note says the radar's freshness is unknown and the block is left out. An older API answered from whichever server instance served the request, and a follower instance sent running: false with the zero time 0001-01-01T00:00:00Z; that too is unknown freshness, never presented as a stopped radar.
  • Failure — an MCP error result (isError: true) whenever the lookup did not complete: the host could not be reached, it answered non-2xx, it took longer than the timeout, or it answered 2xx with a body that is not a JSON object. The text names the tool, the cause (status code or error kind), the path, and the base URL, and says it is not a finding; the second text block is the structured result as JSON, less the message's sentences (below). A failure is never rendered as a success with null fields.

Both shapes also carry a structured result, below, and repeat it in their last text block, so a client that passes only content to the model still sees how the answer was measured.

Long answers

A model pays for every character it reads, and clients differ in which part of a result they hand it, so each part is held to the same budget, 30,000 characters, and each is cut on its own terms:

  • Claude Code hands the model structuredContent, not the text blocks, and sizes it against MAX_MCP_OUTPUT_TOKENS (25,000 tokens by default): it warns past 10,000 tokens and, past the cap, saves the result to a file and hands the model its path instead. Through 2.7.x structuredContent.data was always the answer whole (get_cve CVE-2021-44228: 65,540 characters on 2026-10-11, which Claude Code saved to a file). Since 3.0.0 it is cut to fit (below). MAX_MCP_OUTPUT_TOKENS, set in the environment Claude Code starts in, raises its cap.
  • A client that passes only the text blocks (content) reads the first text block, cut to fit as described after the next item.
  • A program that reads structuredContent.data and needs the answer whole, however long, passes full: true: every tool takes it. A client that sizes structured results, as Claude Code does, can refuse such an answer past its cap.

Documentation truncated — see the full README on GitHub.

Reviews

No reviews yet

Be the first to review this server!