Skip to main content
Glama
JoeSandboxMCP

JoeSandboxMCP

Official
by joesecurity

Joe Sandbox MCP Server

A Model Context Protocol (MCP) server for interacting with Joe Sandbox Cloud.
This server exposes rich analysis and IOC extraction capabilities from Joe Sandbox and integrates cleanly into any MCP-compatible application (e.g. Claude Desktop, Glama, or custom LLM agents).

Features

  • Flexible Submission: Submit local files, remote URLs, websites, or command lines for dynamic analysis.

  • IOC Extraction: Retrieve indicators of compromise for dropped files, IPs, domains, and URLs.

  • Signature Detections: Retrieve and extract actionable evidence from sandbox signatures.

  • Process Trees: Visualize full execution hierarchies, including command lines and parent-child relationships.

  • Unpacked PE Files: Download in-memory unpacked binaries extracted during execution, often revealing runtime payloads.

  • PCAP Downloads: Retrieve the full network traffic capture (PCAP) recorded during analysis for offline inspection.

  • LLM-Suitable Responses: All results are structured for clear consumption by language models, with truncation and relevant filtering.

Related MCP server: didlogic_mcp

Quick Start

Installation via uv (Recommended)

  1. Clone the repository:

    git clone https://github.com/joesecurity/joesandboxMCP.git
    cd joesandboxMCP
  2. Install dependencies using uv:

    uv venv
    uv pip install -e .
  3. Launch the MCP server (see configuration below)


Example Configuration

{
  "mcpServers": {
    "JoeSandbox": {
      "command": "uv",
      "args": [
        "--directory",
        "/absolute/path/to/joesandboxMCP",
        "run",
        "main.py"
      ],
      "env": {
        "JBXAPIKEY": "your-jbxcloud-apikey",
        "ACCEPTTAC": "SET_TRUE_IF_YOU_ACCEPT"
      }
    }
  }
}

Use of this integration with Joe Sandbox Cloud requires acceptance of the Joe Security Terms and Conditions.

By setting the environment variable ACCEPTTAC=TRUE, you explicitly confirm that you have read and accepted the Terms and Conditions.


Available Tools

The Joe Sandbox MCP server provides a wide range of tools to help you interact with sandbox reports, monitor executions, and extract threat intelligence in a format that's easy for large language models to understand.

1. Submit Analysis

Submit files, URLs, websites, or command lines for sandbox analysis.
You can choose whether to wait for results or return immediately and check back later.
Supports various options like internet access, script logging, and archive passwords.

2. Search Past Analyses

Look up historical submissions using hashes, filenames, detection status, threat names, and more.
Quickly find whether something has already been analyzed.

3. Check Submission Status

Get the current status and key metadata for a previously submitted sample.
Includes detection verdict, systems used, and analysis score.

4. AI Summaries

Retrieve high-level reasoning statements generated by the sandbox's AI.
Helpful for understanding complex behavior in plain language.

5. Malicious Dropped Files

See which files were dropped during execution and marked as malicious.
Includes hash values, filenames, origin processes, and detection indicators.

6–8. Network Indicators

Show domains, IP addresses, or URLs contacted during analysis.
Can be filtered to focus only on clearly malicious items or high-confidence detections.
Includes details like IP resolution, geographic hints, communication context, and detection evidence.

9. Behavioral Detections (Signatures)

Get a summary of key behavioral detections triggered during execution.
Can be filtered to focus only on high impact items.

10. Process Tree

Visualize the full hierarchy of processes that ran during execution.
Shows parent-child relationships, command lines, and termination info.

11. Unpacked Binaries

Retrieve executable files that were unpacked or decrypted in memory.
Great for identifying payloads not visible in the original file.

12. Network Traffic (PCAP)

Download the full network packet capture recorded during analysis.
Useful for traffic inspection, C2 callbacks, or domain/IP extraction.

13. Recent Activity

List your most recent sandbox submissions and see what systems they ran on, how they scored, and what verdicts were returned.

