MIRAI Intelligence & Research MCP
This server does not currently have a deployable release on Glama. Follow the repository's setup instructions to install and configure it for your MCP client, including any required credentials and local dependencies.
❤️ Support My Work
If you find my projects useful, please consider supporting me with a donation.
Your support helps me maintain my projects, improve existing features, and develop more useful open-source tools.
Every donation, no matter how small, is greatly appreciated. Thank you for your kindness and support!
💰 Donate via USDT (TRC20) Network: TRON (TRC20) Currency: USDT Wallet Address: TENRVUreWCFdGzceVsG6Lwr2EQtKytQQ2b
Thank you for supporting open-source development! ❤️
MIRAI Intelligence & Research MCP
An autonomous, evidence-driven research and software-engineering platform implemented as a Model Context Protocol (MCP) server in TypeScript.
The platform unifies three core intelligence engines on top of one shared evidence layer:
Engine A — Technical Software Engineering Intelligence (
software-engineering)Engine B — Botnet, Mirai & Malware Intelligence (
malware-intelligence)Engine C — Exploit & Vulnerability Intelligence (
exploit-intelligence)Engine D — Zero-Day Research (
zero-day-research)
plus supporting engines: attack-methods, anti-ddos, firmware-intelligence,
network-forensics, knowledge-and-evidence, datasets, multi-agent, platform,
and skills — a versioned library of reusable techniques.
1. Status
Item | Result |
Registered engines | 13 |
Registered MCP tools | 113 |
MCP prompts | 6 |
MCP resources | 2 |
Multi-agent roles / workstreams | 23 / 23 |
Skills in library | 36 |
Typecheck ( | 0 errors |
Build ( | success |
Test suite (vitest) | 178/178 pass (12 files) |
End-to-end stdio check | success (113 tools, 6 prompts) |
Related MCP server: pentestlab
2. Install and run
npm install
npm run build # compile to dist/
npm start # run the MCP server over stdio
npm run dev # development mode (tsx watch)
npm run verify # typecheck + full test suite
npm run stdio-check # real JSON-RPC handshake over stdin/stdout
npm run inspector # open MCP InspectorRegister with an MCP client (example JSON config)
{
"mcpServers": {
"mirai-intelligence": {
"command": "node",
"args": ["/absolute/path/to/mirai-mcp/dist/index.js"],
"env": {
"MIRAI_WORKSPACE": "/absolute/path/to/your/workspace",
"MIRAI_LOG_LEVEL": "info"
}
}
}
}3. Configuration
Configuration is merged in this order: MIRAI_* environment variables → mirai.config.json
(or MIRAI_CONFIG) → defaults.
Variable | Default | Meaning |
|
| Directory boundary for reads/writes |
|
| Knowledge base storage location |
|
|
|
|
| Allow public network access (read-only) |
|
| Allow command execution inside the isolated sandbox |
|
| Hard timeout per sandboxed command |
|
| Output size cap |
|
| Cap for artifacts read into memory |
| (unset) | Required token for active lab testing |
|
|
|
allowOffensiveOpsis alwaysfalseand cannot be enabled through configuration (hard-coded in config/index.ts).
Dependency diagnostics
The platform never assumes external tools are installed. Every dependency is probed (read-only — it never downloads or installs anything) and reported as one of:
AVAILABLE · MISSING · VERSION_UNSUPPORTED · CONFIGURATION_ERROR · NOT_REQUIRED
Probed dependencies: GCC, Clang, AFL++, Honggfuzz, QEMU ARM/MIPS, Binwalk, 7-Zip, objdump, readelf, strings, nm, Radare2, Ghidra, Git. (See dependencies.ts.)
The
dependency_diagnosticstool (engineplatform) lists each dependency's status; passrequired: ["aflplusplus", ...]to mark dependencies your workflow needs.environment_reportembeds the same probe results.A tool that depends on an unavailable dependency throws
TOOL_MISSINGwith per-dependency install hints — it never returns a fake success.node scripts/dependency-report.mjswrites host status toscripts/_dependency-report.json(does not fail the build; missing dependencies are recorded as BLOCKED, never PASS).
4. Architecture
src/
├── index.ts # entry point: registers all engines + starts the server
├── config/index.ts # merged configuration, safe defaults
├── core/
│ ├── server.ts # MCP SDK adapter: policy gate → handler → evidence
│ ├── registry.ts # ToolRegistry: unique names, policy pre-screening
│ ├── tool.ts # EngineModule / ToolDefinition / ToolContext
│ ├── errors.ts # MiraiError with actionable `code` + `hint`
│ ├── logger.ts # structured logging over stderr (keeps stdio clean)
│ └── environment.ts # Phase 1 — environment discovery
├── shared/
│ ├── security.ts # security boundary: path containment, capability gating
│ ├── exec.ts # execution sandbox: argv-only, timeout, output cap
│ ├── evidence.ts # EvidenceCollector, provenance, aggregateConfidence
│ ├── knowledge-base.ts # knowledge store + evidence graph (atomic JSON)
│ ├── curated-datasets.ts # curated reference data (real sources only)
│ └── types.ts # shared type contracts
├── skills/ # Skills Library system (independent of engines)
│ ├── types.ts # SkillManifest, SkillSelection, type contracts
│ ├── frontmatter.ts # YAML front-matter parser (no external dependency)
│ ├── loader.ts # auto-discovery of skills/<name>/SKILL.md, validate + parse
│ └── registry.ts # SkillRegistry: unique names, search, multi-select
├── prompts/index.ts # 6 MCP prompt workflows
├── tools/
│ ├── helpers.ts # defineTool / finish / addEvidence / artifact readers
│ └── platform.ts # engine `platform`
└── engines/ # 13 independent enginesTool execution flow
ToolRegistrypre-screens the tool descriptor throughevaluateIntent(blocks forbidden capabilities).server.tschecksregistry.screen(name); if blocked it returnsblocked: truetogether with a defensive alternative instead of a generic refusal.The handler runs with a
ToolContext(logger, knowledge base,EvidenceCollector).Results are wrapped in a uniform
ToolResult:ok,data,summary,evidence,assertions,warnings,blocked,durationMs,timestamp.After every call the knowledge base is
flush()ed (atomic write).
5. Catalogue of 113 MCP tools
platform (3)
environment_report · health_check · dependency_diagnostics
knowledge-and-evidence (7)
knowledge_search · knowledge_ingest · evidence_graph_query · source_provenance_check ·
research_report_generate · knowledge_update · research_checkpoint
datasets (3)
curated_dataset_search · curated_dataset_ingest · curated_dataset_stats
software-engineering (17)
engineering_toolchain_probe · repository_analyze · repository_search · symbol_search ·
dependency_analyze · documentation_search · architecture_analyze · source_generate ·
source_modify · source_review · source_refactor · build_project · run_tests ·
debug_project · regression_test · code_quality_report · project_memory
malware-intelligence (10)
malware_sample_analyze · malware_family_compare · mirai_variant_analyze ·
malware_source_analyze · binary_similarity · malware_behavior_report ·
c2_protocol_analyze · ai_malware_indicator_analyze · honeypot_telemetry_analyze ·
botnet_lifecycle_stage_search
zero-day-research (16)
zero_day_discovery_analyze · vulnerability_hypothesis_generate · vulnerability_hypothesis_rank ·
source_vulnerability_analyze · binary_vulnerability_analyze · firmware_vulnerability_analyze ·
static_analysis_run · fuzz_target_identify · fuzz_harness_generate · fuzzing_crash_analyze ·
crash_root_cause_analyze · vulnerability_verify · patch_root_cause_analyze ·
vulnerability_variant_hunt · zero_day_lifecycle_update · zero_day_research_report
exploit-intelligence (14)
knowledge_source_registry · cve_search · cwe_search · advisory_search ·
exploit_reference_search · nuclei_template_search · yara_rule_search · sigma_rule_search ·
knowledge_source_sync · exploit_metadata_analyze · vulnerability_root_cause ·
patch_diff_analyze · safe_validation_generate · vulnerability_pipeline_report
attack-methods (6)
attack_method_search · attack_method_classify · malware_attack_module_analyze ·
attack_behavior_analyze · attack_method_compare · attack_detection_recommend
anti-ddos (10)
anti_ddos_research · defense_architecture_analyze · network_traffic_analyze · pcap_analyze ·
ddos_detection_design · detection_rule_generate · rate_limit_design ·
mitigation_strategy_compare · defense_test_plan · defense_performance_analyze
firmware-intelligence (8)
firmware_analyze · firmware_extract · firmware_filesystem_analyze · elf_analyze ·
firmware_component_scan · emulation_plan · firmware_patch_diff · firmware_integrity_check
network-forensics (9)
pcap_flow_analyze · pcap_dns_analyze · pcap_http_analyze · pcap_tls_metadata_analyze ·
c2_beacon_detect · ioc_extract · network_timeline_reconstruct · protocol_fingerprint ·
flow_summarize
multi-agent (7)
agent_roles_list · orchestrator_plan · agent_brief_generate · agent_findings_merge ·
evidence_reconciliation · missing_evidence_identify · research_audit
Architecture §8/§11: 23 specialist roles and 23 workstreams are validated against dependencies;
agent_roles_listlists roles,orchestrator_plandecomposes a task into parallelisable phases, andagent_findings_merge+evidence_reconciliationmerge findings and reconcile evidence.
skills (3)
skill_list · skill_get · skill_select
MCP prompts (6)
autonomous_task · malware_research_workflow · vulnerability_research_workflow ·
anti_ddos_defense_workflow · software_engineering_workflow · skill_workflow
MCP resources
mirai://knowledge/stats — knowledge base statistics as JSON.
mirai://skills/index — full Skills library listing (JSON: total, facets, per-skill metadata).
6. Skills library (engine skills)
The skills engine provides a versioned technique library that lets an agent discover,
inspect and combine multiple skills to solve complex tasks. Each skill is a SKILL.md file at
skills/<name>/SKILL.md following a standard schema:
YAML front matter:
name,description,version,engines[],tags[],tools[],licenseBody (Markdown): Purpose, Prerequisites, Inputs/Outputs, Procedure, Examples, Known limitations, Verification criteria, Provenance
36 skills available (version 1.0.0)
Each skill is a skills/<name>/SKILL.md with complete front matter and the standard body. Current
list:
anti-ddos-defense · api-reverse-engineering · attack-source-engineering ·
automated-testing · binary-vulnerability-analysis · build-and-debug · code-review ·
evidence-based-research · evidence-validation-and-reconciliation ·
exploit-mechanism-research · exploit-source-analysis · exploit-source-code-analysis ·
firmware-analysis · firmware-zero-day-research · fuzzing-and-crash-triage ·
malware-configuration-extraction · malware-reverse-engineering ·
malware-source-code-analysis · malware-variant-comparison ·
memory-corruption-research · mirai-api-c2-protocol-analysis ·
mirai-botnet-lineage-analysis · mirai-c2-protocol-research · mirai-deep-source-analysis ·
mirai-variant-intelligence · patch-diff-and-variant-hunting · pcap-network-forensics ·
protocol-reverse-engineering · repository-analysis · research-tool-development ·
software-architecture · source-vulnerability-analysis · static-analysis-research ·
threat-intelligence-correlation ·
vulnerability-root-cause-analysis · zero-day-vulnerability-discovery
MCP tools
Tool | Description |
| List skills, filter by engine/tag, return facets |
| Fetch the full skill content (front matter + body) |
| Select and combine skills for a task → ranked recommendations + tool plan + workflow |
MCP resource
mirai://skills/index — JSON: { root, total, facets: {engines, tags}, skills: [...] }
MCP prompt
skill_workflow — 8-step guide: list → select → get → execute tool plan → checkpoint → missing
evidence → reconciliation → final report.
Quick usage
// 1. Browse the library
{ "tool": "skill_list", "input": { "engine": "malware-intelligence", "limit": 10 } }
// 2. Pick skills for a task
{ "tool": "skill_select", "input": { "task": "analyze mirai botnet sample c2 protocol", "limit": 3 } }
// 3. Read skill details
{ "tool": "skill_get", "input": { "name": "mirai-api-c2-protocol-analysis" } }7. Evidence model
Every conclusion carries provenance and confidence; hypotheses are never presented as confirmed findings.
ConfidenceLevel:confirmed→observed→inferred→hypothesis→unknownEpistemicStatus:verified_fact·direct_observation·researcher_interpretation·hypothesis·unverified_claimEvidenceRefcontainsclaim,provenance(source/url/publishedAt/retrievedAt/version/commit/license),confidence,locator(file/line/symbol/offset) anddata.Assertiongroupssupporting+contradictingevidence.aggregateConfidence()computes confidence along the weakest link.KnowledgeCategoryis strictly separated:advisory,detection_template,fingerprint_template,exploit_poc,exploit_module,yara_rule,sigma_rule,network_detection_rule,remediation_guidance,patch_reference,research_paper,attack_method,defense_technology,dataset,firmware_component,malware_family,mirai_variant,c2_protocol_spec,malware_sample_ref.VerificationState:unverified·statically_reviewed·lab_validated_non_destructive·disputed— a published PoC is not automatically treated as verified.
8. Security boundary (§10)
Allowed: malware source and binary analysis, reverse engineering, root-cause analysis, safe PoC analysis, non-destructive validation, isolated lab simulation, firmware analysis, PCAP analysis, detection engineering, DDoS defence deployment, defensive automation, source development and patching, regression testing, honeypot/sinkhole research.
Not allowed (hard-coded, cannot be enabled through configuration): deployable botnets, automated recruitment/infection, worm propagation, malware persistence, unauthorised exploitation, credential theft/brute force, botnet C2, operational DDoS code, distributed flooding, reflection/amplification launchers, source spoofing, evasion code aimed at third-party products, automated exploitation of public targets.
Enforcement:
security.ts —
evaluateIntent()matches forbidden capability patterns and returns a defensive alternative;resolveWorkspacePath()blocks path traversal outside the workspace;requireLabAuthorization()requires a token for active testing.exec.ts — commands run as argv (never through a shell), with hard timeout, output cap and
cwdconfined to the workspace.registry.ts — pre-screens every tool before its handler runs.
9. Testing
tests/
├── smoke.test.ts # registry integrity + real execution of representative tools
├── skills.test.ts # skill loader, registry, skill selection
├── multi-agent.test.ts # roles, orchestrator plan, briefs, findings merge, reconciliation
├── mcp-protocol.test.ts # real Client ↔ Server over InMemoryTransport
├── firmware-extract.test.ts # cpio/tar parsing + firmware extraction regressions
├── binary-similarity.test.ts # binary similarity engine
├── c2-protocol.test.ts # C2 protocol analysis
├── crash-root-cause.test.ts # crash triage
├── curated-datasets.test.ts # curated dataset integrity
├── dependencies.test.ts # dependency probing
├── source-vulnerability.test.ts # source vulnerability analysis
└── stdio-check.test.ts # stdio handshaketests/mcp-protocol.test.ts also verifies the policy gate: with
MIRAI_ALLOW_PUBLIC_FETCH=false, cve_search returns blocked: true instead of touching the
network.
npm run verify10. Adding a new engine
// src/engines/my-engine/index.ts
import type { EngineModule } from '../../core/tool.js';
import { defineTool, finish } from '../../tools/helpers.js';
import { z } from 'zod';
const ENGINE = 'my-engine';
export const myEngine: EngineModule = {
name: ENGINE,
title: 'My Engine',
description: 'Engine description.',
tools: [
defineTool({
name: 'my_tool',
title: 'My tool',
engine: ENGINE,
description: 'Tool description.',
capabilities: ['read_repo'],
risk: 'safe',
inputSchema: { path: z.string() },
handler: async (input, ctx) => {
const started = Date.now();
const { path } = input as { path: string };
return finish({
engine: ENGINE, tool: 'my_tool', startedAt: started, ctx,
data: { path },
summary: `Processed ${path}.`,
});
},
}),
],
};Mandatory constraints: relative imports must end with .js; tool names must match
/^[a-z][a-z0-9_]{2,63}$/ and be globally unique; descriptor.engine must equal
EngineModule.name. Then add the engine to the ENGINES array in index.ts.
11. Known limitations
HTTP transport is not implemented (stdio only).
Deep analysis (Ghidra headless, QEMU emulation, Zeek/Suricata) depends on external tools in
PATH; when missing, the platform falls back to pure-JS analysis (PCAP/ELF/firmware carving) and states so in the result. Per-dependency status is exposed bydependency_diagnostics; a missing dependency yields a structuredTOOL_MISSINGerror and must not be treated as executed.emulation_planonly produces a plan; it never executes untrusted firmware emulation.defense_test_planonly produces a plan; active traffic testing requiresMIRAI_LAB_TOKEN.Curated data in
curated-datasets.tscontains only verified public events; uncertain items were dropped rather than inferred.
License
MIT — see LICENSE.
Core philosophy: Understand deeply. Research rigorously. Engineer intelligently. Verify everything. Defend effectively.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
This server cannot be deployed
Maintenance
Related MCP Connectors
Enrich, search, assess, and manage threat intelligence through 80+ typed MCP tools.
AI-security knowledge as MCP: standards-mapped tools (OWASP, NIST, MITRE) for AI agents.
Compliance frameworks (SOC 2, ISO 27001, CMMC, NIST, more) delivered to AI agents as MCP tools.
Find, vet, and run MCP tools through a secure audited gateway with prompt-injection risk scoring
Related MCP Servers
- FlicenseAqualityDmaintenanceEnables AI assistants to perform defensive security tasks such as vulnerability detection, CVE lookup, phishing/link safety checks, and security report generation via MCP tools.23-
- AlicenseNot gradedqualityBmaintenanceEnables AI agents to conduct authorized mobile banking reverse engineering and security research through 50+ MCP tools spanning APK analysis, Frida instrumentation, malware detection, Play Integrity bypass detection, no-root traffic interception, and evidence reporting.MIT
- AlicenseNot gradedqualityCmaintenanceEnables AI assistants to conduct penetration testing and offensive security workflows, including reconnaissance, exploitation, post-exploitation, threat intelligence, malware analysis, forensics, and reporting through MCP tools. It supports session management, C2, evasion, credential attacks, and many specialized security testing capabilities.1MIT
- AlicenseNot gradedqualityBmaintenanceEnables agents to reverse engineer native binaries, JavaScript/Electron applications, .NET assemblies, web captures, EVM bytecode, and process behavior through a provider-neutral MCP interface. Every result is an evidence envelope stating what was observed, derived, unexamined, or unprovable, with all capabilities gated by a deterministic fail-closed policy engine.Apache 2.0