← Back to directory
R

Reversecore MCP

Community
AI-powered reverse engineering and security analysis
Category
Dev Tools #199 of 438
Stars
★ 211 Very popular
Transport
stdio (local process) · SSE
Runtime
Docker 20.10+ · Python 3.10+ · Prebuilt binary
Credentials
Optional API key
License
MIT
Last commit
Tools
12
54FMRS · D

The supplied sources describe Reversecore MCP as an MIT-licensed open-source security-analysis server, version 3.0.3, distributed through PyPI and OCI packages. It offers broad coverage and a substantial toolchain, with path validation, input sanitization, structured errors, rate limiting, and optional sandboxing. It is intended for professional security workflows, so users should still configure isolation and access controls independently when handling untrusted samples.

Strongest · Documentation 13/20 Weakest · Security and permissions 8/20

Reliability
10/20
Security and permissions
8/20
Maintenance
11/20
Documentation
13/20
Setup experience
12/20
Why each score
Reliability 10/20
The static material describes stdio transport, structured results, timeouts, output limits, and coded errors, and claims extensive tests and CI coverage. However, no actual source code, CI workflows, or test files are provided, so MCP initialization, tool-list handshake, registration count, and implementation behavior cannot be verified. The dependency surface is broad—Radare2, r2ghidra, YARA, angr, Volatility, Sleuth Kit, Redis, and others—and the README uses tool names that do not always match the catalog. Under the static calibration, reliability cannot exceed 12 and is reduced for the lack of verifiable execution evidence.
Security and permissions 8/20
The material describes path confinement, symlink resolution, list-based subprocess execution, API-key authentication, timing-safe comparison, rate limiting, loopback restriction, non-root containers, and resource limits. However, sandboxing is disabled by default, while the server exposes raw Radare2 commands, file creation and copying, import/export, patch generation, PoC generation, ROP construction, email delivery, and dynamic analysis. There is no clear evidence of per-operation confirmation, least-privilege defaults, complete audit coverage, or disclosed data flows. This is not a stated red-line violation, but dangerous capabilities and confirmation boundaries are incomplete, warranting a substantial deduction.
Maintenance 11/20
The project is marked unarchived, uses the MIT license, and identifies version 3.0.3 with PyPI and GHCR release paths. The README also describes security scanning, dependency auditing, and multi-architecture publishing. However, there is no evidence of commit history, release dates, maintainer responsiveness, update cadence, dependency-update practice, or a security-response channel. Stars and open issues are discovery signals only and add no points. The license and release path are clear, but governance evidence is incomplete.
Documentation 13/20
The README covers architecture, the tool catalog, prompts, resources, installation routes, client configuration, environment variables, security controls, test commands, Docker design, and usage examples. It loses points because most tools lack individually reviewable parameters, permission effects, failure conditions, and demonstrated outputs; the supplied README is truncated, and there are inconsistencies such as a stdio-only manifest alongside HTTP/SSE documentation, mismatched tool names in examples, and use of the mutable Docker latest tag while the manifest uses a pinned version.
Setup experience 12/20
PyPI, local-source, Docker, and Docker Compose installation paths are provided, along with Cursor/Claude configuration examples and macOS, Linux, and Windows mount examples. The deduction reflects the complex external toolchain and substantial resource requirements, possible Redis and forensic-component setup, and the fact that local installation still requires manual Radare2 installation. Platform profiles, image versioning, and HTTP deployment details may also be fragile. The process is actionable but not close to few-step turnkey setup.

Static review · not runListed 2026-08-14

Read the FMRS scoring method →

Fit and risk

What it can accessReads local filesWrites / deletes local filesRuns commands or codeUses the network

Best for

  • Security researchers and malware analysts
  • Teams that need natural-language orchestration across analysis engines
  • Developers performing binary, firmware, vulnerability, or forensic analysis

Not for

  • General development tasks without security-analysis requirements
  • Users who want to handle untrusted samples without an isolated environment
  • Users seeking only basic file operations or general database capabilities

Required permissions

  • Access to the configured analysis workspace and sample files
  • A mounted local sample directory for Docker deployments
  • Optional API-key, upload-size, and rate-limit configuration in HTTP mode
  • Optional Redis, SQLite memory storage, and container sandbox access

