qualys-mcp
Provides tools for interacting with Qualys security data, enabling vulnerability management, cloud security, container security, compliance checks, remediation planning, security overviews, and report management.
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., "@qualys-mcpGive me a security overview"
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.
Qualys MCP Server
ā ļø Unofficial project. This is a personal project to showcase the viability of connecting AI assistants to Qualys via the Model Context Protocol. It is not affiliated with, endorsed by, or supported by Qualys, Inc.
An MCP server that connects AI assistants to Qualys security data. 7 workflow tools covering vulnerability management, cloud security, containers, compliance, remediation, and more. Pure Python, zero config beyond credentials.
What's new in v0.2.9
Streamable HTTP + Docker support ā run the server as a persistent, network-reachable container instead of stdio-only (see Run with Docker below).
Fixed per-asset detections in issue #229.
Breaking: now requires Python ā„3.10 and
fastmcpā„2.11 ā Python 3.9 installs are no longer supported.
Related MCP server: Exegol MCP Server
Setup
Add to ~/Library/Application Support/Claude/claude_desktop_config.json:
{
"mcpServers": {
"qualys": {
"command": "uvx",
"args": ["qualys-mcp"],
"env": {
"QUALYS_USERNAME": "your-username",
"QUALYS_PASSWORD": "your-password",
"QUALYS_POD": "US2"
}
}
}
}Set QUALYS_POD to your platform POD ā the server derives the correct API and gateway URLs automatically.
Supported pods: US1 US2 US3 US4 EU1 EU2 EU3 IN1 CA1 AE1 UK1 AU1 KSA1
Advanced: If you need to override the auto-derived URLs, set
QUALYS_BASE_URLandQUALYS_GATEWAY_URLexplicitly instead ofQUALYS_POD. Explicit URLs take priority.
Requires uv: brew install uv or curl -LsSf https://astral.sh/uv/install.sh | sh
Updating
uvx caches the resolved build, so a plain uvx qualys-mcp keeps running the
version it first downloaded ā it does not auto-upgrade when a new release
ships. To move to the latest version, clear the cache and restart Claude Desktop:
uv cache clean qualys-mcpTo pin (and control) the version explicitly, set it in your config args:
"args": ["qualys-mcp@0.2.7"]pip install -U qualys-mcp only updates a pip-installed copy ā it has no effect
on the uvx-launched server.
Alternative
pip install qualys-mcp
qualys-mcpSelf-Signed Certificates
For environments with self-signed certs, add "QUALYS_SSL_VERIFY": "false" to the env block.
Run with Docker (Streamable HTTP)
Prefer a persistent, network-reachable server over the uvx stdio setup above? Run it as a container instead:
docker build -t qualys-mcp:latest .
cp .env.example .env
$EDITOR .env # set your Qualys credentials
docker compose up -d
claude mcp add --transport http qualys http://127.0.0.1:8000/mcp/See docs/DOCKER.md for the full guide: environment variables, connecting other MCP clients, security notes, and troubleshooting.
Tools
7 workflow tools that intelligently dispatch to 42 internal aggregators across all Qualys modules. Each tool handles routing, concurrent API calls, cross-domain correlation, and response synthesis automatically.
Tool | What it answers |
| Deep-dive any security topic ā CVEs, threat actors, assets, EDR/FIM events, KB searches |
| Cross-domain risk ā VMs, cloud (AWS/Azure/GCP/OCI), containers, web apps, certificates, assets |
| Compliance posture ā PCI, HIPAA, CIS, NIST, SOC2 pass/fail, failing controls, exceptions |
| Patch priorities, deployment status, mitigation coverage, program gap analysis |
| Daily/weekly/monthly briefing ā scanner health, scan status, vulnerability findings |
| Generate, list, download, and manage Qualys reports |
| View and clear API caches |
Key Parameters
investigate
targetā CVE ID, threat actor, hostname, IP, or free-text topicdepthāquick(~10s) /standard(~20s) /deep(~45s)scopeāall/vulns/threats/assets/edr/fim
assess_risk
scopeāall/cloud/containers/web/certs/assetstag/asset_groupā filter by business groupproviderāaws/azure/gcp(cloud scope)asset_idā single asset deep-dive
check_compliance
frameworkāPCI/HIPAA/CIS/NIST/SOC2include_exceptionsā include risk acceptances
plan_remediation
scopeāall/patches/mitigations/programseverityācritical/high/moderatecves/qidsā check mitigation coverage for specific vulns
security_overview
periodātoday/week/monthquickā fast snapshot (~2s) vs full briefing
Example Conversations
Daily Operations
"Give me a security overview" ā security_overview(quick=True)
"What happened this week?" ā security_overview(period="week")
"What should we patch first?" ā plan_remediation(scope="patches", severity="critical")
"How's our compliance?" ā check_compliance()Investigation
"Tell me about CVE-2024-3400" ā investigate(target="CVE-2024-3400")
"Are we exposed to ransomware?" ā investigate(target="ransomware")
"What do we know about Iranian threats?" ā investigate(target="iran")
"Investigate this host: 10.0.0.1" ā investigate(target="10.0.0.1", scope="edr")Risk Assessment
"What's our overall risk?" ā assess_risk(scope="all")
"How's our cloud security?" ā assess_risk(scope="cloud")
"Any container vulnerabilities?" ā assess_risk(scope="containers")
"Web app security status?" ā assess_risk(scope="web")
"Show me risk for Production assets" ā assess_risk(tag="Production")Compliance & Remediation
"Are we PCI compliant?" ā check_compliance(framework="PCI")
"What's our patch coverage?" ā plan_remediation(scope="patches")
"Is there a mitigation for CVE-2024-3400?" ā plan_remediation(cves=["CVE-2024-3400"])
"What security gaps do we have?" ā plan_remediation(scope="program")Multi-Step Workflows
"New critical CVE dropped ā what do I need to know?"
ā investigate(target="CVE-...") ā plan_remediation(cves=["CVE-..."]) ā check_compliance()
"Prepare me for the weekly security standup"
ā security_overview(period="week") ā assess_risk(scope="all") ā plan_remediation(scope="patches")
"PCI audit prep"
ā check_compliance(framework="PCI", include_exceptions=True) ā assess_risk(scope="all") ā plan_remediation()Architecture
AI Assistant ā qualys_mcp.py (7 tools) ā workflows/ (dispatch + synthesis) ā aggregators.py (42 functions) ā api.py (HTTP + caching) ā Qualys APIsEach workflow tool:
Builds a dispatch plan based on parameters
Runs selected aggregators concurrently
Merges results into a unified response envelope
Applies cross-domain correlation
Returns prioritized findings and recommended actions
Performance
Tested on an 89,000-asset environment (US2 POD):
Workflow | Time |
| 1.7s |
| 1.3s |
| 3.1s |
| <1ms (cached) |
| 2.6s |
| ~33s |
| 4.9s |
Cold start: The first query after launching takes 2-10s longer while the bearer token is acquired and caches warm up. A background thread pre-fetches VMDR detections on startup. After the first query, responses are significantly faster. Ask
security_overview(quick=True)first to warm caches.
Eval Harness
300 routing test questions + 900 variants + 30 multi-turn conversation workflows for automated evaluation.
# Install eval dependencies
pip install anthropic mcp python-dotenv pyyaml
# Run eval
python -m eval --quickTesting
# Unit tests (282 tests)
pip install pytest
pytest tests/ --ignore=tests/conversations -q
# Smoke test
bash test_tools.sh fastQualys PODs
POD | BASE_URL | GATEWAY_URL |
US1 | qualysapi.qualys.com | gateway.qg1.apps.qualys.com |
US2 | qualysapi.qg2.apps.qualys.com | gateway.qg2.apps.qualys.com |
US3 | qualysapi.qg3.apps.qualys.com | gateway.qg3.apps.qualys.com |
US4 | qualysapi.qg4.apps.qualys.com | gateway.qg4.apps.qualys.com |
EU1 | qualysapi.qualys.eu | gateway.qg1.apps.qualys.eu |
EU2 | qualysapi.qg2.apps.qualys.eu | gateway.qg2.apps.qualys.eu |
EU3 | qualysapi.qg3.apps.qualys.eu | gateway.qg3.apps.qualys.eu |
IN1 | qualysapi.qg1.apps.qualys.in | gateway.qg1.apps.qualys.in |
CA1 | qualysapi.qg1.apps.qualys.ca | gateway.qg1.apps.qualys.ca |
AE1 | qualysapi.qg1.apps.qualys.ae | gateway.qg1.apps.qualys.ae |
UK1 | qualysapi.qg1.apps.qualys.co.uk | gateway.qg1.apps.qualys.co.uk |
AU1 | qualysapi.qg1.apps.qualys.com.au | gateway.qg1.apps.qualys.com.au |
KSA1 | qualysapi.qg1.apps.qualysksa.com | gateway.qg1.apps.qualysksa.com |
License
MIT - Copyright (c) 2026 Andrew Nelson
Available Tools
8 toolsassess_riskA
[Risk Assessment] Cross-domain risk assessment ā VMs, cloud, containers, web apps, certificates, assets. @slow
USE WHEN: "what's our risk?", "show me cloud risk in AWS", "top risky assets", "container vulnerabilities", "expiring certificates", "EOL systems", "risk by business unit", "how's our security posture?"
| Name | Required | Description | Default |
|---|---|---|---|
| os | No | OS filter | |
| tag | No | filter by tag/business group | |
| days | No | time window (default 30) | |
| limit | No | max results per data source (default 20) | |
| query | No | hostname/asset name search | |
| scope | No | "all" | "cloud" | "containers" | "web" | "certs" | "assets" | "fim" | "edr" | "infrastructure" | all |
| detail | No | "summary" | "standard" | "detailed" | standard |
| service | No | cloud service filter (S3, IAM, EC2, Lambda, etc.) | |
| sort_by | No | "trurisk" | "severity" | trurisk |
| app_name | No | web application name filter | |
| asset_id | No | single asset deep-dive (skips broad queries) | |
| eol_only | No | only end-of-life assets | |
| image_id | No | specific container image | |
| provider | No | "aws" | "azure" | "gcp" (cloud scope) | |
| weak_only | No | only certificates with issues | |
| account_id | No | specific cloud account | |
| asset_group | No | filter by asset group | |
| per_account | No | include per-account breakdown | |
| breakdown_by | No | "tag" | "none" | tag |
| weak_ciphers | No | filter for weak cipher suites | |
| owasp_category | No | OWASP Top 10 category (Injection, XSS, etc.) | |
| days_since_scan | No | scan gap filter (days) | |
| days_since_seen | No | stale asset filter (days) | |
| include_expired | No | include expired certificates | |
| protocol_filter | No | TLS version filter (TLSv1.0, SSLv3, etc.) | |
| insecure_renegotiation | No | filter for insecure TLS renegotiation |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses that the tool is '@slow' and spans multiple domains, but does not explicitly state that it is read-only, which data sources it queries, or any side effects. The output schema covers return structure, but the behavior beyond speed is somewhat opaque.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded with the core purpose and a performance warning ('@slow'). The 'USE WHEN' list is directly relevant and adds no fluff. Every sentence and clause earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (26 parameters) and the absence of annotations, the description is relatively sparse. It provides high-level usage scenarios but does not explain parameter interactions (e.g., asset_id skipping broad queries), how results are aggregated across domains, or how to interpret the output. The rich schema and output schema help compensate, but the description alone leaves gaps for such a feature-rich tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so parameter descriptions exist. The tool description adds value by mapping natural language to specific parameters, e.g., 'cloud risk in AWS' implies provider='aws' and scope='cloud', and 'container vulnerabilities' implies scope='containers'. This semantic mapping goes beyond the schema's literal field descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a clear, specific purpose: cross-domain risk assessment across VMs, cloud, containers, web apps, certificates, and assets. The 'USE WHEN' examples further specify intent ('what's our risk?', 'show me cloud risk in AWS'). This distinguishes it from siblings like security_overview by emphasizing the cross-domain aggregation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a 'USE WHEN' section with concrete example queries, giving clear context for when to invoke the tool. It does not explicitly mention alternative tools or when not to use it, so it falls short of a 5, but the examples are strong enough to effectively guide selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
aws_org_connectorsA
[Cloud] AWS Organization connectors ā list and health status for multi-account AWS setups.
USE WHEN: "show AWS org connectors", "AWS Organizations status", "multi-account cloud connector health", "which AWS accounts are connected", "AWS org sync status"
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | max connectors to return (default 50) | |
| detail | No | "summary" | "standard" | "detailed" | standard |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the behavioral burden. It implies a read-only operation via 'list and health status' but does not describe return details, pagination, or potential rate limiting. This is acceptable for a simple list tool but leaves some behavioral aspects unspecified.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence followed by a 'USE WHEN' list, with no redundant wording. It front-loads the core purpose and provides immediately useful trigger phrases.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The presence of an output schema and fully described parameters means the description only needs to convey purpose and usage context, which it does effectively. The sibling tool list adds context, and the tool is simple enough that no more behavioral detail is required.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema fully documents both parameters with descriptions: 'limit' (max connectors, default 50) and 'detail' (summary/standard/detailed). The tool description adds no additional parameter-level meaning, so it relies on the schema's 100% coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool 'list and health status for multi-account AWS setups,' with a specific verb and resource. It distinguishes itself from sibling tools like cache_status or investigate by focusing on AWS Organization connectors.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
A 'USE WHEN' section provides explicit trigger phrases like 'show AWS org connectors' and 'AWS Organizations status', giving clear context for when to use this tool. It does not explicitly mention when not to use it or name alternatives, but the sibling list and distinct purpose make the usage context clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
cache_statusB
[Admin] Show cache stats or clear all caches.
| Name | Required | Description | Default |
|---|---|---|---|
| clear | No | True to clear all caches, False to show stats only |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It states the two modes (show stats/clear caches) but does not disclose side effects of clearing caches, such as performance impact, irreversibility, or potential disruption to other users.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no wasted words. The '[Admin]' tag gives immediate context, and all information is relevant and efficiently presented.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simplicity of the tool (one boolean parameter and an output schema), the description is minimal but adequate for basic usage. However, the lack of any warning or context around the destructive 'clear' operation, combined with no annotations, leaves the description incomplete for safe usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, and the parameter description already explains the 'clear' flag. The tool description essentially restates the parameter behavior without adding additional meaning, so it meets the baseline but doesn't exceed it.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool displays cache statistics or clears all caches. The '[Admin]' prefix and verbs 'Show'/'clear' specify the action and resource, making it distinct from sibling security/risk tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives. The '[Admin]' prefix implies administrative context, but there is no mention of prerequisites, exclusions, or when clearing vs. showing is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
check_complianceA
[Compliance] Compliance posture assessment ā framework pass/fail rates, failing controls, risk acceptances. @slow
USE WHEN: "are we PCI compliant?", "compliance gaps", "show failing controls", "risk acceptances expiring", "HIPAA posture", "CIS benchmark results", "what frameworks do we have?"
| Name | Required | Description | Default |
|---|---|---|---|
| tag | No | filter by tag | |
| limit | No | max results (default 20) | |
| detail | No | "summary" | "standard" | "detailed" | standard |
| platform | No | "windows" | "linux" (filter by platform) | |
| framework | No | "PCI" | "HIPAA" | "SOC2" | "CIS" | "NIST" | "" (all frameworks) | |
| vuln_type | No | "False Positive" | "Compensating Control" | |
| asset_group | No | filter by asset group | |
| days_to_expiry | No | show exceptions expiring within N days (default 30) | |
| exception_status | No | "Active" | "Expired" | "Pending" | Active |
| include_exceptions | No | include vulnerability exceptions/risk acceptances |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description carries the burden for behavioral disclosure. It notes '@slow' as a performance characteristic but does not mention other behavioral aspects such as how data is fetched, whether it provides real-time or cached data, or any permission requirements. The output schema may cover return format, but the description itself offers limited behavioral insight.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, uses a clear structure with a summary line and a 'USE WHEN' section, and every sentence adds value. It front-loads the core purpose without unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (10 optional parameters) and the presence of an output schema, the description covers the main purpose and usage scenarios effectively. However, it omits guidance on how parameters interact (e.g., whether framework and platform are mutually exclusive), and the '@slow' hint could imply performance constraints without elaboration. Still, it is largely complete for an agent to decide when to invoke it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so parameters are fully documented in the schema. The description does not add further detail beyond the schema; it only lists examples of user intents. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function as a compliance posture assessment and lists specific outputs (framework pass/fail rates, failing controls, risk acceptances). It distinguishes from sibling tools by focusing on compliance frameworks and providing example queries in the USE WHEN section.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The USE WHEN section provides explicit example queries covering common use cases (PCI compliance, compliance gaps, failing controls, risk acceptances, HIPAA, CIS, frameworks). However, it does not explicitly state situations where alternative tools (e.g., assess_risk, security_overview) should be preferred instead, so it falls short of full 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
investigateA
[Investigation] Deep-dive investigation on any security topic ā CVEs, threat actors, assets, endpoint events, vulnerability intelligence. @slow
USE WHEN: "tell me about CVE-2024-3400", "are we exposed to Lazarus Group?", "investigate this IP", "what ransomware vulns exist?", "deep dive on Log4Shell", "what's happening on 10.0.0.1?"
| Name | Required | Description | Default |
|---|---|---|---|
| tag | No | filter affected assets by tag | |
| days | No | lookback window for events/vulns (default 7) | |
| depth | No | "quick" (~10s, 2 sources) | "standard" (~20s, 4 sources) | "deep" (up to ~4 min on cold caches, all sources + summary) | standard |
| limit | No | max results per data source (default 20) | |
| scope | No | "all" | "vulns" | "threats" | "assets" | "edr" | "fim" | all |
| detail | No | "summary" | "standard" | "detailed" (includes raw aggregator output) | standard |
| target | Yes | CVE ID, threat actor/nation, hostname, IP address, or free-text topic | |
| audience | No | "technical" | "management" | "executive" (for deep investigation summaries) | technical |
| software | No | software name filter for KB search (e.g. "Apache", "OpenSSL") | |
| asset_group | No | filter by asset group | |
| threat_type | No | RTI filter ā Ransomware, Active_Attacks, Cisa_Known_Exploited_Vulns, etc. | |
| prior_context | No | summary from a previous investigation for chaining |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must convey behavioral traits on its own. It includes '@slow' as a warning about latency and mentions 'deep-dive', implying heavy processing. However, it does not disclose whether the tool is read-only, the data sources accessed, or any rate limits, leaving behavioral transparency incomplete.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is exceptionally concise: a one-sentence summary followed by a short list of example queries. It is front-loaded with the core purpose, and every elementāincluding the '@slow' note and examplesāearns its place without redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (12 parameters) and the existence of an output schema, the description is fairly complete. It clearly explains the tool's scope, provides realistic usage examples, and flags latency. It lacks any mention of edge cases or limitations beyond slowness, but the detailed schema and output schema compensate for most gaps, meriting a 4.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, with all 12 parameters already having detailed descriptions in the input schema. The tool description itself adds no additional parameter semantics beyond the schema, so the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states a specific verb ('Deep-dive investigation') and resource ('any security topic'), listing concrete examples like CVEs, threat actors, assets, and endpoint events. It also includes example queries that distinguish it from sibling tools (e.g., 'assess_risk', 'reports') by emphasizing broad investigation over focused assessment or reporting.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The 'USE WHEN' section provides explicit example queries for when to invoke the tool, such as 'tell me about CVE-2024-3400' and 'are we exposed to Lazarus Group?'. This gives clear context on suitable scenarios, though it does not mention alternatives or when not to use it, preventing a score of 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
plan_remediationA
[Remediation] Remediation planning ā patch priorities, deployment status, mitigation coverage, program gaps. @slow
USE WHEN: "what should we patch?", "outstanding patches", "patch deployment status", "mitigation coverage", "is there a mitigation for CVE-X?", "what's missing from our security program?", "how do we reduce risk?"
| Name | Required | Description | Default |
|---|---|---|---|
| tag | No | filter by tag | |
| cves | No | check mitigation coverage for specific CVEs (list of strings) | |
| qids | No | check mitigation coverage for specific QIDs (list of ints) | |
| limit | No | max results (default 20) | |
| scope | No | "all" | "patches" | "mitigations" | "program" | all |
| detail | No | "summary" | "standard" | "detailed" | standard |
| status | No | patch job status filter | |
| platform | No | "windows" | "linux" | |
| severity | No | "critical" | "high" | "moderate" | |
| asset_group | No | filter by asset group |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description notes '@slow', giving a performance warning. Without annotations, it doesn't explicitly state whether the tool is read-only or whether it modifies anything; the word 'planning' implies non-destructive but this is not explicit. Thus partial transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and front-loaded with a clear summary, followed by usage examples. All content is useful and no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present and full parameter descriptions, the description's use cases and scope notes make it complete for most planning queries. Missing explicit information about limitations or interactions between parameters, but overall sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers 100% of parameters with descriptions, so baseline is 3. The description provides no additional parameter-specific semantics beyond the schema, so it stays at 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states its role: 'Remediation planning ā patch priorities, deployment status, mitigation coverage, program gaps.' This is a specific verb+resource and differentiates it from sibling tools like investigate or assess_risk by focusing on remediation planning.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides an explicit 'USE WHEN' list with natural language queries, making it clear when to invoke this tool. However, it doesn't mention alternatives or when not to use it, so it falls 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.
reportsB
[Reporting] Unified report operations ā list, templates, generate, status, download, delete.
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | "list" | "templates" | "generate" | "status" | "download" | "delete" | |
| report_id | No | report ID (for status/download/delete) | |
| template_id | No | template ID (for generate) | |
| report_title | No | custom title for generated report | |
| output_format | No | "pdf" | "html" | "mht" | "xml" | "csv" | "docx" (default pdf) | |
| template_name | No | filter templates by name substring | |
| asset_group_ids | No | comma-separated asset group IDs (for generate) |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden for behavioral disclosure. It only lists actions without explaining side effects, permissions, rate limits, or what happens after execution. This is a significant gap for a multi-action tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is brief and front-loaded with a '[Reporting]' tag, but it's terse to the point of omitting necessary context for a tool with 7 parameters and 6 actions. It's concise but under-specified.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (multiple actions, 7 params), the description fails to provide enough contextual information. The schema covers parameter details well, but the description doesn't explain the purpose of each action, usage sequence, or operational dependencies. Output schema may cover return values, but operational context is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds no additional parameter meaning beyond repeating the action list, which is already fully described in the schema's action parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description identifies the tool as handling report operations and enumerates the supported actions (list, templates, generate, status, download, delete). This clearly distinguishes it from the security-focused sibling tools. However, it doesn't elaborate on what each action does, so it's clear but not fully detailed.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for any report-related task by listing the available actions, but it doesn't explicitly state when to prefer this tool over alternatives or when to use each action. No exclusions or alternative references are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
security_overviewA
[Overview] Security briefing ā daily/weekly/monthly summary with scanner health, findings, and risk trends. @slow when quick=False
USE WHEN: "morning briefing", "what happened this week?", "security overview", "any new critical vulns?", "scanner status", "what needs attention today?"
| Name | Required | Description | Default |
|---|---|---|---|
| qql | No | QQL query for ETM findings | |
| tag | No | filter by tag | |
| limit | No | max results (default 50) | |
| quick | No | True for fast snapshot (~3s), False for full briefing (~10s) | |
| scope | No | "all" | "infrastructure" | "findings" | "risk" | all |
| detail | No | "summary" | "standard" | "detailed" | standard |
| period | No | "today" | "week" | "month" | today |
| severity | No | finding severity filter | |
| scan_state | No | comma-separated scan states (default "Running,Paused,Queued,Error") | Running,Paused,Queued,Error |
| asset_group | No | filter by asset group |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Since no annotations are provided, the description carries the full burden. It discloses the performance trade-off ('@slow when quick=False') and the general content of the briefing (scanner health, findings, risk trends), but it does not explicitly state that the tool is read-only, nor does it mention authentication requirements, rate limits, or other side effects. This is moderate disclosure but leaves gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured, opening with a clear title and purpose, followed by a compact definition of the summary content, and then a focused list of usage examples. There is no redundancy; every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of the tool (10 parameters, output schema), the description provides a high-level purpose and usage triggers, which is sufficient for an agent to decide when to invoke it. It does not repeat parameters that are fully documented in the schema, and the output schema covers return values. It could mention the configurable periods explicitly (daily/weekly/monthly) but these are inferred from the description and schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage for all 10 parameters, so the baseline is 3. The description does not add additional meaning beyond the schema, only referencing 'quick' indirectly through the performance note. All parameter details are already fully documented in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function as a 'Security briefing' that provides daily/weekly/monthly summaries of scanner health, findings, and risk trends. The 'USE WHEN' examples ('morning briefing', 'security overview', 'scanner status') distinguish it from sibling tools like investigate or reports, which focus on deeper analysis or custom reporting.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage scenarios with 'USE WHEN' trigger phrases, signaling appropriate contexts such as morning briefings and weekly retrospectives. However, it does not state when not to use the tool or explicitly mention alternative sibling tools, so it offers clear context but lacks exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
8 tool updates
v0.2.9- First observed
assess_risk - First observed
aws_org_connectors - First observed
cache_status - First observed
check_compliance - First observed
investigate - First observed
plan_remediation - First observed
reports - First observed
security_overview
TDQS
Scored across 8 tools
Each tool targets a distinct security domain: cache admin, investigation, risk, compliance, remediation, overview, reporting, and cloud connectors. The descriptions provide clear use cases that prevent confusion, with only minor overlap between assess_risk and security_overview that is still disambiguated by their scope.
Naming conventions are mixed: some tools use verb_noun (assess_risk, check_compliance, plan_remediation), some are bare verbs (investigate), and others are nouns or noun phrases (reports, aws_org_connectors, cache_status, security_overview). There is no consistent pattern across the set.
Eight tools is a well-scoped count for a broad security platform, covering major operational areas without bloat. Each tool represents a meaningful high-level capability, making the count appropriate.
The tool set covers the core security operations lifecycle: investigation, risk assessment, compliance, remediation, overview, reporting, and cloud connector management. Minor gaps exist such as explicit asset management or scan configuration, but these are workable through the provided tools.
Maintenance
Related MCP Connectors
- mcpOAuthcom.vibgrate
Query your team's drift, vulnerability, and upgrade data from any AI assistant. OAuth 2.1, 51 tools.
Pay-per-call cybersecurity for AI agents: vuln scans, threat intel, compliance, code security.
Real-time CVE, exploit, and vulnerability intelligence for AI assistants (350K+ CVEs, 115K+ PoCs)
- mcp-serverOAuthcom.make
Give your AI agents the tools to build, manage, and run automation workflows.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to perform penetration testing and security assessments by exposing 60+ Kali Linux security tools including network scanning, web security testing, password cracking, exploitation frameworks, and OSINT capabilities through an AI-friendly interface.2MIT
- FlicenseNot gradedqualityFmaintenanceEnables AI agents to interact with Exegol pentesting containers to execute commands and manage container status. It includes seven predefined workflows for automated security tasks such as web reconnaissance, port scanning, and vulnerability assessment.2-
- AlicenseNot gradedqualityDmaintenanceMCP server enabling AI assistants to interact with the Qualys vulnerability management platform. Supports investigation, risk assessment, compliance, remediation, security overview, and report management.92MIT
- AlicenseNot gradedqualityAmaintenanceBrings the full AlertLogic MDR platform into AI assistants, exposing 473+ tools for incident response, log search, SOAR automation, and multi-account security operations at MSSP scale.MIT