14. Memory Dumps

Retrieve raw memory dumps captured during runtime.

15. Dropped Files

Retrieve all files dropped during analysis.


License

This project is licensed under the MIT License.

Available Tools

15 tools
get_ai_summariesA
Retrieve the AI summaries for a specific analysis run, either from cache or by downloading it.

Joe Sandbox analyses may run on multiple system configurations (e.g., different Windows/Linux variants).
Each run is indexed in the `runs` array of the analysis metadata. This function retrieves the report
corresponding to a specific run.

Args:
    webid: The submission ID of the analysis (unique identifier).
    run (optional, default = 0): The index of the analysis run to retrieve the report for.
                                 Use 0 for the first run, 1 for the second, etc.
                                 If not specified, defaults to 0 (the first run).

Returns:
    A dictionary containing AI reasoning summaries with fields:
    - webid: The analysis ID
    - run: The run index
    - reasonings: List of AI reasoning entries
    - count: Number of reasoning entries found

Notes:
    - Reports are cached in memory by key: "{webid}-{run}".
    - Use `run` to distinguish between different environments used during analysis.

Inputs: webid (required), run.

get_analysis_infoA
Retrieve metadata and status for a previously submitted analysis by its submission ID.

Use this tool to check whether an analysis is finished, whether the sample was classified as malicious,
and to retrieve contextual metadata such as score, system, and tags.

Args:
    webid (required): The submission ID (also called webid) returned when the sample was uploaded.

Returns:
    If successful, returns a dictionary with fields such as:

    - status (e.g. "finished", "in progress"): Global analysis state.
    - detection (e.g. "malicious", "clean"): Overall result summary.
    - score (integer, e.g. 0-100): The final aggregated threat score.
    - filename: The original filename or download URL of the submitted sample.
    - tags: A list of classification or behavioral tags.
    - scriptname: The Joe Sandbox script used to run the analysis.
    - has_malwareconfig: True if malware configuration extraction succeeded.
    - md5, sha1, sha256: Hashes of the submitted sample.
    - time: The ISO8601 timestamp when the analysis was submitted.
    - duration: Total time (in seconds) the analysis took.
    - classification: Internal or customer-specific label (if set).
    - comments: Analyst comments or notes.
    - encrypted: Whether the submitted file was password-protected.
    - threatname: Identified malware families or on behavioral or signature matches.

    - runs: A list of dictionaries describing individual analysis runs on different systems.
        Each run contains:
        - system: The sandbox environment used (e.g., "w7x64l", "w10x64", "lnxubuntu20").
        - score: Detection score for that system.
        - detection: Result for that specific system (e.g., "malicious", "clean").
        - yara, sigma, suricata: Boolean flags indicating whether detection engines matched.
        - error: Any error that occurred during that specific run.

    Notes:
        - The `runs` array is useful when the same sample is executed on multiple OS environments.
        - The top-level `score` and `detection` reflect the most severe result across all runs.

    If the submission ID is invalid or expired, returns an error object with a reason.

Inputs: webid (required).

get_domain_infoA
Retrieve domains in a completed analysis, along with their associated detection indicators.

This tool extracts domains gathered by the sandbox engine and returns relevant context such as resolved IP address, activity status, and detection metadata.
Optional filtering parameters allow control over the inclusion of domains and indicators based on their assessed severity.

Args:
    webid (required): The submission ID of the analysis.
    run (default: 0): Index of the sandbox run to inspect (from the `runs` array in analysis info).
    only_malicious_elements (default: True): If True, returns only domains explicitly classified as malicious by the sandbox engine.
    only_malicious_indicators (default: True): If True, limits the returned indicators to those considered clearly malicious by the detection logic.
        This excludes low-impact behavioral signals and focuses on indicators with a high likelihood of malicious intent or confirmed threat classification.
        If False, all observed indicators are included regardless of their severity.