Risks and side effects

  • Samples may be malicious or exploitative and should be analyzed in an isolated environment.
  • PoC generation, ROP construction, and vulnerability-research tools can create misuse risks.
  • Sandbox execution is disabled by default; dynamic analysis may run on the host unless enabled.
  • Misconfigured HTTP, uploads, or workspace mounts can increase file or network exposure.
  • Results can include inference; the project distinguishes OBSERVED, INFERRED, and POSSIBLE evidence.

Setup

Before you start

Runtime:Docker 20.10+ · Python 3.10+ · Prebuilt binary

MCP_API_KEY optionalsecret API key for HTTP auth via X-API-Key or Bearer header; generate it yourself
Other optional settings (33)
REVERSECORE_WORKSPACE optional Analysis workspace directory, mounted as /app/workspace in Docker
MCP_TRANSPORT optional Transport mode: stdio or http
MCP_HOST optional Host interface for HTTP mode; falls back to 127.0.0.1 when no API key is set
MCP_PORT optional HTTP server port, default 8000
REVERSECORE_READ_DIRS optional Comma-separated additional read-only directories
REVERSECORE_STRICT_PATHS optional Raise errors for missing paths instead of warnings
REVERSECORE_STRUCTURED_ERRORS optional Enable structured error responses with error codes
REVERSECORE_DEFAULT_TOOL_TIMEOUT optional Default tool execution timeout in seconds, default 120
REVERSECORE_MAX_OUTPUT_SIZE optional Maximum tool output size in bytes
REVERSECORE_RATE_LIMIT optional Max requests per minute in HTTP mode
MAX_UPLOAD_SIZE optional Maximum upload size, default 100 MB
FILE_RETENTION_MINUTES optional Retention period for uploaded files, default 24h
REVERSECORE_R2_POOL_SIZE optional Radare2 connection pool size, default 3
REVERSECORE_R2_POOL_TIMEOUT optional Timeout for acquiring a pool connection in seconds
REVERSECORE_R2_EXTENSIONS optional Comma-separated r2 extension classes (module:ClassName)
REVERSECORE_GHIDRA_MAX_PROJECTS optional Max cached r2ghidra decompiler projects
REVERSECORE_GHIDRA_EXTENSIONS optional Comma-separated Ghidra extension classes
MAX_EMULATION_INSTRUCTIONS optional Maximum ESIL emulation instructions, default 1000
REVERSECORE_SANDBOX_ENABLED optional Enable sandbox execution for dynamic analysis tools
REVERSECORE_SANDBOX_MODE optional Sandbox mode: auto/host/container/disabled
REVERSECORE_SANDBOX_DOCKER_IMAGE optional Docker image used for sandbox execution
REVERSECORE_SANDBOX_CPU_LIMIT optional CPU core limit for sandbox containers
REVERSECORE_SANDBOX_MEMORY_LIMIT optional Memory limit for sandbox containers
REVERSECORE_SANDBOX_PIDS_LIMIT optional PID limit for sandbox containers
REVERSECORE_SANDBOX_USER optional Non-root user for sandbox execution
REDIS_URL optional Redis URL for task queue and result caching
MEMORY_DB_PATH optional Path to the AI memory SQLite database
REVERSECORE_LIEF_MAX_FILE_SIZE optional Maximum file size for LIEF parsing, default 1 GB
LOG_LEVEL optional Logging verbosity: DEBUG/INFO/WARNING/ERROR
LOG_FILE optional Path to the log file
LOG_FORMAT optional Log format: human or
REVERSECORE_PLUGIN_DIRS optional Comma-separated directories to scan for extension plugins
REVERSECORE_SAST_RULES_PATH optional Path to a custom YAML SAST rules file

Docker is recommended for the complete toolchain: mount a local sample directory at /app/workspace and reference samples by filename inside the container. You can also install reversecore-mcp from PyPI or run it from source; local mode requires Radare2, while full forensics support requires additional external tools. The server supports stdio and can also be configured for HTTP/SSE mode.

claude_desktop_config.json
{"mcpServers":{"reversecore":{"command":"docker","args":["run","-i","--rm","-v","/path/to/your/samples:/app/workspace","-e","REVERSECORE_WORKSPACE=/app/workspace","-e","MCP_TRANSPORT=stdio","ghcr.io/sjkim1127/reversecore_mcp:latest"]}}}

