SpiderFoot MCP Server

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation5/5
Each tool has a clearly distinct purpose with no overlap: listing event types, exporting results, listing modules, pinging the server, fetching scan data (regular and unique), retrieving scan metadata, fetching logs, listing scans, and starting a scan. The descriptions make it easy to differentiate between them, such as distinguishing scan_data from scan_data_unique or scan_info from scan_logs.
Naming Consistency5/5
All tool names follow a consistent snake_case pattern with a 'spiderfoot_' prefix and descriptive suffixes (e.g., event_types, export_json, start_scan). This uniformity makes the tools predictable and easy to understand, with no deviations in style or structure across the set.
Tool Count5/5
With 10 tools, the server is well-scoped for managing SpiderFoot scans, covering key operations like listing, starting, fetching data, and exporting results. Each tool serves a specific function without redundancy, making the count appropriate for the domain of security scanning and reconnaissance.
Completeness5/5
The tool set provides complete coverage for scan management: listing scans, starting scans, retrieving metadata, data, logs, and exporting results, along with auxiliary functions like pinging and listing modules/event types. There are no obvious gaps, as it supports the full lifecycle from initiation to analysis and export.
Average 3/5 across 10 of 10 tools scored. Lowest: 2.4/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
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

Behavior2/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. It mentions exporting results but doesn't disclose behavioral traits such as whether this is a read-only operation, if it requires specific permissions, rate limits, or what the output looks like. For a tool with no annotations, this is a significant gap in transparency.
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 very concise with a single sentence, which is efficient and front-loaded. However, it's somewhat cryptic ('for CSV of IDs' could be clearer), and while there's no wasted text, it might be too brief to be fully informative.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no annotations, no output schema, and low parameter coverage, the description is incomplete. It doesn't provide enough context for an agent to understand the tool's behavior, output, or how it fits with siblings. For a tool with these gaps, more detail is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 1 parameter with 0% description coverage, and the description adds minimal semantics. It implies 'ids' relates to scan IDs in CSV format, but doesn't explain the format, constraints, or examples. This doesn't adequately compensate for the low schema coverage, leaving the parameter poorly understood.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool exports scan results in JSON format, which provides a basic purpose. However, it's vague about the resource scope ('for CSV of IDs' is ambiguous) and doesn't clearly distinguish from siblings like spiderfoot_scan_data or spiderfoot_scan_data_unique that might also retrieve scan data. It specifies the output format but lacks clarity on what exactly is exported.
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?
No explicit guidance on when to use this tool versus alternatives is provided. The description mentions 'for CSV of IDs', which might imply usage with multiple scan IDs, but it doesn't clarify prerequisites, when not to use it, or compare to sibling tools. This leaves the agent without clear usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/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 mentions fetching results but doesn't specify whether this is a read-only operation, if it requires authentication, rate limits, or what the output format looks like. This leaves significant gaps for a tool that likely interacts with scan data.
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, efficient sentence with no wasted words. It's appropriately sized and front-loaded, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of scan data tools, no annotations, no output schema, and low parameter coverage, the description is incomplete. It doesn't explain what 'unique' entails, how results are returned, or provide enough context for safe and effective use by an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, so parameters 'id' and 'eventType' are undocumented. The description adds no meaning beyond the schema, failing to explain what 'id' refers to (e.g., scan ID) or how 'eventType' filters results. This doesn't compensate for the low coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Fetch unique scan event results' clearly states the action (fetch) and resource (unique scan event results), but it's vague about what 'unique' means and doesn't differentiate from sibling tools like 'spiderfoot_scan_data' or 'spiderfoot_scan_logs'. It provides a basic purpose but lacks specificity.
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?
No guidance is provided on when to use this tool versus alternatives such as 'spiderfoot_scan_data' or 'spiderfoot_scan_logs'. The description implies usage for fetching data but offers no context on prerequisites, exclusions, or comparisons with siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/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 states it 'fetches' results, implying a read-only operation, but doesn't specify if it requires authentication, has rate limits, returns paginated data, or what the output format is (e.g., JSON, raw text). This leaves significant gaps for a tool that retrieves data.
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, direct sentence with no wasted words. It's front-loaded with the core action ('Fetch scan event results') and condition ('for a scan ID'), making it efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (2 parameters, no annotations, no output schema), the description is incomplete. It doesn't explain the return values, error conditions, or behavioral traits like data format or access requirements. For a data-fetching tool with undocumented parameters, this minimal description is insufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/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 mentions 'scan ID' which maps to the 'id' parameter, but doesn't explain the 'eventType' parameter at all (e.g., what types are available, if it's optional for filtering). This partial coverage fails to fully clarify the parameters beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Fetch') and resource ('scan event results') with a specific condition ('for a scan ID'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'spiderfoot_scan_data_unique' or 'spiderfoot_scan_logs', which likely also retrieve scan-related data.
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?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing scan ID), exclusions, or comparisons to siblings like 'spiderfoot_scan_data_unique' for unique results or 'spiderfoot_scan_logs' for logs, leaving the agent to infer usage from context alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/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 mentions 'fetch/poll', suggesting it might retrieve or monitor logs, but fails to clarify key traits such as whether this is a read-only operation, potential side effects, authentication needs, rate limits, or the format of returned logs. This is inadequate for a tool with multiple parameters and no output schema.
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, efficient sentence that directly states the tool's function without unnecessary words. It is front-loaded and appropriately sized, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (4 parameters, no annotations, no output schema), the description is incomplete. It lacks details on behavioral traits, parameter purposes beyond 'id', and what the tool returns (e.g., log format or structure). This leaves significant gaps for the agent to understand and use the tool effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, so the description must compensate, but it only references the 'id' parameter ('for a given scan ID') and ignores 'limit', 'reverse', and 'rowId'. This adds minimal meaning beyond the schema, leaving most parameters undocumented and their purposes unclear to the agent.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('fetch/poll') and resource ('scan logs') with a specific scope ('for a given scan ID'), making the purpose understandable. However, it doesn't differentiate from siblings like 'spiderfoot_scan_data' or 'spiderfoot_scan_info', which might also retrieve scan-related information, so it doesn't fully distinguish itself.
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?
The description provides minimal guidance by implying usage when logs for a specific scan ID are needed, but it offers no explicit advice on when to use this tool versus alternatives (e.g., 'spiderfoot_scan_data' or 'spiderfoot_scan_info'), prerequisites, or exclusions. This leaves the agent with insufficient context for optimal selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/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 states the tool starts a scan but doesn't mention critical traits such as whether this is a long-running operation, what permissions are required, potential rate limits, or what happens if a scan with the same name exists. This leaves significant gaps in understanding the tool's behavior.
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 extremely concise with a single sentence that directly states the tool's purpose. It is front-loaded with no wasted words, making it easy to parse quickly. This efficiency is appropriate for a simple action, though it sacrifices detail for brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of starting a scan (a potentially resource-intensive operation), no annotations, 0% schema coverage, and no output schema, the description is incomplete. It doesn't address key aspects like expected return values, error conditions, or operational constraints, making it inadequate for safe and effective use by an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, so the description must compensate by explaining parameters. It adds no meaning beyond the schema, failing to clarify what 'scanname', 'scantarget', 'modulelist', 'typelist', or 'usecase' represent. For example, it doesn't indicate if 'scantarget' is a URL, IP address, or domain, leaving parameters largely undocumented.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Start a new scan') and target ('against a target'), providing a specific verb+resource combination. However, it doesn't differentiate this tool from sibling tools like 'spiderfoot_scans' or 'spiderfoot_scan_info', which might also relate to scan operations, leaving some ambiguity about its unique role.
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?
No guidance is provided on when to use this tool versus alternatives. The description lacks context about prerequisites (e.g., whether a target must be pre-configured) or comparisons to sibling tools like 'spiderfoot_scans' (which might list scans) or 'spiderfoot_scan_data' (which might retrieve results). This omission leaves the agent without clear usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/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 states the tool retrieves metadata/config, implying a read-only operation, but does not specify if it requires authentication, has rate limits, or details the return format. This leaves significant gaps in understanding how the tool behaves beyond its basic purpose.
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, clear sentence with no wasted words, making it highly concise and front-loaded. It efficiently communicates the core purpose without unnecessary elaboration, earning a top score for brevity and structure.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (retrieving metadata/config), lack of annotations, and no output schema, the description is incomplete. It does not cover behavioral aspects like error handling, response format, or usage context, which are crucial for an agent to invoke the tool correctly in a real-world scenario.
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 input schema has one parameter ('id') with 0% description coverage, so the schema provides no semantic context. The description adds minimal value by implying 'id' refers to a scan ID, but does not explain format, constraints, or examples. Since there is only one parameter, the baseline is higher, but the description does not fully compensate for the lack of schema details.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Retrieve') and resource ('scan metadata/config for a scan ID'), making the purpose understandable. However, it does not explicitly differentiate from sibling tools like 'spiderfoot_scans' or 'spiderfoot_scan_data', which might also retrieve scan-related information, so it falls short of a perfect score.
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?
The description provides no guidance on when to use this tool versus alternatives, such as distinguishing it from 'spiderfoot_scans' (which might list scans) or 'spiderfoot_scan_data' (which might retrieve actual scan results). There is no mention of prerequisites or context for usage, leaving the agent to infer based on tool names alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/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 states the tool lists scans but doesn't mention any behavioral traits such as whether it's read-only, if it includes pagination, rate limits, or authentication needs. This is a significant gap for a tool with no annotation coverage.
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 extremely concise and front-loaded, consisting of a single, clear sentence that directly states the tool's function. There is no wasted verbiage, making it efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description is incomplete. It doesn't explain what the return values include (e.g., scan IDs, statuses, timestamps) or any behavioral context like pagination. For a tool that lists data, this leaves the agent with insufficient information to use it effectively.
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 has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add parameter details, which is appropriate, but it could have hinted at implicit parameters like filtering options. Since there are no parameters, a baseline of 4 is justified, as the description doesn't need to compensate for any gaps.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('List') and resource ('all scans'), making it immediately understandable. However, it doesn't differentiate from sibling tools like 'spiderfoot_scan_info' or 'spiderfoot_scan_data', which might also retrieve scan information, so it falls short of a perfect score.
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?
The description provides no guidance on when to use this tool versus alternatives. With siblings like 'spiderfoot_scan_info' or 'spiderfoot_scan_data' that might retrieve specific scan details, there's no indication of scope (e.g., this lists all scans broadly vs. others for detailed data), leaving usage ambiguous.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/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 states 'List available SpiderFoot event types,' which implies a read-only operation, but doesn't specify if it returns all types, requires authentication, has rate limits, or describes the return format (e.g., list, JSON). For a tool with zero annotation coverage, this is insufficient.
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, clear sentence with zero waste. It's front-loaded with the core action ('List') and resource, making it highly efficient. Every word earns its place, and there's no redundancy or unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is minimally adequate. It states what the tool does but lacks details on behavior, output, or usage context. For a list tool with no structured data to rely on, it should provide more guidance on what 'event types' entail and how to use the result.
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 0 parameters, and schema description coverage is 100%, so there are no parameters to document. The description doesn't need to add parameter semantics, and it correctly avoids mentioning any. A baseline of 4 is appropriate as it doesn't mislead or omit parameter info.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('available SpiderFoot event types'), making the purpose unambiguous. It distinguishes from siblings like 'spiderfoot_modules' or 'spiderfoot_scans' by specifying 'event types' rather than modules or scans. However, it doesn't explicitly differentiate from all siblings (e.g., 'spiderfoot_scan_data' also lists data), so it's not a perfect 5.
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?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, context (e.g., before starting a scan), or comparisons to siblings like 'spiderfoot_modules' (which lists modules, not event types). This leaves the agent without explicit usage instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/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 states it 'lists' modules, implying a read-only operation, but does not specify details like response format, pagination, or error handling. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.
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, efficient sentence that directly states the tool's purpose without any fluff or redundancy. It is front-loaded and wastes no words, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is minimally adequate. It states what the tool does but lacks details on behavior, output, or usage context, which could be helpful for an agent. It meets the baseline for a simple list tool but does not excel.
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 has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately does not discuss parameters, earning a baseline score of 4 for not adding unnecessary information.
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 verb ('List') and the resource ('available SpiderFoot modules'), making the purpose specific and unambiguous. It distinguishes itself from siblings like 'spiderfoot_scans' (which lists scans) or 'spiderfoot_event_types' (which lists event types), focusing specifically on modules.
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?
The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, context (e.g., before starting a scan), or exclusions, leaving the agent to infer usage based on the tool name alone.
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 full burden. It discloses the behavioral trait of checking server response, which is appropriate for a ping operation. However, it lacks details like expected response format, timeout behavior, or error handling, which could enhance transparency for an agent.
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, efficient sentence that front-loads the purpose without unnecessary words. Every part ('Ping SpiderFoot server to verify it is responding') earns its place by clearly conveying the tool's function in a minimal format.
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 low complexity (0 parameters, no output schema, no annotations), the description is complete enough for a basic ping operation. It covers the core purpose and context. However, without an output schema, adding a hint about the response (e.g., success/failure status) could improve completeness for agent use.
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 has 0 parameters with 100% coverage, so no parameter documentation is needed. The description adds no parameter information, which is acceptable here. A baseline of 4 is applied as it adequately handles the zero-parameter case without redundancy.
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 specific action ('Ping') and target resource ('SpiderFoot server') with the explicit purpose of 'verify it is responding.' It distinguishes from siblings like 'spiderfoot_start_scan' or 'spiderfoot_scan_data' by focusing on server availability rather than operational tasks.
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 usage context for verifying server responsiveness, which is clear for a ping tool. However, it does not explicitly state when not to use it or name alternatives, such as using other tools only after confirming server availability, leaving room for improvement in sibling differentiation.
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:

[![Spiderfoot-MCP-Server MCP server](https://glama.ai/mcp/servers/CorbettCajun/Spiderfoot-MCP-Server/badges/card.svg)](https://glama.ai/mcp/servers/CorbettCajun/Spiderfoot-MCP-Server)

Score Badge

Copy to your README.md:

[![Spiderfoot-MCP-Server MCP server](https://glama.ai/mcp/servers/CorbettCajun/Spiderfoot-MCP-Server/badges/score.svg)](https://glama.ai/mcp/servers/CorbettCajun/Spiderfoot-MCP-Server)

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/CorbettCajun/Spiderfoot-MCP-Server'

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