Returns:
    A dictionary containing a list of malicious domains. Each entry includes:
      - name: The domain name.
      - ip: The resolved IP address, if available.
      - active: Whether the domain was reachable during analysis.
      - malicious: 'true' for domains classified as malicious
      - indicators: List of triggered detection rules, if any. Each entry includes:
          - desc: Description of the matched detection rule.
          - data: Matched content or signature.
          - source: The detection subsystem responsible (e.g. Suricata, Sigma, global traffic etc.).
            - impact: Either "high" or "low", indicating the severity or confidence of the detection.  
                High-impact indicators are strongly associated with malicious behavior or confirmed threats.  
                Low-impact indicators reflect general behavior or environmental traits that may not be malicious on their own.
Notes:
    - Empty Array returned if no domain was gathered during the analysis

Inputs: webid (required), run, only_malicious_elements, only_malicious_indicators.

get_dropped_filesA
Download all dropped files from a Joe Sandbox analysis.

This tool retrieves the 'dropped' archive from the specified analysis run and extracts
all contents into a local directory for further inspection.

Files are extracted as-is without renaming or classification.

Output path logic:
- If `save_path` is valid, dumps go to `{save_path}/droppedfiles/{webid}`
- If not, fallback is `droppedfiles/{webid}` under the current directory

Args:
    webid (str): Joe Sandbox analysis ID
    run (int, optional): Run index (default: 0)
    save_path (str, optional): Optional base path to save dumps

Returns:
    dict: {
        "output_directory": absolute path to extraction folder,
        "files": list of files with full path
        "note": status message (e.g. fallback notice)
    }

Inputs: webid (required), run, save_path.

get_dropped_infoA
Retrieve metadata for files dropped in a completed analysis, along with their associated detection indicators.

This tool returns information about dropped files for a specific sandbox run of an analysis.
Each result includes relevant metadata and detection indicators where available.

Args:
    webid (required): The submission ID of the analysis.
    run (optional, default = 0): The index of the analysis run to inspect.
                                 Use 0 for the first run, 1 for the second, etc.
    only_malicious_elements (default: True): If True, returns only dropped files explicitly classified as malicious by the sandbox engine.
    only_malicious_indicators (default: True): If True, limits the returned indicators to those considered clearly malicious by the detection logic.
        This excludes low-impact behavioral signals and focuses on indicators with a high likelihood of malicious intent or confirmed threat classification.
        If False, all observed indicators are included regardless of their severity.

Returns:
    A dictionary with:
      - webid: The analysis ID.
      - malicious_dropped_files: A list of dropped files marked as malicious, each with:
          - filename
          - sha256
          - size
          - type
          - process (originating process)
          - dump_name (sandbox-internal reference)
          - category (e.g., "dropped", "modified")
          - indicators: List of triggered detection rules, if any. Each entry includes:
              - desc: Description of the matched detection rule.
              - data: Matched content or signature.
              - source: The detection subsystem responsible (e.g. Suricata, Sigma, global traffic etc.).
                  - impact: Either "high" or "low", indicating the severity or confidence of the detection.  
                      High-impact indicators are strongly associated with malicious behavior or confirmed threats.  
                      Low-impact indicators reflect general behavior or environmental traits that may not be malicious on their own.
      - count: Total number of malicious dropped files found
Notes:
    - Empty Array returned if no dropped file was gathered during the analysis

Inputs: webid (required), run, only_malicious_elements, only_malicious_indicators.

get_ip_infoA
Retrieve IP addresses in a completed analysis, along with their associated detection indicators.

This tool extracts IP addresses gathered by the sandbox engine and returns relevant context such as geolocation, status, and detection metadata.
Optional filtering parameters allow control over the inclusion of IP addresses and indicators based on their assessed severity.

Args:
    webid (required): The submission ID of the analysis.
    run (default: 0): Index of the sandbox run to inspect (from the `runs` array in analysis info).
    only_malicious_elements (default: True): If True, returns only IP addresses explicitly classified as malicious by the sandbox engine.
    only_malicious_indicators (default: True): If True, limits the returned indicators to those considered clearly malicious by the detection logic.
        This excludes low-impact behavioral signals and focuses on indicators with a high likelihood of malicious intent or confirmed threat classification.
        If False, all observed indicators are included regardless of their severity.

