tenable-vpr-mcp

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.1.0
Disambiguation5/5
Each tool targets a clearly distinct resource or action: assets, vulnerabilities, plugins, tags, agents, scans, and specialized analyses (VPR comparison, KEV/EPSS cross-reference, scan delta). No two tools have overlapping purposes.
Naming Consistency4/5
Most tools follow a verb_noun pattern (get_asset_details, search_vulnerabilities, list_scans, compare_vpr_reprioritization, check_kev_epss_exposure). However, 'scan_delta' deviates as a noun-noun compound, breaking the otherwise consistent convention.
Tool Count5/5
11 tools is well within the ideal 3-15 range and each tool serves a specific purpose for the server's VPR-focused analysis domain. The count feels neither excessive nor thin.
Completeness4/5
The server covers core retrieval and comparison workflows well, including asset and scan details, vulnerability search, and specialized reporting tools. A minor gap is the lack of a per-asset vulnerability findings endpoint, but existing tools can work around this.
Average 4.3/5 across 11 of 11 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 3 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It adds the specific list of returned fields (description, solution, CVSS, CVEs, VPR drivers), which is useful context. However, it does not disclose whether this is a read-only operation, any permission requirements, error behavior, or rate limits. The verb 'Get' implies read-only but is not explicit.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is one clearly structured sentence that front-loads the action ('Get full plugin detail') and then enumerates the specific content categories. There is no filler or redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple single-parameter retrieval tool with an output schema present, the description is complete enough for an agent to understand what it does and that it requires a plugin_id. It could benefit from noting prerequisites or distinctions from siblings, but it adequately covers the core operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema only defines plugin_id as an integer with no description. The description adds semantic meaning by calling it a 'Tenable plugin ID', which clarifies the domain and format expectations. This is valuable beyond the schema, though it lacks examples, ranges, or error handling details.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly uses 'Get' as the verb and specifies the resource as 'full plugin detail' with concrete fields (description, solution, CVSS vectors, CVEs, VPR drivers) and the target 'given Tenable plugin ID'. This distinctly separates it from sibling tools like get_scan_details and get_asset_details that target different entities.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no explicit when-to-use or when-not-to-use guidance, and no mention of alternatives. The description implies usage through purpose but does not clarify situations where other tools like search_vulnerabilities or check_kev_epss_exposure might be more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the transparency burden. It discloses that results are 'latest' and enumerates the return content, but it omits other behavioral details such as error handling, authorization requirements, or whether multiple scan runs are supported. This is adequate but not rich.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that states the main purpose first, then specifies the included results. Every phrase adds value and there is no filler or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter get tool with an output schema, the description is largely complete. It mentions the key components of the response and the 'latest' qualifier. It does not address edge cases or prerequisites, but these are not critical given the tool's simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, so the description must compensate. It says 'by ID', which implies scan_id is the unique identifier of a scan, but it does not elaborate on where to find the ID or any expected format beyond the schema's integer type. This is a minimal but functional explanation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool as fetching latest results for a single scan by ID, listing specific content (hosts scanned, per-plugin findings, vulnerability counts). This distinguishes it from siblings like list_scans (which likely lists scans) and get_asset_details (which focuses on assets).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly implies use when needing detailed results for a specific scan, but it does not explicitly mention when not to use it or point to alternative tools (e.g., list_scans for finding IDs). It provides clear context without exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the 'Capped at `limit` records' behavior, which is useful, and the word 'List' implies a read-only operation. However, it does not explicitly mention side effects, authentication, or rate limits, leaving some transparency gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences. The first states purpose and output fields, the second explains the cap. Every word earns its place—no fluff or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple listing tool with one parameter and an output schema, the description covers the essential context: what it lists, the fields returned, and the cap. It doesn't mention pagination beyond the cap, but the output schema likely covers response structure, so the description is nearly complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema only defines 'limit' as an integer with a default, but the description adds meaning by stating 'Capped at `limit` records', explaining the parameter's purpose. This compensates well for the 0% schema description coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'List Nessus Agents linked to the tenant' with a specific verb and resource. It also enumerates the returned data (status, platform, timestamps), distinguishing it from sibling tools like list_assets or list_scans.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context ('List Nessus Agents') but does not explicitly compare against alternatives or state when not to use it. Since the name and wording strongly indicate it's for agent listing, usage is inferred rather than clearly guided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description clearly discloses important behavior: it uses external non-Tenable sources, assigns an ordered signal classification, sorts results by urgency, and warns that each plugin incurs an extra Tenable API call. It does not cover error handling or rate limits, but the cost implication and signal ordering are valuable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is organized with a clear lead, bullet list, and workflow notes; every sentence adds context about data sources, ranking, cost, or filtering. It is slightly longer than strictly necessary but remains focused and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the tool's main purpose, output signal order, cost implications, and suggested preceding filters, while an output schema exists to document return values. The missing explanation of the EPSS threshold parameter and lack of annotations keep it from being fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, and the text explains `limit` (bounds plugin CVE lookups and API calls), `severity`, and `plugin_family` (filtering similar to search_vulnerabilities). However, `epss_high_confidence_threshold` is never described, leaving its meaning and default (0.5) unexplained despite being central to the EPSS signal classification.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool 'cross-reference[s] live findings against two independent, publicly sourced exploitation signals' (CISA KEV and FIRST.org EPSS) and explicitly distinguishes itself from Tenable's VPR and the sibling compare_vpr_reprioritization tool. This provides a specific verb+resource and differentiates it from related tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives clear context: use alongside compare_vpr_reprioritization for vendor-independent re-prioritization evidence, and filter by severity/plugin_family first. It references search_vulnerabilities for consistent filtering, but does not explicitly state when not to use the tool or name alternative tools for substitutions, so it lacks full exclusion guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral burden and does so well: it discloses output fields, sorting (escalated first), filtering semantics, and the assessment context. It does not explicitly state 'read-only' or discuss side effects, but the table-building purpose implies no mutation, and the description provides more context than typical.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is organized in two focused paragraphs, front-loading the core action and output. The use-case sentence and sorting rationale earn their place, though the text is longer than a minimal two-sentence summary.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity and an existing output schema, the description covers the essential what, why, and filtering options. It lacks only a small clarification of limit's role, but the description is sufficient for an agent to select and invoke the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so the description must compensate. It explains severity and plugin_family as optional filters 'same as search_vulnerabilities', adding real meaning. The limit parameter is not described beyond its name/default, but two of three parameters receive useful semantic context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb 'Build' and clearly states the tool produces a before/after re-prioritization table comparing CVSS vs VPR severity per plugin, with rerating flags and asset counts. It distinguishes itself from siblings by its comparison/assessment focus rather than simple listing or asset details.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly identifies the intended scenario: POC/assessment deliverables and Tenable One CTEM engagements, which tells an agent when to reach for this tool. It also references search_vulnerabilities for filter behavior, though it doesn't explicitly say when not to use it or name alternative tools for plain vulnerability listing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It discloses the authorization scope ('visible to the authenticated API key') and the optional filter behavior, plus the returned fields. However, it does not mention potential pagination, ordering, rate limits, or whether the list is partial or complete, leaving some behavioral traits undisclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the action and resource, and includes only relevant details: the optional filter and the returned fields. There is no redundant or vague wording.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool with a single optional parameter and an output schema, the description is complete enough. It explains the input and the output, and the auth scope. No critical information seems missing for an AI to select and invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The only parameter, folder_id, is explained in the description as an optional filter. Since the input schema has no property descriptions (0% schema coverage), this description provides essential meaning beyond the schema, clarifying that it controls folder-based filtering. It does not detail null handling, but the schema's default null and the phrase 'optionally' cover the basics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description begins with 'List scans visible to the authenticated API key, optionally filtered by folder ID.' This clearly states the verb (list), the resource (scans), the scope (visible to API key), and an optional filter (folder ID). It also names the returned fields. This distinguishes it from siblings like get_scan_details (single scan) and scan_delta (comparison).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use the tool: to retrieve a list of scans that the API key can see, with an optional folder filter. It does not explicitly name alternatives or exclusions, but the simple 'list' intent and the sibling names make the use case evident. No misleading guidance is present.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full responsibility for behavioral disclosure. It transparently notes that exposure scores (ACR/AES) are only available 'if licensed', and it lists the exact types of data returned. It does not discuss permissions or error cases, but the read-only nature is implied by 'Get'.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that front-loads the action ('Get full detail') and then compactly lists the returned fields. Every segment adds value without redundancy or unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that the tool has only one parameter, has an output schema, and is a straightforward read operation, the description adequately covers the scope and special conditions (licensing). It does not need to describe return format because the output schema is present.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema offers only a bare string parameter 'asset_uuid' with 0% description coverage. The description compensates by clarifying that the UUID identifies a single asset and by specifying the detail categories returned, giving the agent a clear understanding of the parameter's purpose and expected input.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly specifies 'Get full detail for a single asset by UUID' and enumerates the content areas (network interfaces, installed software, tags, exposure scores). This makes the tool's purpose distinct from sibling tools like list_assets, which lists assets rather than fetching one asset's full details.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'by UUID' establishes a clear usage context: use this tool when you have a specific asset UUID and need comprehensive details. It does not explicitly mention alternatives or when not to use it, but the context is sufficiently clear to guide agent selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description provides key behavioral detail: it is capped at the 'limit' parameter to keep responses small. It also discloses the return fields. It does not cover all possible caveats (e.g., pagination, ordering), but the cap behavior is significant and useful.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the primary action and scope, and the second sentence succinctly explains the cap behavior. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one parameter, output schema present), the description is largely complete. It omits some possible details like sorting or default behavior when limit is omitted, but the schema covers the default. The core purpose, scope, return fields, and resource constraint are all present.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description compensates by clearly explaining the sole parameter 'limit' (capping the number of records). This directly adds meaning beyond the schema's type and default.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the resource (assets) and the action (list), and specifies the scope (Tenable.io / Tenable One) and included fields (hostname, IPs, UUID, last seen, sources). This distinguishes it from siblings like get_asset_details or search_vulnerabilities.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for use: it lists assets, which is distinct from more specific tools. It does not explicitly mention alternatives or when not to use it, so it stops short of 5, but the listing intent is unmistakable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It details the three output buckets (fixed, still_open, new_since_baseline), the remediation-rate percentage, and the plugin-ID-based comparison logic. It does not explicitly state read-only status or error handling, but the comparative verb and output-driven tone imply no side effects and give the agent a solid mental model.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences long, with no filler. It front-loads the primary action and expected result, then adds a single context sentence that explains the tool's purpose. Every clause earns its place, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the tool's purpose, input roles, and a high-level summary of the return buckets. Since an output schema exists, there is no need to detail the return structure further. It could mention prerequisites or failure modes, but for a simple two-parameter comparison tool, the provided context is practical and complete enough.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It references 'baseline scan' and 're-test scan,' which map directly to baseline_scan_id and retest_scan_id, clarifying their roles in the comparison. For only two self-explanatory integer parameters, this level of semantic context is sufficient.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with the specific verb 'Compare' and clearly identifies the resources (baseline scan vs. re-test scan) and the comparison dimension (by plugin ID). It distinguishes itself from sibling tools like compare_vpr_reprioritization by focusing on plugin-level delta and remediation reporting, making the tool's purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a clear, context-rich use case: 'Built for pentest/assessment re-test reporting where a client needs proof of what got remediated between engagement rounds.' This implies when to use the tool but does not explicitly mention alternative tools or state when not to use it, so it stops short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. 'List all' confirms a read-only operation and indicates no filtering or pagination, providing useful behavioral context. The tenant scope adds further precision. No hidden side effects are implied.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler. Every word contributes meaning, making it optimally concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter listing tool with an output schema, the description is fully complete. It clearly states the resource and scope, and the output schema covers return value details. No additional context is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the description appropriately omits parameter details. The baseline of 4 applies since there is no parameter complexity to explain.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('List') and resource ('asset tag categories and values'), clearly indicating what the tool does. It distinguishes this from sibling tools like list_assets or list_agents by focusing on tags.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly implies usage by stating 'configured in the tenant,' but it does not explicitly mention when to use this tool vs alternatives. Since the tool name is self-explanatory and the scope is clear, this is adequate with no major gaps.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavior. It does so by stating the return shape (per-plugin aggregate records with CVSS severity, VPR score, affected asset count) and the cap at 'limit' records. It also notes case-insensitivity for severity. This adds meaningful behavioral context beyond the schema, though it does not address side effects (none expected for a search) or pagination details beyond the cap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Four sentences, every one delivers essential info: what the tool does, filter options with examples, return shape, and a limit caveat. No fluff or repetition. The main action is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given three optional parameters, no annotations, but an output schema that likely documents return fields, the description covers the core purpose, parameter semantics, and the limit behavior. It is sufficiently complete for an AI agent to select and invoke the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has zero descriptions and no enums, so the description carries the full burden. It explains the allowed severity values ('info', 'low', 'medium', 'high', 'critical'), case-insensitivity, provides an example for plugin_family ( ["Windows", "Web Servers"]), and specifies that limit caps the number of records. This is rich semantic detail that the schema lacks.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource: 'Search current findings across the tenant via the vulnerability workbench.' It clearly distinguishes from sibling tools like get_asset_details or list_assets, which address different resources (assets, plugins, scans). The scope and action are unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use the tool: when searching for vulnerability findings with optional severity/family filters. It gives concrete filter examples, making the use case clear. However, it does not explicitly mention alternatives or exclusions, so it stops short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![tenable-vpr-mcp MCP server](https://glama.ai/mcp/servers/Sabastiaz/tenable-vpr-mcp/badges/card.svg)](https://glama.ai/mcp/servers/Sabastiaz/tenable-vpr-mcp)

Score Badge

Copy to your README.md:

[![tenable-vpr-mcp MCP server](https://glama.ai/mcp/servers/Sabastiaz/tenable-vpr-mcp/badges/score.svg)](https://glama.ai/mcp/servers/Sabastiaz/tenable-vpr-mcp)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/Sabastiaz/tenable-vpr-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server