RedVector MCP server

RedVector AI v8.0

Official Website

https://0x7ak7.github.io/RedVector/

AI-Assisted Cybersecurity Automation, Penetration Testing and Red Team Orchestration

Developed and maintained by Adam Karim

RedVector connects MCP-compatible AI clients with a large collection of real cybersecurity tools through a Python MCP layer and a Flask execution backend.

Overview • Architecture • Installation • Security Tools • AI Systems • Workflow • MCP Tools • License

---

Overview

RedVector AI is an AI-assisted cybersecurity automation platform for authorized penetration testing, red-team exercises, vulnerability research, CTFs, labs, defensive validation, digital forensics, reverse engineering, cloud and container assessment, Active Directory testing, web and API security, and security-tool orchestration.

The supplied source tree registers 328 MCP tools in redvector_mcp.py and 331 Flask routes in redvector_server.py. The MCP layer exposes structured capabilities to compatible AI clients. The Flask backend performs validation, process execution, orchestration, result collection, caching, recovery, telemetry, reporting, and access to the underlying security tools installed on the host.

RedVector does not magically bundle every third-party executable. A wrapper may exist even when the corresponding tool is not installed. Kali Linux provides the broadest out-of-the-box coverage, while Ubuntu, Debian and other supported environments can also be used with the required tools installed separately.

Authorized use only. Use RedVector only on systems you own or have explicit permission to assess.

---

Architecture

graph TD
    A[AI Client / MCP-Compatible Agent] -->|MCP stdio| B[redvector_mcp.py]
    B -->|HTTP / REST| C[redvector_server.py]
    C --> D[Intelligent Decision and Workflow Layer]
    C --> E[Process, Cache, Recovery and Telemetry]
    C --> F[Security Tool Integrations]
    F --> G[Recon and Network]
    F --> H[Web, API and Authentication]
    F --> I[Active Directory and Windows]
    F --> J[Cloud, Container and IaC]
    F --> K[Binary, Forensics and CTF]
    D --> L[Structured Results and Reports]
    E --> L
    G --> L
    H --> L
    I --> L
    J --> L
    K --> L

Main runtime files

File	Role
redvector_server.py	Flask backend, orchestration, security-tool execution, autonomous workflows, process management and reporting
redvector_mcp.py	FastMCP interface exposing RedVector capabilities to AI clients
redvector_tool_manager.py	Runtime tool registry and manager backing RedVector's MCP tool surface
redvector-mcp.json	Example MCP configuration
start_redvector.sh	Linux launcher, verifies backend ownership, starts backend on demand and runs MCP client
redvector_banner.py	Shared original terminal banner and startup panel; also performs the Linux socket/process ownership backend identity check via --backend-check (migrated from the removed redvector_backend_check.py); never starts the backend
redvector_ai_desktop_manager.sh	Primary Claude Desktop installer and MCP manager (install, configure, check, start and update Claude Desktop with RedVector MCP)
start_redvector.ps1	Windows PowerShell launcher
requirements.txt	Python dependencies

---

How RedVector Works

1. Start the RedVector backend. The Flask service normally binds to 127.0.0.1:8888.
2. Connect an MCP-compatible AI client. The client launches or connects to redvector_mcp.py.
3. Submit an authorized task. The AI selects a RedVector MCP capability based on the operator's request.
4. RedVector validates parameters and scope. Requests are normalized before execution.
5. The backend invokes the selected integration. The corresponding security tool runs on the RedVector host.
6. Process and recovery systems monitor execution. Long-running jobs can be cached, monitored, retried, paused, resumed, or terminated where supported.
7. Results are normalized. Tool output is returned through the Flask API to the MCP layer.
8. The AI interprets the result. The client can explain findings, select a follow-up workflow, generate a report, or call another RedVector capability.

Typical assessment workflow

Authorized target
      |
      v
Reconnaissance and OSINT
      |
      v
Service and technology identification
      |
      v
Vulnerability discovery and correlation
      |
      v
Validation / exploit research
      |
      v
Controlled exploitation where explicitly authorized
      |
      v
Post-exploitation / privilege escalation / lateral movement where in scope
      |
      v
Evidence, reporting and remediation guidance

RedVector also contains specialized workflow managers and autonomous engines for CTF, bug bounty, Active Directory, web vulnerability chaining, cloud assessment, CCTV assessment, exploitation research, privilege escalation, persistence, lateral movement, data exfiltration simulation, fuzzing and related red-team workflows.

---

Installation

Kali Linux / Linux

Clone RedVector and install its Python dependencies:

git clone https://github.com/0x7AK7/RedVector.git
cd RedVector
python3 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip
pip install -r requirements.txt

Choose how to run RedVector:

• Claude Desktop integration (recommended for desktop users): Follow Claude Desktop automatic setup below. Do not start start_redvector.sh separately when Claude Desktop is configured to launch it.
• Standalone or another MCP client: Run bash start_redvector.sh in a dedicated terminal. This starts the backend if necessary and launches the MCP client using stdio. For a backend-only session, see below.

Or start the backend directly:

python redvector_server.py