Returns:
    A dictionary containing a list of malicious IP addresses. Each entry includes:
      - ip: The IP address in question.
      - country: Country code associated with the IP.
      - pingable: Whether the IP responded during analysis.
      - domain: Resolved domain name (if available).
      - malicious: 'true' for IP addresses classified as malicious
      - indicators: List of triggered detection rules, if any. Each entry includes:
          - desc: Description of the matched detection rule.
          - data: Matched content or signature.
          - source: The detection subsystem responsible (e.g. Suricata, Sigma, global traffic etc.).
            - impact: Either "high" or "low", indicating the severity or confidence of the detection.  
                High-impact indicators are strongly associated with malicious behavior or confirmed threats.  
                Low-impact indicators reflect general behavior or environmental traits that may not be malicious on their own.
Notes:
    - Empty Array returned if no ip was gathered during the analysis

Inputs: webid (required), run, only_malicious_elements, only_malicious_indicators.

get_list_of_recent_analysesA
List recent analyses submitted by the user.

This tool returns a summary of the most recent sandbox analyses performed in the current account. Each entry includes the submission ID and a minimal set of metadata useful for follow-up actions such as downloading artifacts or examining behavior.

By default, the tool returns the latest 20 analyses. You can override the `limit` parameter to retrieve more or fewer entries.

For each analysis, the following fields are returned:
    - webid: Unique submission identifier.
    - time: Timestamp of when the analysis was submitted.
    - filename: Original submitted filename or URL.
    - sha256: SHA-256 hash of the submitted object.
    - score: Final detection score assigned by the sandbox.
    - detection: Verdict (e.g., clean, suspicious, malicious).
    - classification: Malware family or type (if available).
    - threatname: Named threat label (e.g., campaign or actor), if detected.
    - systems: List of sandbox systems the sample was run on.
    - num_runs: Total number of sandbox executions (runs) for this submission.

Args:
    limit (optional, default = 20): The number of most recent analyses to return.

Returns:
    A list of dictionaries summarizing each recent analysis.

Inputs: limit.

get_memory_dumpsA
Download and extract memory dumps from a Joe Sandbox analysis.

This tool retrieves the 'memdumps' archive from the specified analysis run and extracts
all contents into a local directory for further inspection. These files represent raw 
memory snapshots taken during execution.

Files are extracted as-is without renaming or classification.

Output path logic:
- If `save_path` is valid, dumps go to `{save_path}/memdumps/{webid}`
- If not, fallback is `memdumps/{webid}` under the current directory

Args:
    webid (str): Joe Sandbox analysis ID
    run (int, optional): Run index (default: 0)
    save_path (str, optional): Optional base path to save dumps

Returns:
    dict: {
        "output_directory": absolute path to extraction folder,
        "info": "Info string detailing how many memory dumps were downloaded"
        "note": status message (e.g. fallback notice)
    }

Inputs: webid (required), run, save_path.

get_pcap_fileA
Retrieve the network traffic capture (PCAP) file from a sandbox analysis.

This tool downloads the full packet capture generated during execution of the submitted sample. The PCAP file contains all recorded network traffic for the specified sandbox run, including DNS requests, HTTP traffic, and raw TCP/UDP communications.

The PCAP is saved locally with the name `{webid}-{run}.pcap`. If a custom `save_path` is provided, the file is written to that directory. If the path is invalid or inaccessible, the file is saved to a fallback directory named `pcap/`.

Args:
    webid (required): The submission ID of the analysis.
    run (optional, default = 0): Index of the sandbox run to retrieve.
    save_path (optional): Custom directory to save the PCAP file. If invalid, a fallback location is used.

Returns:
    A dictionary containing:
    - output_file: Absolute path to the downloaded PCAP file.
    - note: Message indicating whether the fallback directory was used.