Shown for Claude Desktop. Other clients may use a different file or key (VS Code uses "servers") — the configurator below converts it.

.vscode/mcp.json
{
  "servers": {
    "reversecore": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-v",
        "/path/to/your/samples:/app/workspace",
        "-e",
        "REVERSECORE_WORKSPACE=/app/workspace",
        "-e",
        "MCP_TRANSPORT=stdio",
        "ghcr.io/sjkim1127/reversecore_mcp:latest"
      ]
    }
  }
}

Goes in your project's .vscode/mcp.json (VS Code uses a "servers" key).

Terminal
claude mcp add reversecore -- docker run -i --rm -v /path/to/your/samples:/app/workspace -e REVERSECORE_WORKSPACE=/app/workspace -e MCP_TRANSPORT=stdio ghcr.io/sjkim1127/reversecore_mcp:latest

Run it in a terminal; replace any <…> placeholders with your own values first.

Check that it works

After starting the server, tools such as run_file, Radare2_decompile_function and extract_iocs should appear in your client's tool list; calling run_file on a sample in the workspace and getting back file type and architecture info confirms the install works.

Troubleshooting

  1. In Docker mode, verify that the sample directory is mounted and use container filenames or paths.
  2. For local installation, verify Radare2 with r2 --version.
  3. If capabilities are missing, check YARA, Volatility3, Scapy, Sleuth Kit, GDB, and other backend dependencies.
  4. For HTTP mode, check MCP_TRANSPORT, MCP_HOST, MCP_PORT, and API-key settings.
  5. For long-running jobs, check the default timeout, Redis task queue, and container CPU and memory limits.

Things to try

Once connected, you can ask your AI assistant things like:

  • Analyze the sample sample.exe and extract all IPs, URLs and other IOCs
  • Use run_capa to detect what capabilities this binary has, like persistence or encryption
  • Scan my memory dump memdump.raw, list all processes and detect code injection
  • Run audit_source_code on this Python project to find dangerous code patterns

Tools 12

run_file read-only
Identifies file type, architecture, and compiler fingerprints.
run_strings read-only
Extracts ASCII and Unicode strings.
parse_binary_with_lief read-only
Parses PE, ELF, and Mach-O headers, sections, imports, exports, and TLS data.
run_capa read-only
Detects binary capabilities such as encryption or persistence.
Radare2_analyze_binary read-only
Runs full Radare2 automatic analysis on a binary.
Radare2_decompile_function read-only
Decompiles a selected function into pseudo-C using r2ghidra.
extract_iocs read-only
Extracts IOCs including IPs, URLs, domains, hashes, registry keys, and cryptocurrency addresses.
run_yara read-only
Scans files with custom rule files and built-in rulesets.
Show 4 more tools
memory_analyze read-only
Analyzes memory dumps with Volatility3.
pcap_analyze read-only
Analyzes PCAP protocol breakdowns and anomalies with Scapy.
audit_source_code read-only
Scans Python, C, and C++ source code for dangerous patterns using AST and regex analysis.
create_analysis_report writes
Creates full-analysis, quick-triage, IOC-summary, or executive-brief reports.

Use cases

Static malware analysis and IOC extraction
Binary disassembly, decompilation, and control-flow analysis
Vulnerability research, patch diffing, and fuzzing
Memory, disk, network, and artifact forensics
Python, C, and C++ source-code security auditing
Generating YARA, SIGMA, VEX, and analysis reports

Supported clients

Claude Desktop
Cursor

Listed from the project's documentation, not tested by this site.

Overview

Reversecore MCP gives AI assistants Model Context Protocol access to reverse engineering, malware analysis, vulnerability research, digital forensics, and source-code security auditing. It integrates Radare2, r2ghidra, YARA, LIEF, Capstone, angr, Volatility3, Scapy, Sleuth Kit, and other engines through 120 tools, 22 guided analysis modes, and 11 MCP resources.

Similar servers

Context7 80 · B

Upstash's official server providing up-to-date third-party library docs for AI coding assistants

★ 63.3k · Tools 2 Compare with this →

Source revision c1c576709e47 Data synced 2026-10-19 Read the FMRS scoring method