AI Desktop Manager (Claude Desktop)

redvector_ai_desktop_manager.sh is a menu-driven manager that installs and manages Claude Desktop with its RedVector MCP integration. Run it after cloning and installing the Python dependencies above:

chmod +x redvector_ai_desktop_manager.sh
./redvector_ai_desktop_manager.sh

REDVECTOR  —  AI DESKTOP MANAGER

  [1] Claude Desktop    Install Claude and register the RedVector MCP server
  [0] Exit

• Claude Desktop — installs from the verified official APT repository (signing-key fingerprint checked) and registers RedVector as an MCP server by launching start_redvector.sh. Existing MCP servers and any existing RedVector environment variables are preserved, a timestamped backup is written, and the configuration is updated atomically.

Run the manager as your normal desktop user (it uses sudo only for package steps). Use --status for a non-interactive summary and --help for usage. This manager is an optional convenience; the manual Claude Desktop setup below remains fully supported.

Claude Desktop automatic setup (Kali Linux)

Claude Desktop on Linux is currently a beta release. Kali Linux is Debian-based, but it is not among Anthropic's officially tested distributions. An x86_64 or arm64 Debian-based desktop is required. If you use Kali through WSL2, Anthropic recommends installing Claude Desktop on Windows and running sessions in WSL rather than installing the Linux desktop app inside WSL.

One-time setup: use the AI Desktop Manager described above (./redvector_ai_desktop_manager.sh). Choose Install Claude Desktop, then Configure RedVector MCP. The manager creates or updates ~/.config/Claude/claude_desktop_config.json, backs up an existing configuration, and preserves other MCP server entries. The generated redvector-ai entry launches start_redvector.sh using an absolute path. Use your existing API token configuration when applicable; avoid publishing secrets in Git.

Everyday use, after fully quitting and restarting Claude Desktop once to load the configuration:

claude-desktop

Claude Desktop is expected to launch RedVector's start_redvector.sh automatically through MCP. The launcher resolves its own installation directory (including symbolic links), uses that project's .venv Python when available, and verifies the listening process through Linux /proc before reusing a backend. It checks http://127.0.0.1:8888/health, starts the RedVector backend when the port is free, and runs redvector_mcp.py via stdio. A foreign process or unverifiable owner causes a clear error; no process is stopped automatically. You normally do not need to execute start_redvector.sh manually. The backend may remain running after Claude Desktop closes because the launcher detaches it.

The MCP client obtains tool availability from /health/details, including the essential count (for example, 8/8). Missing or invalid availability fields are reported as Unknown. Launcher and MCP diagnostics go to stderr; backend output goes to server.log, keeping MCP stdout reserved for the protocol. If ownership cannot be read (for example, restricted /proc access or a different user), run the backend under the same user with visible process metadata or resolve the port conflict manually.

When run manually with bash start_redvector.sh from an interactive terminal, the launcher also displays the original red logo and startup panel on stderr, including when it reuses this installation's running backend. The server and launcher share the same renderer; displaying the banner does not start another server. The MCP tool count is read from the current registrations. Claude Desktop's piped MCP launch suppresses the banner and keeps stdout exclusively for the protocol.

Verify the connection: Open Claude Desktop → Settings → Developer → Local MCP servers and check that redvector-ai is running. In a Claude chat, request a read-only server_health check. Do not assume a reported scan was executed unless the corresponding MCP tool call and output are visible.

If redvector-ai shows Failed:

curl -fsS http://127.0.0.1:8888/health
cat ~/.config/Claude/claude_desktop_config.json
ls -lah ~/.config/Claude/logs/

Inspect the redvector-ai log through View logs in Claude Desktop. Ensure the configured project path exists and start_redvector.sh is present. Avoid sharing API tokens when pasting configuration or logs publicly.

This setup is for Claude Desktop. Claude Code launched independently with the claude terminal command may require separate MCP registration.

Windows PowerShell

git clone https://github.com/0x7AK7/RedVector.git
cd RedVector
python -m venv .venv
.\.venv\Scripts\Activate.ps1
python -m pip install --upgrade pip
pip install -r requirements.txt
.\start_redvector.ps1

Verify the backend

curl http://127.0.0.1:8888/health

---

Configuration

Common environment variables used by the project include:

Variable	Purpose
REDVECTOR_HOST / HOST	Backend bind address, depending on launcher/runtime path
REDVECTOR_PORT / PORT	Backend port
REDVECTOR_API_TOKEN	Bearer token used to protect API access
REDVECTOR_ENABLE_PYTHON_EXEC	Opt-in switch for the Python execution/installation endpoints (see below). Disabled unless set to 1/true/yes/on
COMMAND_TIMEOUT	Maximum command execution time where supported
CACHE_TTL	Cache lifetime
FLASK_DEBUG	Flask debug setting

Example:

export REDVECTOR_API_TOKEN="replace-with-a-strong-random-token"
python redvector_server.py

For remote exposure, use appropriate network controls, authentication, TLS termination, and an isolated assessment environment. Binding to localhost is the safest default.

Python execution endpoints (REDVECTOR_ENABLE_PYTHON_EXEC)