Inputs: webid (required), run, save_path.

get_process_infoA
Extract and return the full process tree for a specific analysis run from a Joe Sandbox report.

This tool traverses the execution tree recorded during dynamic analysis and returns a structured
process hierarchy, showing which processes spawned others, with their respective attributes.

Each process node includes:
  - name: Process executable name
  - pid: Process ID
  - cmdline: Full command-line invocation
  - path: File path of the executable
  - has_exited: Boolean flag indicating if the process terminated
  - children: List of child processes (if any), recursively structured
  - targetid: purely internal field, ignore this when replying to the user

The result can be large and deeply nested, depending on the behavior of the sample. To improve
readability, consider representing the tree using indentation or a UNIX-style `tree` layout. If the cmd args are not too long, consider displaying them as well, e.g.:

    parent.exe (1000) - "C:\Program Files\Parent\parent.exe"
    ├── child1.exe (1001) - "C:\Program Files\Parent\child1.exe --option"
    │   └── grandchild1.exe (1002) - "grandchild1.exe /silent"
    └── child2.exe (1003) - "child2.exe --config config.yaml --verbose"
        ├── grandchild2.exe (1004) - "grandchild2.exe"
        └── grandchild3.exe (1005) - "grandchild3.exe --debug --log-level=info"

Args:
    webid (required): Submission ID of the analysis.
    run (default: 0): Index of the sandbox run to inspect (from the `runs` array in analysis info).

Returns:
    Dictionary representing the root-level processes and their child process trees.
    If parsing or report retrieval fails, returns an error dictionary with a reason.

Inputs: webid (required), run.

get_signature_infoA
Retrieve high-impact signature detections from a sandbox analysis report.

This tool extracts detection signatures triggered during the specified analysis run. These signatures reflect behavioral or static patterns typically associated with malware, such as code injection, credential theft, or suspicious memory activity as well as general behavioural indicators.
Optional filtering parameters allow control over the inclusion of all signatures or only those with high impact.

Args:
    webid (required): The submission ID of the analysis.
    run (optional, default = 0): Index of the sandbox run to inspect (from the `runs` array in analysis info). Use 0 for the first run.
    only_malicious_indicators (default: True): If True, limits the returned signatures to those considered high impact by the detection logic.

Returns:
    A dictionary containing a list of triggered detection signatures. Each entry includes:
    - desc: Description of the detected malicious behavior or technique.
    - indicators: List of up to three supporting observations. Each indicator includes:
        - desc: Action or operation that triggered the detection (e.g., "Section loaded").
        - context: Process name or source related to the event.
        - evidence: Supporting detail, such as file paths, memory dumps, or rule names.
        - impact: Either "high" or "low", indicating the severity or confidence of the detection.  
            High-impact indicators are strongly associated with malicious behavior or confirmed threats.  
            Low-impact indicators reflect general behavior or environmental traits that may not be malicious on their own.

Inputs: webid (required), run, only_malicious_indicators.

get_unpacked_filesA
Retrieve and classify in-memory unpacked binaries from a sandbox analysis.

This tool extracts executable artifacts that were unpacked in memory during the dynamic execution of the submitted sample. These binaries typically reflect runtime-decrypted payloads or memory-resident code generated by the sample or its child processes.

Each extracted file is associated with:
- The process ID (pid) responsible for its memory region.
- A classification that indicates **when** during execution the memory snapshot was taken.

If a custom `save_path` is provided, the files are saved under `{save_path}/{webid}-{run}`. If the path is invalid or inaccessible, a fallback directory under `unpacked_files/{webid}-{run}` is used instead.

Snapshot types:
    - "Snapshot at beginning of execution": Memory captured at process start.
    - "Snapshot taken on unpacking (modifying executable sections or adding new ones)": Captured at runtime after self-modifying code or section manipulation.
    - "Snapshot at the end of execution": Captured near process termination.
    - "Snapshot taken when memory gets freed": Captured when memory regions were released.

