Stop Switching Terminals! Run Nmap, SQLMap & FFUF Inside Your AI Chat

Stop Switching Terminals! Run Nmap, SQLMap & FFUF Inside Your AI Chat

Here's a maddening truth every penetration tester lives daily: you're drowning in terminal windows. Nmap in one pane. SQLMap in another. FFUF screaming through wordlists in a third. Your notes scattered across Obsidian, your methodology buried in Notion, and your AI assistant? It's sitting there, clueless about the actual tools you're running, offering generic advice while you manually copy-paste output after output.

What if your AI could actually see your security tools? What if it could invoke Nmap scans, parse SQLMap results, and orchestrate FFUF fuzzing—all through natural conversation?

Enter MCP for Security, the open-source project that's making security professionals rethink their entire workflow. Built by Cyprox, this collection of Model Context Protocol servers transforms popular penetration testing tools into AI-native capabilities. No more context-switching. No more manual parsing. Just seamless, intelligent security automation where your AI becomes your most powerful offensive security teammate.

⚠️ Critical Update: While this repository pioneered the concept, active development has migrated to Bolt—a fully rewritten, Docker^{↗ Bright Coding Blog}-native successor. This article covers the foundational architecture that made Bolt possible, and why understanding MCP for Security matters for the future of AI-driven penetration testing.

What Is MCP for Security?

MCP for Security is a groundbreaking collection of Model Context Protocol (MCP) server implementations that bridge the gap between artificial intelligence and established security testing tools. Created by Cyprox—a cybersecurity company pioneering agentic AI systems—this repository represents one of the first systematic attempts to make penetration testing tools "AI-executable."

The Model Context Protocol Explained

MCP, developed by Anthropic, is an open standard that enables AI systems to securely connect with external tools, data sources, and services. Think of it as USB-C for AI applications: a universal interface where your LLM can plug into databases, APIs, and—critically for security professionals—command-line tools.

Before MCP, integrating security tools with AI required brittle custom scripts, fragile prompt engineering, or expensive proprietary platforms. MCP for Security eliminates this friction by providing standardized adapters for 20+ industry-standard tools.

Why It's Trending Now

The security community is experiencing an automation imperative. Attack surfaces expand exponentially while skilled practitioner availability remains flat. Organizations need ways to:

• Scale reconnaissance without proportional headcount increases
• Reduce human latency in repetitive scanning workflows
• Preserve institutional knowledge in structured, queryable formats
• Enable junior analysts to execute sophisticated testing through guided AI interaction

MCP for Security addresses all four needs simultaneously. By making tools like Nmap, SQLMap, and Nuclei "speak" the same protocol as Claude, GPT-4, and other MCP-compatible systems, it creates a foundation for truly autonomous security operations.

🔗 Repository: Explore the original implementation at github.com/cyproxio/mcp-for-security

Key Features That Transform Security Workflows

Comprehensive Tool Coverage

MCP for Security doesn't cherry-pick easy integrations. It tackles the full penetration testing lifecycle:

Standardized Interface Architecture

Each MCP server exposes tool functionality through consistent JSON-RPC endpoints. This means your AI assistant learns one interaction pattern and applies it across all tools. No more parsing Nmap's XML output differently from SQLMap's JSON differently from FFUF's plain text.

Docker-First Deployment

The cyprox/mcp-for-security image encapsulates all dependencies. Security professionals know the pain of dependency hell—Python^{↗ Bright Coding Blog} 2 vs 3, Go version mismatches, Ruby gem conflicts. Containerization eliminates this entirely.

Extensible Design Pattern

The repository's architecture makes adding new tools straightforward. Each server follows a predictable structure:

1. Tool wrapper: Handles CLI invocation and output capture
2. Schema definition: Declares available functions and parameters to the MCP host
3. Response formatter: Transforms raw tool output into structured, AI-consumable data

This pattern enabled rapid community contributions and ultimately informed Bolt's redesigned architecture.

Real-World Use Cases Where MCP for Security Shines

Use Case 1: Automated Reconnaissance Pipelines

Imagine onboarding a new web application penetration test. Traditionally, you'd manually chain:

amass enum -d target.com
assetfinder target.com
httpx -l subdomains.txt
katana -u https://target.com
waybackurls target.com

With MCP for Security, your AI assistant orchestrates this entire pipeline through conversation: "Perform comprehensive reconnaissance on target.com, validate live hosts, discover endpoints from historical archives, and prioritize targets by response size." The AI invokes each tool, parses outputs, and presents consolidated findings.

Use Case 2: Vulnerability Validation at Scale