The /api/python/execute and /api/python/install endpoints run arbitrary Python and install arbitrary packages, so they provide authenticated arbitrary-code execution. They are disabled by default and hardened as follows:

• They return 403 unless REDVECTOR_ENABLE_PYTHON_EXEC is explicitly set to a truthy value (1, true, yes, on).
• Even when enabled, they stay disabled whenever the backend is bound to a non-loopback interface, so they can never be reached over the network.
• Valid API authentication is always required; the historical development token is rejected like any other request.
• The launchers, installers and Claude Desktop integration never set this variable — enabling the endpoints is always a deliberate, local action.

Only enable this on a trusted local workstation for authorized use (e.g. local tooling or CTF work). Leave it unset for any shared, exposed or production host.

---

MCP Client Integration

RedVector is designed to work with MCP-compatible AI clients. Examples include Claude-based clients, Cursor, VS Code integrations, local LLM workflows, and other clients capable of launching an MCP stdio server.

Example configuration:

{
  "mcpServers": {
    "redvector": {
      "command": "python",
      "args": ["/absolute/path/to/RedVector/redvector_mcp.py"],
      "env": {
        "REDVECTOR_SERVER": "http://127.0.0.1:8888"
      }
    }
  }
}

The repository also contains redvector-mcp.json as a starting point. Review paths and environment values before use.

---

Security Tools

RedVector exposes a broad security-tool surface through MCP and REST integrations. The list below is derived from the supplied project documentation and source. Availability depends on what is installed on the host.

Security Tool Arsenal

• Nmap - Advanced port scanning, service detection, OS fingerprinting, NSE scripting, and network discovery.
• RustScan - Ultra-fast port discovery designed to feed identified services into deeper scanning workflows.
• Masscan - High-speed large-scale TCP port scanning with configurable rates and banner collection.
• AutoRecon - Automated multi-stage reconnaissance and service enumeration across discovered ports.
• Amass - Subdomain enumeration, attack-surface mapping, and OSINT-assisted domain discovery.
• Subfinder - Fast passive subdomain discovery using multiple public intelligence sources.
• HTTPx - HTTP probing, status discovery, title collection, technology identification, and web-service validation.
• theHarvester - OSINT collection for domains, hosts, subdomains, email addresses, and public exposure.
• DNSRecon - DNS enumeration, record discovery, zone-transfer checks, and brute-force workflows.
• DNSEnum - DNS information gathering and subdomain enumeration.
• Fierce - DNS reconnaissance and domain-mapping support.
• Enum4linux - SMB and Windows host enumeration for users, groups, shares, and policy information.
• Enum4linux-ng - Enhanced SMB enumeration with structured output and broader discovery options.
• SMBMap - SMB share discovery, permission review, and remote resource enumeration.
• rpcclient - RPC-based Windows and Samba enumeration.
• NBTScan - NetBIOS name and host discovery across local or remote networks.
• ARP-Scan - Layer-2 host discovery using ARP requests.
• Responder - LLMNR, NBT-NS, and MDNS analysis for authorized internal-network assessments.
• NetExec - Multi-protocol network assessment and Active Directory enumeration framework.
• Shodan CLI - Internet-facing asset, service, and exposure discovery through Shodan data.

• Nuclei - Template-driven vulnerability scanning for web services, exposed technologies, and known security issues.
• Gobuster - Directory, file, DNS, and virtual-host enumeration.
• Dirsearch - Directory and file discovery with extension, recursion, and threading controls.
• Feroxbuster - Recursive web content discovery with filtering and high-performance enumeration.
• FFuf - Fast web fuzzing for paths, parameters, virtual hosts, and request components.
• Dirb - Traditional web-content discovery using configurable wordlists.
• Katana - Modern crawler for endpoint discovery, JavaScript-aware crawling, and form extraction.
• Hakrawler - Lightweight web crawling and endpoint enumeration.
• Gau - URL collection from public archives and passive sources.
• Waybackurls - Historical URL discovery using Wayback Machine data.
• Nikto - Web-server configuration and vulnerability assessment.
• WPScan - WordPress security assessment, plugin/theme enumeration, and vulnerability discovery.
• Arjun - Hidden HTTP parameter discovery.
• ParamSpider - Parameter and URL mining from archived web data.
• x8 - Hidden parameter discovery for web applications and APIs.
• Jaeles - Signature-based vulnerability scanning and customizable web assessment workflows.
• Dalfox - XSS discovery and analysis with parameter mining and DOM-focused testing.
• XSSer - Cross-site scripting assessment and payload testing.
• Wfuzz - Flexible web application fuzzing and discovery.
• DotDotPwn - Directory traversal assessment.
• Wafw00f - Web application firewall identification and fingerprinting.
• testssl.sh - TLS/SSL configuration, cipher, and protocol security assessment.
• Commix - Command-injection detection and validation for authorized testing.
• NoSQLMap - NoSQL injection assessment for supported database technologies.
• Burp Suite Integration - Project-based and headless web security assessment integration.
• OWASP ZAP Integration - Automated web application scanning and proxy-assisted security testing.