Args:
    webid (required): The submission ID of the analysis.
    run (optional, default = 0): Index of the sandbox run to process (typically 0 for the first run).
    save_path (optional): Optional base directory to store the unpacked files. If not valid, a default directory is used.

Returns:
    A dictionary containing:
    - output_directory: Absolute path where the files were saved.
    - files: A list of unpacked file entries, each with:
        - unpacked_file: Absolute path to the file on disk.
        - pid: ID of the process associated with the memory region.
        - type: A human-readable label describing when the snapshot was taken.
    - note: A message indicating whether the fallback directory was used.

Inputs: webid (required), run, save_path.

get_url_infoA
Retrieve urls in a completed analysis, along with their associated detection indicators.

This tool extracts urls gathered by the sandbox engine and returns relevant context such as ip address, source, and detection metadata.
Optional filtering parameters allow control over the inclusion of urls and indicators based on their assessed severity.

Args:
    webid (required): The submission ID of the analysis.
    run (default: 0): Index of the sandbox run to inspect (from the `runs` array in analysis info).
    only_malicious_elements (default: True): If True, returns only urls explicitly classified as malicious by the sandbox engine.
    only_malicious_indicators (default: True): If True, limits the returned indicators to those considered clearly malicious by the detection logic.
        This excludes low-impact behavioral signals and focuses on indicators with a high likelihood of malicious intent or confirmed threat classification.
        If False, all observed indicators are included regardless of their severity.

Returns:
    A dictionary containing a list of malicious URLs. Each entry includes:
      - url: The observed URL (may be truncated if extremely long).
      - ip: The resolved IP address associated with the URL (if available).
      - fromMemory: Whether the URL was extracted from memory.
      - source: Subsystem or extraction context (e.g., browser, process).
      - malicious: 'true' for urls classified as malicious
      - indicators: List of triggered detection rules, if any. Each entry includes:
          - desc: Description of the matched detection rule.
          - data: Matched content or signature.
          - source: The detection subsystem responsible (e.g. Suricata, Sigma, global traffic etc.).
- impact: Either "high" or "low", indicating the severity or confidence of the detection.  
    High-impact indicators are strongly associated with malicious behavior or confirmed threats.  
    Low-impact indicators reflect general behavior or environmental traits that may not be malicious on their own.

Notes:
    - Very long URLs are truncated for readability but include their original length as a hint.
    - Empty Array returned if no url was gathered during the analysis

Inputs: webid (required), run, only_malicious_elements, only_malicious_indicators.

search_analysisA
Search the JoeSandbox Cloud for malware analyses using structured search parameters.

Args:
    - md5, sha1, sha256: Exact match
    - filename, url, tag, comments, ioc_url, ioc_dropped-file: Substring match
    - detection: One of 'clean', 'suspicious', 'malicious', 'unknown'
    - threatname: Exact match
    - before_date, after-date: ISO 8601 format (YYYY-MM-DD). These are exclusive (the date itself is not included).
    - ioc_domain, ioc_public_ip: Exact match

    Notes:
        - You must provide at least one of the supported parameters.
        - If multiple parameters are provided, all conditions must match (AND logic).
        - Searches are case-insensitive.
        - On the Cloud version, date comparisons use the CET/CEST time zone.
        - The 'q' parameter is not supported and should not be used.

    Examples:
        {"md5": "661f3e4454258ca6ab1a4c31742916c0"}
        {"threatname": "agenttesla", "before_date": "2024-12-01"}
        {"filename": "agent.exe", "detection": "malicious"}

Inputs: md5, sha1, sha256, filename, +11 more.

submit_analysis_jobA
Submit a file, URL, website, or command line for sandbox analysis using Joe Sandbox.

This tool analyzes one of the following:
- A local file (`sample_path`)
- A remote file URL (`sample_url`)
- A website to visit (`website_url`)
- A raw command line to execute (`command_line`)