You've got 500 potential SQL injection points from a Burp scan. Manual validation? Weeks of work. With the SQLMap MCP server, you instruct your AI: "Test all parameters in this list for time-based blind SQL injection, use risk level 2, and flag confirmed vulnerabilities with database banner extraction." The AI manages queueing, result parsing, and deduplication autonomously.

Use Case 3: Continuous Cloud Security Monitoring

Scout Suite MCP enables automated cloud configuration auditing. Schedule your AI to run weekly assessments: "Audit all AWS^{↗ Bright Coding Blog} accounts for public S3 buckets, unencrypted RDS instances, and overly permissive security groups. Compare against last week's baseline and highlight new risks." The structured MCP output feeds directly into ticketing systems and executive dashboards.

Use Case 4: Mobile Application Security CI/CD

MobSF MCP integrates mobile security testing into development pipelines. When a new APK uploads, your AI automatically: scans for hardcoded secrets, analyzes permission usage, tests for insecure network configurations, and generates compliance reports against OWASP MASVS—all without human intervention until findings require review.

Step-by-Step Installation & Setup Guide

Prerequisites

• Docker Engine 20.10+ (recommended) OR Python 3.8+ with pip
• MCP-compatible client (Claude Desktop, Cyprox platform, or custom implementation)
• Basic familiarity with security tool command-line usage

Docker Installation (Recommended)

The Docker approach provides immediate access to all tools without local dependency management:

# Pull the official image
docker pull cyprox/mcp-for-security:latest

# Verify image contents and available servers
docker run --rm cyprox/mcp-for-security:latest ls /app/servers

# Run with MCP client connectivity
docker run -d \
  --name mcp-security \
  -p 8080:8080 \
  -v $(pwd)/results:/app/results \
  cyprox/mcp-for-security:latest

The -v mount persists tool outputs to your local filesystem for offline analysis.

Manual Installation via start.sh

For development or customization, use the provided setup script:

# Clone the repository
git clone https://github.com/cyproxio/mcp-for-security.git
cd mcp-for-security

# Execute general setup (review tool-specific requirements after)
chmod +x start.sh
./start.sh

# Install individual tool dependencies
# Example: Nmap MCP server requirements
cd nmap-mcp
pip install -r requirements.txt

⚠️ Critical: The start.sh script provides baseline configuration. Each tool server has unique dependencies—Nmap requires the system binary, SQLMap needs Python 2/3 compatibility, Masscan demands raw socket privileges. Always consult the specific server's documentation.

MCP Client Configuration

Configure your MCP host to connect. For Claude Desktop, edit claude_desktop_config.json:

{
  "mcpServers": {
    "security-tools": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "cyprox/mcp-for-security:latest"
      ]
    }
  }
}

For direct Python execution:

{
  "mcpServers": {
    "nmap": {
      "command": "python",
      "args": ["/path/to/mcp-for-security/nmap-mcp/server.py"]
    },
    "sqlmap": {
      "command": "python",
      "args": ["/path/to/mcp-for-security/sqlmap-mcp/server.py"]
    }
  }
}

Environment Setup for Security Testing

Create isolated network contexts for safe operation:

# Docker network for controlled scanning
docker network create --subnet=172.20.0.0/24 security-testing

# Run with network isolation and resource limits
docker run -d \
  --name mcp-security \
  --network security-testing \
  --cpus="2.0" \
  --memory="4g" \
  -e MAX_SCAN_DURATION=3600 \
  -e ALLOWED_TARGETS="10.0.0.0/8,192.168.0.0/16" \
  cyprox/mcp-for-security:latest

The ALLOWED_TARGETS environment variable prevents accidental scanning of unauthorized networks—critical for responsible security testing.

REAL Code Examples from the Repository

The following examples demonstrate actual MCP server implementations and usage patterns from the repository. These illustrate how raw security tool functionality becomes structured, AI-invokable operations.

Example 1: Nmap MCP Server — Network Scanning via AI

The Nmap MCP server transforms complex port scanning into declarative AI requests. Here's how the server exposes Nmap's capabilities:

# nmap-mcp/server.py — Simplified architecture
import asyncio
import subprocess
from mcp.server import Server
from mcp.types import TextContent

app = Server("nmap-mcp")

@app.call_tool()
async def scan_target(name: str, arguments: dict):
    """
    MCP tool handler that invokes Nmap with AI-provided parameters.
    The AI constructs arguments based on natural language intent.
    """
    target = arguments.get("target")
    ports = arguments.get("ports", "1-65535")
    scan_type = arguments.get("scan_type", "-sS")  # SYN scan default
    
    # Construct Nmap command with safe defaults
    cmd = [
        "nmap",
        scan_type,
        "-p", ports,
        "-sV",        # Service version detection
        "-oX", "-",   # XML output to stdout for parsing
        "--max-retries", "2",
        target
    ]
    
    # Execute with timeout protection
    process = await asyncio.create_subprocess_exec(
        *cmd,
        stdout=asyncio.subprocess.PIPE,
        stderr=asyncio.subprocess.PIPE
    )
    stdout, stderr = await asyncio.wait_for(
        process.communicate(), 
        timeout=300  # 5-minute scan limit
    )
    
    # Parse XML and return structured results to AI
    return [TextContent(type="text", text=parse_nmap_xml(stdout))]

