Robin: AI-Powered Dark Web OSINT
Dark web OSINT over Tor: search onion engines, scrape pages, report with your own model.
Security-first MCP server for reverse engineering, malware analysis, forensics, and SAST.
Elige la app de IA que usas y copia la configuración.
Pasó 3/3 revisiones · Funciona en tu computadora · ✓ Comandos revisados el 13 nov 2026
Primero: ¿qué IA usas?
Elige tu app y los pasos aparecen abajo.
Funciona con Claude, pero hay que preparar algo antes
Instala Python (uv) en tu computadora primero (una sola vez) · Solo en la app de Claude para computadora (Windows o Mac), no en la web ni en el móvil
Una sola vez; sirve para todos los servidores que necesitan Python (uv)
SettingsDeveloperEdit Config
{
"mcpServers": {
"reversecore": {
"command": "uvx",
"args": [
"reversecore-mcp"
]
}
}
}Usa Reversecore MCP y dime qué puedes hacer por mí; luego muéstrame una cosa✓ Si Claude dice que está usando Reversecore MCP o muestra una herramienta de Reversecore MCP en la respuesta, ya está conectado
Nombres de menú comprobados con la ayuda de Anthropic el 11 nov 2026 · tu pantalla puede variar un poco según la versión
ChatGPT todavía no puede conectar Reversecore MCP
Reversecore MCP se instala en tu computadora, pero ChatGPT solo conecta servidores que funcionan en la web
A · Usa una app que pueda conectar Reversecore MCP
B · Otros en Ciberseguridad que funcionan con ChatGPT
Elegidos entre los más usados de la misma categoría, solo los que se conectan con una dirección y sin clave
Funciona con Claude Code, pero hay que preparar algo antes
Instala Python (uv) en tu computadora primero (una sola vez)
Una sola vez; sirve para todos los servidores que necesitan Python (uv)
Mac: pulsa Command+Espacio y escribe Terminal · Windows: abre PowerShell
claude mcp add --scope user reversecore -- uvx reversecore-mcpDeberías ver Reversecore MCP en la lista como conectado
Usa Reversecore MCP y dime qué puedes hacer por mí; luego muéstrame una cosa✓ Si Claude Code dice que está usando Reversecore MCP o muestra una herramienta de Reversecore MCP en la respuesta, ya está conectado
Nombres de menú comprobados con la ayuda de Anthropic el 11 nov 2026 · tu pantalla puede variar un poco según la versión
Funciona con Cursor, pero hay que preparar algo antes
Instala Python (uv) en tu computadora primero (una sola vez)
Una sola vez; sirve para todos los servidores que necesitan Python (uv)
Usa Reversecore MCP y dime qué puedes hacer por mí; luego muéstrame una cosa✓ Si Cursor dice que está usando Reversecore MCP o muestra una herramienta de Reversecore MCP en la respuesta, ya está conectado
Nombres de menú comprobados con la ayuda de Cursor el 11 nov 2026 · tu pantalla puede variar un poco según la versión
Funciona con VS Code, pero hay que preparar algo antes
Instala Python (uv) en tu computadora primero (una sola vez)
Una sola vez; sirve para todos los servidores que necesitan Python (uv)
Usa Reversecore MCP y dime qué puedes hacer por mí; luego muéstrame una cosa✓ Si VS Code dice que está usando Reversecore MCP o muestra una herramienta de Reversecore MCP en la respuesta, ya está conectado
Nombres de menú comprobados con la ayuda de VS Code el 11 nov 2026 · tu pantalla puede variar un poco según la versión
Otras apps que usan MCP, como Windsurf, Zed o Gemini CLI, añaden servidores de forma distinta. Míralo en la lista de apps
Ver todas las apps que usan MCP →
La configuración JSON está en “Para desarrolladores”, abajo
Claude Code
claude mcp add --scope user reversecore -- uvx reversecore-mcpClaude Desktop (claude_desktop_config.json)
{
"mcpServers": {
"reversecore": {
"command": "uvx",
"args": [
"reversecore-mcp"
]
}
}
}Cursor (~/.cursor/mcp.json)
{
"mcpServers": {
"reversecore": {
"command": "uvx",
"args": [
"reversecore-mcp"
]
}
}
}VS Code (mcp.json)
{
"servers": {
"reversecore": {
"type": "stdio",
"command": "uvx",
"args": [
"reversecore-mcp"
]
}
}
}Esta configuración se genera a partir de la ficha del creador en el registro. Si el README dice otra cosa, sigue el README.
pypi: reversecore-mcpoci: ghcr.io/sjkim1127/reversecore_mcp:3.1.0Según cómo se conecta este servidor y la documentación de cada app, comprobado el 10 nov 2026.
Se ejecutan en tu computadora en
ClaudeGooseLM StudioMsty StudioCherry StudioCursorVS Code + GitHub CopilotVisual StudioWindsurf (Devin Desktop)ZedKiroClineContinueJetBrains AI AssistantClaude CodeCodex CLIGemini CLIOpenCodenodecodeWarpLibreChatRaycast
Se ejecuta en tu computadora; la lista de herramientas aparece en tu app de IA después de instalarlo.
Revisamos información que cualquiera puede ver; no hemos leído el código. Las revisiones que no aplican no se cuentan. · Revisado el 13 nov 2026
El nombre en el registro se verificó con la cuenta de GitHub sjkim1127, dueña del repo
Último cambio de código: ayer
Usa MIT
Este se ejecuta en tu computadora; no hay endpoint en internet
Se ejecuta en tu computadora y usa ajustes locales en su lugar
Se ejecuta en tu computadora; solo podemos leer listas de herramientas de endpoints en internet
Pregunta, comparte un consejo o avisa de que no funciona. Ordenado por lo que la gente marcó como útil.
Aún no hay publicaciones. Sé la primera persona en preguntar o compartir.
Lo publicado aquí lo escriben usuarios, no el equipo de PopNx.
Aún no hay reseñas
Comparado con todos los servidores activos de esta categoría en el registro. Las estrellas solo cuentan cuando quien lo publica es dueño del repo.
Superó 3 de 3 revisiones básicas aplicables. No hemos leído el código. Antes de agregar una clave o un token, revisa qué acceso pide el servidor y usa una clave que tenga solo los permisos que necesitas.
El registro no indica ninguna clave obligatoria, aunque algunos servidores te piden iniciar sesión la primera vez que los usas.
Se ejecuta en tu computadora. Tu app de IA lo inicia cuando hace falta, y los datos no pasan por los servidores del creador (a menos que el propio servidor llame a un servicio en línea).
El repo de GitHub cambió por última vez ayer, y la última versión (3.1.0) llegó al registro hace 3 días.
Las apps compatibles con MCP, como Claude Desktop, Claude Code, Cursor y VS Code. También necesitas Python (uv), Docker en tu computadora.
En la misma categoría: Robin: AI-Powered Dark Web OSINT, HOL Guard, SonarQube MCP Server
Servidores de la misma categoría hechos por otros creadores, ordenados por estrellas.
Cómo leer una tarjeta:↓ Descargas por semanai★ Estrellas de GitHubiTres pilares: reseñas · revisiones · usoiActualizado = fecha en que se publicó la última versión en el registroi
Dark web OSINT over Tor: search onion engines, scrape pages, report with your own model.
Local-first AI agent security evidence and approval workflows through HOL Guard's stdio MCP server.
Analyze code quality and security with SonarQube Server or Cloud directly in AI assistants.
Copiado tal cual del repo del creador. PopNx MCP no lo ha revisado ni lo respalda. Se quitaron HTML, imágenes y scripts. Los enlaces llevan fuera de este sitio.
AI-Powered Reverse Engineering & Security Analysis via Model Context Protocol
*An MCP server that gives AI assistants like Claude and Cursor the ability to perform reverse engineering, malware analysis, vulnerability research, digital forensics, and source code auditing through natural language.*
Reversecore MCP is a Model Context Protocol server that wraps 179 analysis tools into a single interface that AI assistants can call through natural language.
Instead of learning the command-line syntax for a dozen different tools, you describe what you want:
"Decompile the main function of this malware sample, extract all network IOCs,
map the behavior to MITRE ATT&CK, and generate a triage report."
The AI assistant breaks this into tool calls:
r2_decompile("sample.exe", "main")
→ extract_iocs("sample.exe") → add_mitre_technique(technique_id="T1071.001", ...) → create_analysis_report(template_type="quick_triage")
Each tool returns a structured ToolResult (either ToolSuccess or ToolError) with typed data that the AI can reason about, chain into follow-up queries, or render for the user.
| Domain | What you can do |
|---|---|
| Static analysis | Disassembly, decompilation (r2ghidra), binary parsing (LIEF), packer detection (DIE), capability detection (CAPA), string extraction, firmware scanning (binwalk) |
| Dynamic & symbolic | ESIL emulation, angr symbolic execution, taint analysis, fuzzing harness generation |
| Malware analysis | IOC extraction, YARA scanning, dormant backdoor detection, adaptive vaccine generation, autonomous vulnerability hunting |
| Vulnerability research | Dangerous API detection, ROP gadget discovery, heap exploit analysis, crash triage, PoC generation |
| Digital forensics | Memory forensics (Volatility3), PCAP analysis (Scapy), disk forensics (Sleuth Kit), artifact correlation |
| Source code audit | Python AST scanning, C/C++ regex pattern scanning |
| Reporting | Session-based reports with MITRE ATT&CK mapping, SIGMA rule generation, VEX reports, email delivery |
AI Client (Claude / Cursor / any MCP-compatible client)
│ MCP Protocol (stdio or HTTP/SSE) ▼ ┌──────────────────────────────────────────────────────┐ │ FastMCP 3.4.11 Server │ │ 179 registered tools · Fully async │ │ Python 3.10–3.12 │ ├────────────────────┬─────────────────────────────────┤ │ Guided Prompts │ Dynamic Resources │ │ (22 analysis │ (11 URI-based: per-binary │ │ modes) │ strings, IOCs, ASM, CFG, …) │ ├────────────────────┴─────────────────────────────────┤ │ Core Infrastructure │ │ Config · Security · Validators · Exceptions (17) │ │ R2 Pool · Metrics · Memory (SQLite) · Task Queue │ │ MITRE Mapper · Evidence Engine · Resilience Layer │ │ Arch Registry (x86/ARM/MIPS/RISC-V/PPC) │ │ Result Cache (SHA256) · Analysis Cache (Redis+SQL) │ │ SAST (Python AST + C/C++ Regex) · Plugin System │ ├──────────────────────────────────────────────────────┤ │ Analysis Engines │ │ Radare2 6.0.4 │ YARA 4.3.1 · LIEF · Capstone │ │ r2ghidra │ CAPA · angr · Qiling │ │ Volatility3 · Scapy│ DIE · Binwalk · Sleuth Kit │ │ pwntools · ROPgadget│ Keystone (assembler) │ └──────────────────────────────────────────────────────┘
The server supports Python 3.10–3.12. The optional angr symbolic execution engine is installed on Python 3.12 and newer, where a secure compatible release is available; Python 3.10 and 3.11 installs omit angr.
The reversecore_mcp/core/ directory contains the shared infrastructure that all tools build on:
| Module | Purpose |
|---|---|
config.py | Pydantic BaseSettings with 34+ environment variables |
security.py | Input sanitization, command argument validation |
validators.py | File and binary path validation with TOCTOU mitigation, symlink resolution |
r2_pool.py | Thread-safe Radare2 connection pool with configurable size |
r2_helpers.py | Structured Radare2 output parsing |
metrics.py | Per-tool execution times, call counts, error rates, cache statistics |
memory.py | Async SQLite-backed AI memory store for persisting analysis findings across sessions |
mitre_mapper.py | MITRE ATT&CK technique ID mapping engine |
evidence.py | Evidence classification system: OBSERVED, INFERRED, POSSIBLE |
resilience.py | Retry, circuit-breaker, and timeout decorator patterns |
task_queue.py | Background task queue via Redis + arq |
extension_registry.py | Plugin registration and lifecycle management |
arch_registry.py | Multi-architecture mapping (x86, x86_64, ARM32, ARM64, MIPS, RISC-V, PPC → r2 arch/bits/registers) |
result_cache.py | SHA256-based tool result caching decorator (@cache_tool_result) |
analysis_cache.py | Multi-level decompilation cache (L1: Redis, L2: SQLite) |
result.py | ToolSuccess / ToolError Pydantic models |
exceptions.py | 17 exception classes with RCMCP-E* error codes |
decorators.py | @log_execution, @track_metrics |
error_handling.py | @handle_tool_errors decorator |
error_formatting.py | Structured error response formatting |
execution.py | Safe subprocess execution with timeout and output limits |
command_spec.py | Command specification for subprocess calls |
loader.py | Dynamic tool module loader |
plugin.py | Plugin base class |
extension.py | Extension base class |
container.py | Container/sandbox execution support |
audit.py | Audit logging |
binary_cache.py | Binary file caching |
json_utils.py | JSON serialization via orjson (3-5x faster than stdlib json) |
logging_config.py | Loguru-based structured logging |
report_generator.py | Report rendering engine (Markdown, PDF via xhtml2pdf) |
resource_manager.py | MCP resource lifecycle management |
sast/python_ast_scanner.py | Python AST-based vulnerability scanner |
sast/regex_scanner.py | C/C++ regex-based vulnerability scanner |
sast/rule_manager.py | SAST rule loading and management |
📖 [Authoritative Tool Catalog & Parameter Reference (151 Tools)](docs/TOOLS.md)
📊 [Tool Profile Footprint & Context Benchmark Matrix](docs/benchmarks/profile_footprint.md)
Every tool returns a structured ToolResult — either a ToolSuccess with typed data or a ToolError with an RCMCP-E* error code. Tools are organized into 11 domain plugins across 5 modular execution profiles (full, static, malware, forensics, vuln-research):
| Profile | Registered Tools | Schema Size | LLM Context Saving vs Full | Recommended Domain |
|---|---|---|---|---|
full | 153 | 116.8 KB | Baseline (0%) | Complete enterprise reverse engineering suite |
vuln-research | 105 | 73.3 KB | -37.2% (~10,800 tokens) | Fuzzing, ASan crash triage, CVE hunting, exploit research |
static | 99 | 67.7 KB | -42.0% (~12,200 tokens) | Disassembly, decompilation (r2ghidra), LIEF, static triage |
malware | 67 | 62.8 KB | -46.2% (~13,500 tokens) | Threat triage, YARA scanning, deobfuscation, anti-analysis |
forensics | 57 | 37.0 KB | -68.4% (~19,500 tokens) | Memory forensics (Volatility3), network PCAP (Scapy), disk |
| # | Tool | Backend | Description |
|---|---|---|---|
| 1 | run_strings | strings CLI | ASCII/Unicode string extraction with configurable min-length |
| 2 | run_binwalk | Binwalk | Firmware deep-scan for embedded signatures and filesystems |
| 3 | run_binwalk_extract | Binwalk | Extract embedded files discovered by binwalk |
| 4 | parse_binary_with_lief | LIEF | Full PE/ELF/Mach-O header, section, import/export, TLS parsing |
| 5 | detect_packer | DIE | Quick packer/compiler detection |
| 6 | detect_packer_deep | DIE (diec) | Deep packer/protector analysis via Detect It Easy |
| 7 | run_capa | CAPA (Mandiant FLARE) | Capability detection — "encrypts data", "creates persistence", etc. |
| 8 | run_capa_quick | CAPA | Quick capability scan with a rule subset |
| 9 | generate_signature | Radare2 | Generate binary signatures for identification |
| 10 | generate_yara_rule | Radare2 + YARA | Generate YARA detection rules from binary patterns |
| 11 | generate_advanced_yara_rule | Radare2 + YARA | Advanced YARA rules with behavioral indicators |
| 12 | scan_for_versions | LIEF + strings | Scan binary for embedded version strings |
| 13 | extract_rtti_info | Radare2 | Extract C++ RTTI (Run-Time Type Information) |
| 14 | diff_binaries | Radare2 | Semantic binary diff between two file versions |
| 15 | analyze_variant_changes | Radare2 | Analyze changes between binary variants |
| 16 | match_libraries | Radare2 | Identify statically linked libraries by function fingerprint |
| 17 | patch_diff_1day | Radare2 + heuristics | Automated patch diff analysis for 1-day vulnerability research |
| 18 | analyze_patch_diff_auto | Radare2 + inference | Automated patch vulnerability inference |
| 19 | emulate_binary | Radare2 ESIL | Register/memory-traced code emulation |
| 20 | generate_fuzzing_harness | Qiling + AFL++ | G