Only one input type must be provided. The rest of the arguments configure how the analysis is performed.
For URL and website analysis, make sure `internet_access=True` to allow downloads or navigation.

Args:
    wait_for_analysis_end: If True, the tool will block and wait until the sandbox analysis is complete before returning. If False, the tool returns immediately after submission.
    timeout (default: 1200): Max number of seconds to wait for analysis completion, this is only relevant if wait_for_analysis_end is True.
    File to Upload (required — provide exactly one):
        sample_path: Path to a local file to upload and analyze.
        sample_url: Direct download URL for a file to analyze.
        website_url: Website to visit and analyze in a browser.
        command_line: Command line string to execute in the sandbox.

    Sandbox configuration parameters (optional):
        tags (default: null): Optional tags for the submission.
        analysis_time (default: 120): Time in seconds to run the analysis.
        internet_access (default: True): Enable internet during analysis.
        report_cache (default: False): Use cached results if available.
        powershell_logging (default: False): Enable PowerShell script logging.
        ssl_inspection (default: True): Enable HTTPS inspection.
        vba_instrumentation (default: True): Instrument VBA macros.
        hybrid_code_analysis (default: True): Enable Hybrid Code Analysis (HCA).
        js_instrumentation (default: True): Instrument JavaScript.
        java_jar_tracing (default: True): Enable Java tracing.
        start_as_normal_user (default: False): Run the sample without admin privileges.
        email_notification (default: False): Send notification when complete.
        secondary_results (default: False): Generate post-analysis artifacts.
        archive_password (default: None): This password will be used to decrypt submitted archives (zip, 7z, rar etc.).
        command_line_argument (default: null): Startup arguments for the sample.

Returns:
    A dictionary containing:
    - analyses: A list of extracted analysis entries, each with:
        - webid: Unique identifier for the individual analysis which can be used to retrieve results.
        - sha256: SHA-256 hash of the analyzed file or object.
        - filename: Name of the submitted file or artifact.
        - status: status of the analysis, either finished or running/submitted/accepted

Inputs: wait_for_analysis_end (required), timeout, sample_path, sample_url, +17 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.5/5.0

    Scored across 15 tools

    Disambiguation5/5

    Every tool has a distinct purpose with clear boundaries. Tools are organized by resource type (analysis info, domains, IPs, files, processes, signatures, URLs, etc.) and action (get, submit, search, list), making it easy for an agent to select the correct one without confusion.

    Naming Consistency5/5

    All tools follow a consistent verb_noun pattern with snake_case (e.g., get_analysis_info, submit_analysis_job, search_analysis). The naming is predictable and uniform across all 15 tools, enhancing readability and usability.

    Tool Count5/5

    With 15 tools, the server is well-scoped for malware analysis. It covers submission, retrieval of various analysis artifacts (info, domains, IPs, files, memory dumps, PCAPs, processes, signatures, URLs), and search functionality, each earning its place without bloat.

    Completeness5/5

    The toolset provides complete coverage for malware analysis workflows: submit samples, list recent analyses, search analyses, and retrieve detailed results (metadata, AI summaries, domains, IPs, dropped files, memory dumps, PCAPs, processes, signatures, URLs, unpacked files). No obvious gaps exist for the domain.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      B
      quality
      F
      maintenance
      A Model Context Protocol (MCP) server implementation for the Didlogic API. This server allows Large Language Models (LLMs) to interact with Didlogic services through a standardized interface.
      22
      4
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      This is an MCP (Model Context Protocol) compatible tool that allows MobSF (Mobile Security Framework) to scan APK and IPA files directly via Claude, 5ire, or any MCP-capable client.
      24
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      A standalone Python/FastAPI server that implements the Model Context Protocol (MCP) for the OPTIX threat intelligence platform. It exposes 26 analyst-friendly tools that AI assistants and programmatic consumers can use to query threat feeds, search documents and indicators, manage watchlists, triage IOCs, generate detection rules, trigger AI research, and produce intelligence reports.
      MIT