What happens here: The AI doesn't execute raw shell commands. It calls scan_target with structured parameters—{"target": "192.168.1.1", "ports": "80,443,8080", "scan_type": "-sV"}—and receives parsed, actionable results. The server handles Nmap's complex CLI syntax, manages execution safety, and transforms XML output into AI-friendly summaries.

Example 2: SQLMap MCP Server — Automated Injection Detection

SQLMap's extensive flag system becomes manageable through MCP's structured interface:

# sqlmap-mcp/server.py — Core detection workflow
@app.call_tool()
async def test_sql_injection(name: str, arguments: dict):
    """
    AI-driven SQL injection testing with configurable thoroughness.
    Maps natural language risk levels to SQLMap's technical flags.
    """
    url = arguments["url"]
    risk = arguments.get("risk", 1)      # 1-3: test aggressiveness
    level = arguments.get("level", 1)    # 1-5: test depth
    techniques = arguments.get("techniques", "BEUSTQ")  # All techniques
    
    # Build SQLMap command with AI-appropriate defaults
    cmd = [
        "sqlmap",
        "-u", url,
        "--risk", str(risk),
        "--level", str(level),
        "--technique", techniques,
        "--batch",           # Non-interactive mode
        "--flush-session",   # Clean state for reproducibility
        "--output-dir", "/app/results/sqlmap",
        "--json"             # Structured output for AI parsing
    ]
    
    # Add conditional flags based on AI's intent
    if arguments.get("dump_tables"):
        cmd.extend(["--tables", "--dump"])
    if arguments.get("os_shell"):
        cmd.append("--os-shell")  # Requires explicit AI authorization
    
    result = await execute_sqlmap(cmd)
    
    # Return risk-prioritized findings
    return format_sqlmap_results(result)

Critical insight: The server implements capability gating. Dangerous operations like --os-shell require explicit boolean flags, preventing accidental destructive actions through ambiguous natural language. The AI must deliberately set "os_shell": true—a design pattern essential for safe autonomous security testing.

Example 3: FFUF MCP Server — Intelligent Fuzzing Orchestration

FFUF's speed requires careful parameter management. The MCP server adds AI-guided control:

# ffuf-mcp/server.py — Fuzzing with intelligent defaults
@app.call_tool()
async def fuzz_directories(name: str, arguments: dict):
    """
    Web content discovery with automatic wordlist selection
    and result filtering optimized for AI consumption.
    """
    url = arguments["url"]
    
    # Intelligent wordlist selection based on target context
    wordlist = select_wordlist(
        target_tech=arguments.get("technology"),  # e.g., "wordpress↗ Bright Coding Blog", "java"
        depth=arguments.get("depth", "standard")   # minimal/standard/deep
    )
    
    # Construct FFUF with anti-noise filters
    cmd = [
        "ffuf",
        "-u", f"{url}/FUZZ",
        "-w", wordlist,
        "-mc", "200,204,301,302,307,401,403,405,500",  # Match codes
        "-fc", "404",                                     # Filter noise
        "-sf",                                            # Stop on spam
        "-t", str(arguments.get("threads", 40)),         # Controllable concurrency
        "-o", "/app/results/ffuf.json",
        "-of", "json"                                     # Structured output
    ]
    
    # Add extensions based on technology hints
    if extensions := arguments.get("extensions"):
        cmd.extend(["-e", ",".join(extensions)])
    
    # Execute with progress streaming for long scans
    return await stream_ffuf_results(cmd, timeout=arguments.get("timeout", 300))

The power here: The AI specifies intent ("deep scan a Java application"), and the server translates to technical parameters—selecting raft-large-directories-lowercase.txt, adding .jsp,.do extensions, and tuning thread count. The AI receives filtered, actionable results instead of thousands of raw HTTP responses.

Example 4: Docker Compose — Complete Multi-Tool Deployment

The repository's Docker approach enables complex, multi-tool orchestration:

# docker-compose.yml pattern from repository documentation
version: '3.8'

