kali-mcp-go

Go reimplementation of MCP-Kali-Server, built to eliminate the bottlenecks encountered when running multiple AI agents simultaneously.

Background

MCP-Kali-Server by @Wh0am123 was the project that first proved connecting AI agents to Kali Linux tools over MCP works — it's even shipped as an official Kali package. This project owes a lot to that work.

The rewrite was motivated by running into real bottlenecks when spinning up multiple AI agents in parallel against CTF challenges:

Architecture

  [AI Client]
  (Claude / Claude Code / Codex / OpenCode / ...)
        │  MCP stdio
        ▼
  [mcp-client]  ← runs on your local machine
        │  HTTP + Bearer token
        ▼
  [kali-server]  ← runs where security tools are installed
        │  exec
        ▼
  [nmap · gobuster · sqlmap · msfconsole · ...]

Prerequisites

Required tools: nmap, gobuster, dirb, nikto, tshark, sqlmap, msfconsole, hydra, john, wpscan, enum4linux

Installation

Option A — Pre-built binaries (recommended)

Download the latest binaries from the Releases page.

kali-server:

# x86_64
curl -L https://github.com/found-cake/kali-mcp-go/releases/latest/download/kali-server_linux_amd64 \
  -o kali-server && chmod +x kali-server

# arm64
curl -L https://github.com/found-cake/kali-mcp-go/releases/latest/download/kali-server_linux_arm64 \
  -o kali-server && chmod +x kali-server

mcp-client:

# Linux x64
curl -L https://github.com/found-cake/kali-mcp-go/releases/latest/download/mcp-client_linux_amd64 \
  -o mcp-client && chmod +x mcp-client

# Linux arm64
curl -L https://github.com/found-cake/kali-mcp-go/releases/latest/download/mcp-client_linux_arm64 \
  -o mcp-client && chmod +x mcp-client

# macOS Apple Silicon
curl -L https://github.com/found-cake/kali-mcp-go/releases/latest/download/mcp-client_darwin_arm64 \
  -o mcp-client && chmod +x mcp-client

# macOS Intel
curl -L https://github.com/found-cake/kali-mcp-go/releases/latest/download/mcp-client_darwin_amd64 \
  -o mcp-client && chmod +x mcp-client

# Windows x64
curl -L https://github.com/found-cake/kali-mcp-go/releases/latest/download/mcp-client_windows_amd64.exe -o mcp-client.exe

# Windows arm64
curl -L https://github.com/found-cake/kali-mcp-go/releases/latest/download/mcp-client_windows_arm64.exe -o mcp-client.exe

Verify integrity with checksums.txt from the same release:

sha256sum -c checksums.txt

Option B — Build from source

git clone https://github.com/found-cake/kali-mcp-go.git
cd kali-mcp-go

# kali-server (Linux target)
CGO_ENABLED=0 GOOS=linux GOARCH=amd64 \
  go build -trimpath -ldflags="-s -w" -o kali-server ./cmd/kali-server

# mcp-client (native OS)
CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o mcp-client ./cmd/mcp-client

Usage

1. Start kali-server

Set a strong API token and start the server on the machine where your security tools are installed. The default port is 5000.

export KALI_MCP_API_TOKEN="your-secret-token"

./kali-server                           # binds to 127.0.0.1:5000
./kali-server --ip 0.0.0.0 --port 5000  # expose on all interfaces
./kali-server --debug                   # verbose logging
./kali-server --max-concurrent 30       # allow up to 30 concurrent execution requests

kali-server limits concurrent execution requests to protect server resources. When the limit is exceeded, the server returns 503 Service Unavailable.

Tip: Use an SSH tunnel instead of exposing kali-server directly on the network — it's simpler and more secure:

# On your local machine: forward localhost:5000 → remote:5000
ssh -L 5000:127.0.0.1:5000 user@kali-host -N

Then point mcp-client at http://127.0.0.1:5000 as usual.

2. Connect your AI client

Set the same token in your local environment, then add mcp-client to your AI client's MCP configuration.

Claude Desktop