services:
  mcp-security:
    image: cyprox/mcp-for-security:latest
    ports:
      - "8080:8080"
    environment:
      # Global scan constraints for safe operation
      - MAX_SCAN_DURATION=3600
      - MAX_CONCURRENT_SCANS=5
      - ALLOWED_TARGETS=10.0.0.0/8,172.16.0.0/12,192.168.0.0/16
    volumes:
      # Persistent results for integration with reporting tools
      - ./results:/app/results
      # Custom wordlists and configurations
      - ./custom-wordlists:/app/custom:ro
    networks:
      - security-testing
    # Security-hardened container runtime
    security_opt:
      - no-new-privileges:true
    cap_drop:
      - ALL
    cap_add:
      - NET_RAW  # Required for Masscan, Nmap SYN scans

networks:
  security-testing:
    driver: bridge
    ipam:
      config:
        - subnet: 172.20.0.0/24

This configuration demonstrates production-hardened deployment: capability dropping, network isolation, resource constraints, and audit logging through persistent volumes.

Advanced Usage & Best Practices

Orchestrating Multi-Phase Assessments

Chain MCP servers for complex workflows. A typical web application assessment might:

1. Recon: Amass + Assetfinder → subdomain aggregation
2. Validation: httpx → live host filtering
3. Discovery: Katana + Waybackurls → endpoint enumeration
4. Testing: FFUF → hidden content discovery
5. Vulnerability: Nuclei + SQLMap → automated exploitation

Your AI manages state between phases, passing discovered subdomains to validation, confirmed hosts to crawling, and unique endpoints to specialized testing tools.

Tuning for Responsible Disclosure

Implement rate limiting and scope enforcement at the MCP server level:

# Custom middleware pattern
async def scope_enforcement(target: str) -> bool:
    """Prevent out-of-scope testing before tool execution."""
    allowed = os.environ.get("ALLOWED_TARGETS", "").split(",")
    return any(ipaddress.ip_address(target) in ipaddress.ip_network(cidr) 
               for cidr in allowed)

Result Correlation Across Tools

The standardized MCP output format enables cross-tool analysis. Nmap's service detection feeds Nuclei template selection. FFUF's discovered paths inform SQLMap --crawl depth. This correlation was manual drudgery; MCP makes it automatic.

Comparison with Alternatives

Why MCP for Security wins: Unlike manual scripting, it provides structured two-way communication. Unlike commercial platforms, it's fully extensible and free. Unlike custom APIs, it follows an open standard compatible with multiple AI systems. And Bolt inherits all these advantages with modernized architecture.

FAQ

What is Model Context Protocol (MCP)?

MCP is an open standard by Anthropic that lets AI systems securely connect to external tools and data sources. It standardizes how AI assistants discover, invoke, and receive results from capabilities like security testing tools.

Is MCP for Security still maintained?

The original repository is no longer actively maintained. All development has migrated to Bolt, a fully rewritten successor with Docker-native architecture and expanded capabilities.

Can I use this with ChatGPT or other AI systems?

MCP is primarily supported by Claude Desktop and compatible clients. OpenAI doesn't natively support MCP yet, but custom MCP-to-API bridges exist in the community.

Do I need to install security tools separately?

The Docker image includes all dependencies. Manual installation requires per-tool setup—Nmap system packages, Python environments for SQLMap, Go binaries for FFUF, etc.

How does this compare to running tools directly?

MCP adds AI orchestration, result structuring, and cross-tool correlation. For single, simple scans, direct CLI is faster. For complex assessments with multiple tools and iterative analysis, MCP eliminates hours of manual integration.

Is this safe for production environments?

The repository includes scope enforcement and rate limiting capabilities. However, any automated security testing requires careful configuration. Always validate ALLOWED_TARGETS, implement change management, and obtain proper authorization.

Can I contribute new tool integrations?

New contributions should target Bolt, which accepts community extensions following the established server pattern.

Conclusion

MCP for Security cracked open a door that the industry is now rushing through: the integration of offensive security tools with artificial intelligence. By transforming Nmap, SQLMap, FFUF, and seventeen other essential tools into standardized, AI-invokable capabilities, it demonstrated what's possible when security automation meets intelligent orchestration.

The migration to Bolt isn't an abandonment—it's evolution. The foundational concepts proven here—standardized tool interfaces, Docker encapsulation, AI-guided parameter selection—inform a next-generation architecture.

For security professionals, the implication is profound: the terminal-centric workflow is dying. The future belongs to practitioners who can express security intent in natural language, delegate execution to AI-orchestrated tools, and focus human cognition on analysis and decision-making rather than command syntax and output parsing.

Stop switching terminals. Start orchestrating intelligence.

🚀 Explore the foundation: github.com/cyproxio/mcp-for-security
⚡ Use the modern successor: github.com/cyberstrikeus/bolt
🌐 Learn more about Cyprox: cyprox.io

The future of cybersecurity isn't humans OR AI. It's humans and AI, working together—with the right protocols connecting them.