{
  "mcpServers": {
    "kali-mcp": {
      "command": "/path/to/mcp-client",
      "args": ["--server", "http://127.0.0.1:5000"],
      "env": {
        "KALI_MCP_API_TOKEN": "your-secret-token"
      }
    }
  }
}

Claude Code

claude mcp add kali-mcp \
  -e KALI_MCP_API_TOKEN=your-secret-token \
  -- /path/to/mcp-client --server http://127.0.0.1:5000

OpenAI Codex

{
  "mcpServers": {
    "kali-mcp": {
      "command": "/path/to/mcp-client",
      "args": [
        "--server", "http://127.0.0.1:5000",
        "--timeout", "3600"
      ],
      "env": {
        "KALI_MCP_API_TOKEN": "your-secret-token"
      }
    }
  }
}

OpenCode

For OpenCode, prefer a config that raises both:

• the host-side MCP timeout via experimental.mcp_timeout
• the mcp-client base request timeout via --timeout

This is the recommended setup for long-running tools such as dirb_scan, nikto_scan, sqlmap_scan, and long execute_command sessions.

{
  "$schema": "https://opencode.ai/config.json",
  "experimental": {
    "mcp_timeout": 3600000
  },
  "mcp": {
    "kali-mcp": {
      "type": "local",
      "command": [
        "/path/to/mcp-client",
        "--server", "http://127.0.0.1:5000",
        "--timeout", "3600"
      ],
      "environment": {
        "KALI_MCP_API_TOKEN": "your-secret-token"
      }
    }
  }
}

Notes:

• experimental.mcp_timeout controls the OpenCode-side MCP tool-call timeout.
• --timeout controls the mcp-client base request timeout in seconds.
• For long-running scans, set both. Raising only one layer may still leave the other layer timing out early.

mcp-client flags

kali-server flags

Environment variables

ReadTimeout is enforced for incoming request bodies, while streaming responses remain unrestricted by WriteTimeout.

Available Tools

SSE support summary

These MCP tools now stream incremental output over SSE instead of waiting for a buffered final result:

• execute_command
• nmap_scan
• dirb_scan
• nikto_scan
• wpscan_analyze
• enum4linux_scan
• sqlmap_scan
• tshark_capture

Streaming requests support an optional timeout field (seconds) to override the default 300-second request limit for that specific run. For tshark_capture, this request timeout is distinct from the capture duration field.

When using OpenCode, the per-tool request timeout is not enough by itself for long scans. You should also raise OpenCode's MCP timeout (experimental.mcp_timeout) and the local mcp-client --timeout value as shown above.

For Codex and other MCP hosts, you may still want a larger mcp-client --timeout value for long-running tools, but the OpenCode-specific experimental.mcp_timeout setting does not apply there.

Quiet streams may also emit lightweight heartbeat SSE events to keep the connection active until the final done event arrives.

These tools still use a normal POST request/response flow:

• gobuster_scan
• metasploit_run
• john_crack
• server_health

Choosing between hydra_attack and hydra_attack_stream

• Use hydra_attack for quick checks such as a single username/password attempt or other short runs where a buffered final result is sufficient.
• Use hydra_attack_stream for long-running Hydra jobs when you want progress as it happens, especially with username_file and/or password_file inputs.

Project Structure

kali-mcp-go/
├── cmd/
│   ├── kali-server/      # HTTP API server
│   └── mcp-client/       # MCP stdio bridge
├── internal/
│   ├── executor/         # Command execution + SSE streaming
│   ├── kaliclient/       # HTTP client for kali-server
│   └── tools/            # Tool argument builders + validation
└── pkg/
    └── dto/              # Shared request/response types

Security Notice

⚠️ Only target systems you own or have explicit written permission to test.

execute_command runs arbitrary shell commands as the server process user — restrict network access appropriately and prefer an SSH tunnel over direct exposure.

Acknowledgments

This project exists because MCP-Kali-Server by @Wh0am123 proved the concept and shaped the two-tier architecture. Full credit to the original for pioneering AI-assisted pentesting over MCP.