RAD Security

offiziell

Interagieren Sie mit der RAD Security-Plattform, die KI-gestützte Sicherheitseinblicke für Kubernetes- und Cloud-Umgebungen bietet.

GitHub

Was kann man mit RAD Security MCP machen?

Sicherheitsbefunde auflisten — Bitten Sie Ihren Assistenten, Sicherheitsbefunde in Ihren Kubernetes- und Cloud-Umgebungen aufzulisten und zu analysieren.
Laufzeitverhalten untersuchen — Prozessbäume, Laufzeit-Baselines und Prozessverhaltensanalysen für laufende Container abrufen.
Images und Schwachstellen abfragen — SBOMs abrufen, die am stärksten gefährdeten Images auflisten und CVE-Status wie das Ignorieren oder Aufheben des Ignorierens von CVEs verwalten.
Automatisierungen verwalten — Automatisierungen (Workflows) mit Cron-Zeitplänen direkt aus dem Chat auflisten, erstellen, aktualisieren und ausführen.
Wissensdatenbank durchsuchen — Sammlungen und Dokumente durchsuchen und strukturierte Abfragen gegen bestimmte Dokumente ausführen.
RadQL-Abfragen ausführen — Erweiterte Abfragen mit Filtern, Suchen und Aggregationen über Datentypen wie Container und Befunde ausführen.

Dokumentation

RAD Security MCP Server

Ein Model Context Protocol (MCP)-Server für RAD Security, der KI-gestützte Sicherheitseinblicke für Kubernetes- und Cloud-Umgebungen bietet.

Verbinden (gehostet — empfohlen)

RAD Security betreibt den MCP-Server für Sie, sodass die meisten Benutzer nichts installieren oder hosten müssen. Richten Sie Ihren MCP-Client auf den gehosteten Endpunkt und authentifizieren Sie sich mit Ihren RAD-Security-Anmeldedaten.

Endpunkt: https://api.rad.security/mcp/ — beachten Sie den nachgestellten Schrägstrich.
Transport: Streamable HTTP.
Authentifizierung: Senden Sie Ihre Anmeldedaten im Authorization-Header:
```
Authorization: Bearer <access_key_id>:<secret_key>:<account_id>
```
<access_key_id> und <secret_key> sind ein RAD-Security-API-Zugriffsschlüssel (erstellen Sie einen in der RAD-Security-Konsole); <account_id> ist Ihre Kontonummer. Der Server authentifiziert jede Anfrage gegen die RAD-Security-API — es werden keine Anmeldedaten serverseitig gespeichert.

Eine kurzlebige Form Bearer ory_st_<session_token>:<account_id> funktioniert ebenfalls, aber Sitzungstokens laufen ab — bevorzugen Sie einen Zugriffsschlüssel für alles Langfristige (z. B. Slack / Claude Tag).

Claude Code

claude mcp add --transport http rad-security https://api.rad.security/mcp/ \
  --header "Authorization: Bearer <access_key_id>:<secret_key>:<account_id>"

OpenAI Codex CLI

~/.codex/config.toml:

[mcp_servers.rad-security]
url = "https://api.rad.security/mcp/"
http_headers = { "Authorization" = "Bearer <access_key_id>:<secret_key>:<account_id>" }

Oder über die CLI, wobei das Geheimnis in einer Umgebungsvariable gehalten wird (export RAD_MCP_TOKEN=<access_key_id>:<secret_key>:<account_id>):

codex mcp add rad-security --url https://api.rad.security/mcp/ --bearer-token-env-var RAD_MCP_TOKEN

Cursor

.cursor/mcp.json:

{
  "mcpServers": {
    "rad-security": {
      "type": "http",
      "url": "https://api.rad.security/mcp/",
      "headers": {
        "Authorization": "Bearer <access_key_id>:<secret_key>:<account_id>"
      }
    }
  }
}

VS Code (GitHub Copilot)

.vscode/mcp.json — beachten Sie, dass der Wrapper-Schlüssel servers ist, nicht mcpServers:

{
  "servers": {
    "rad-security": {
      "type": "http",
      "url": "https://api.rad.security/mcp/",
      "headers": {
        "Authorization": "Bearer <access_key_id>:<secret_key>:<account_id>"
      }
    }
  }
}

Gemini CLI

~/.gemini/settings.json — beachten Sie, dass das URL-Feld httpUrl ist (nicht url):

{
  "mcpServers": {
    "rad-security": {
      "httpUrl": "https://api.rad.security/mcp/",
      "headers": {
        "Authorization": "Bearer <access_key_id>:<secret_key>:<account_id>"
      }
    }
  }
}

Cline

cline_mcp_settings.json — beachten Sie, dass type genau streamableHttp sein muss (camelCase):

{
  "mcpServers": {
    "rad-security": {
      "type": "streamableHttp",
      "url": "https://api.rad.security/mcp/",
      "headers": {
        "Authorization": "Bearer <access_key_id>:<secret_key>:<account_id>"
      }
    }
  }
}

Windsurf

~/.codeium/windsurf/mcp_config.json — beachten Sie, dass das URL-Feld serverUrl ist:

{
  "mcpServers": {
    "rad-security": {
      "serverUrl": "https://api.rad.security/mcp/",
      "headers": {
        "Authorization": "Bearer <access_key_id>:<secret_key>:<account_id>"
      }
    }
  }
}

Andere Clients

Die meisten MCP-Clients akzeptieren einen entfernten Streamable-HTTP-Server mit einer URL und einem Authorization-Header — nur die Feldnamen unterscheiden sich. Behalten Sie in jedem Fall den nachgestellten Schrägstrich in der URL bei.

Client	Konfigurationsort	URL-Feld	Transportmarker	Header-Feld
Claude Code	`claude mcp add`	Positionsargument	`--transport http`	`--header`
OpenAI Codex CLI	`~/.codex/config.toml`	`url`	abgeleitet	`http_headers` / `bearer_token_env_var`
Cursor	`.cursor/mcp.json`	`url`	`type: "http"`	`headers`
VS Code	`.vscode/mcp.json` (`servers`)	`url`	`type: "http"`	`headers`
Gemini CLI	`~/.gemini/settings.json`	`httpUrl`	abgeleitet	`headers`
Cline	`cline_mcp_settings.json`	`url`	`type: "streamableHttp"`	`headers`
Windsurf	`~/.codeium/windsurf/mcp_config.json`	`serverUrl`	abgeleitet	`headers`

Claude.ai / Claude Desktop / Claude Tag (Slack)

Diese Oberflächen fügen entfernte MCP-Server als Konnektoren hinzu, die ihre eigenen Anmeldeeinstellungen verwenden, anstatt einen rohen Anfrage-Header. Fügen Sie https://api.rad.security/mcp/ als benutzerdefinierten Konnektor hinzu und geben Sie dann die Bearer-Anmeldedaten über die Einstellungen des Konnektors an:

Claude Tag (Slack): Hängen Sie den Server als Plugin an, dessen .mcp.json auf den Endpunkt zeigt, und fügen Sie die Bearer-Anmeldedaten auf der Registerkarte Anmeldedaten des Access-Bundle hinzu. Siehe Claude Tag — einen benutzerdefinierten MCP-Server verbinden.
Claude.ai / Desktop: Fügen Sie ihn unter Einstellungen → Konnektoren hinzu; siehe benutzerdefinierte Konnektoren.

Testen (MCP Inspector oder curl)

npx @modelcontextprotocol/inspector
# Transport:      Streamable HTTP
# URL:            https://api.rad.security/mcp/   (trailing slash)
# Custom headers: { "Authorization": "Bearer <access_key_id>:<secret_key>:<account_id>" }

curl -H "authorization: Bearer <access_key_id>:<secret_key>:<account_id>" \
  -H "content-type: application/json" \
  -H "accept: application/json, text/event-stream" \
  -X POST https://api.rad.security/mcp/ \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"curl","version":"1"}}}'

Eingrenzen der Tools, die ein Agent sieht

Standardmäßig erhält eine Verbindung jedes Toolkit. Um einem Agenten eine kleinere Menge zu geben — weniger Kontext-/Token-Overhead und geringstes Privileg — fügen Sie einen Scoping-Header zu dieser Verbindung hinzu, neben Authorization. Die Teilmenge wird erzwungen: Ein außerhalb des Bereichs liegendes Tool wird vor tools/list verborgen und abgelehnt, wenn es aufgerufen wird.

Header	Wirkung
`X-Rad-Toolkits: findings, images`	nur diese Toolkits
`X-Rad-Exclude-Toolkits: workflows`	alle Toolkits außer diesen
`X-Rad-Readonly: true`	nur schreibgeschützte Tools (entfernt die Schreib-Tools)

Toolkits: containers, clusters, audit, images, kubeobject, runtime, findings, inbox, workflows, knowledge_base, radql, dashboards, integrations. Alle sind standardmäßig aktiviert — grenzen Sie mit den obigen Headern ein und verwenden Sie X-Rad-Readonly, wenn Sie alle Schreib-Tools ausschließen möchten.

Beispiel — ein schreibgeschützter Findings-/Images-Agent (jeder Client, der Header unterstützt; Cursor gezeigt):

{
  "mcpServers": {
    "rad-security-findings": {
      "type": "http",
      "url": "https://api.rad.security/mcp/",
      "headers": {
        "Authorization": "Bearer <access_key_id>:<secret_key>:<account_id>",
        "X-Rad-Toolkits": "findings, images",
        "X-Rad-Readonly": "true"
      }
    }
  }
}

In Claude Code übergeben Sie einen zusätzlichen --header:

claude mcp add --transport http rad-security https://api.rad.security/mcp/ \
  --header "Authorization: Bearer <access_key_id>:<secret_key>:<account_id>" \
  --header "X-Rad-Toolkits: findings, images"

Funktionen

Alle Tools erfordern eine Authentifizierung und ein Konto in RAD Security. Der gehostete Endpunkt stellt standardmäßig jedes untenstehende Toolkit bereit; grenzen Sie einen Client mit X-Rad-Toolkits / X-Rad-Exclude-Toolkits ein oder entfernen Sie alle Schreib-Tools mit X-Rad-Readonly: true.

Kontoinventar
- Cluster und deren Details auflisten
Container-Inventar
- Container und deren Details auflisten
Sicherheitsbefunde
- Sicherheitsbefunde auflisten und analysieren
- Den Status eines Sicherheitsbefunds aktualisieren
Laufzeitsicherheit
- Prozessbäume laufender Container abrufen
- Laufzeit-Baselines laufender Container abrufen
- Prozessverhalten laufender Container analysieren
Audit
- Auflisten, wer in einen Pod eingestiegen ist
Bilder und Schwachstellen
- SBOMs abrufen
- Bilder und deren Schwachstellen auflisten
- Am stärksten gefährdete Bilder abrufen
- CVEs ignorieren / nicht ignorieren und aktive CVE-Entscheidungen auflisten
Kubernetes-Objekte
- Details einer bestimmten Kubernetes-Ressource abrufen
- Kubernetes-Ressourcen auflisten
Posteingang
- Posteingangselemente und deren Details auflisten
- Ein Posteingangselement als falsch-positiv markieren
Automatisierungen (workflows)
- Automatisierungen, Läufe und Zeitpläne auflisten
- Automatisierungs- und Laufdetails abrufen
- Eine Automatisierung ausführen
- Automatisierungen erstellen und aktualisieren und Cron-Zeitpläne hinzufügen
„Automatisierung" ist der Produktname, den Benutzer sehen; „Workflow" ist das zugrunde liegende Windmill-Objekt, das die API- und Tool-Namen verwenden. Sie sind dasselbe.
Wissensdatenbank
- Die Wissensdatenbank durchsuchen
- Sammlungen und Dokumente auflisten
- Strukturierte Abfragen gegen ein Dokument ausführen
Dashboards
- Dashboards auflisten und deren Details abrufen
- Dashboard- und Widget-Vorlagen auflisten und abrufen
- Ein Dashboard erstellen und eines an Ort und Stelle aktualisieren (weggelassene Felder bleiben unverändert, sodass eine kleine Bearbeitung nicht das erneute Senden des gesamten Dashboards erfordert)
Integrationen
- Externe Integrationen auflisten
RadQL (erweiterte Abfragen)
- Verfügbare Datentypen für Abfragen auflisten (Container, Befunde, Kubernetes-Ressourcen usw.)
- Schema/Metadaten für bestimmte Datentypen abrufen
- Mögliche Werte für Filterfelder auflisten
- RadQL-Abfragen mit Filtern, Suchen und Aggregationen ausführen
- Abfragen programmatisch aus strukturierten Bedingungen erstellen
- Mehrere Abfragen parallel ausführen

Eigenes Hosting

Sie bevorzugen es, den Server selbst zu betreiben — zum Beispiel eine air-gapped Umgebung, Datenresidenz-Anforderungen, oder wenn Sie nicht über das gehostete Gateway leiten möchten? Er ist auf npm veröffentlicht und als Container-Image erhältlich.

Voraussetzungen

Node.js 20.x oder höher

Anmeldedaten

Geben Sie Ihre RAD-Security-Anmeldedaten über Umgebungsvariablen an:

RAD_SECURITY_ACCESS_KEY_ID="your_access_key"
RAD_SECURITY_SECRET_KEY="your_secret_key"
RAD_SECURITY_ACCOUNT_ID="your_account_id"

# Optional: fetched automatically from the account if not set
RAD_SECURITY_TENANT_ID="your_tenant_id"

npx (stdio) — z. B. Claude Desktop

{
  "mcpServers": {
    "rad-security": {
      "command": "npx",
      "args": ["-y", "@rad-security/mcp-server"],
      "env": {
        "RAD_SECURITY_ACCESS_KEY_ID": "<your-access-key-id>",
        "RAD_SECURITY_SECRET_KEY": "<your-secret-key>",
        "RAD_SECURITY_ACCOUNT_ID": "<your-account-id>"
      }
    }
  }
}

Docker (Streamable HTTP)

docker build -t rad-security/mcp-server .
docker run \
  -e TRANSPORT_TYPE=streamable \
  -e RAD_SECURITY_ACCESS_KEY_ID=your_access_key \
  -e RAD_SECURITY_SECRET_KEY=your_secret_key \
  -e RAD_SECURITY_ACCOUNT_ID=your_account_id \
  -p 3000:3000 \
  rad-security/mcp-server

Toolkit-Filterung

Steuern Sie, welche Toolkits ein selbst gehosteter Server bereitstellt:

INCLUDE_TOOLKITS: Kommagetrennte Liste der einzuschließenden Toolkits (nur diese sind aktiviert).
EXCLUDE_TOOLKITS: Kommagetrennte Liste der auszuschließenden Toolkits (alle anderen sind aktiviert). Wird ignoriert, wenn INCLUDE_TOOLKITS gesetzt ist.

Verfügbare Toolkits: containers, clusters, audit, images, kubeobject, runtime, findings, inbox, workflows, knowledge_base, radql, dashboards, integrations. Alle sind standardmäßig aktiviert.

# Only the workflows toolkit
INCLUDE_TOOLKITS="workflows"

# Everything except runtime
EXCLUDE_TOOLKITS="runtime"

Multi-Tenant (Authentifizierung pro Anfrage)

MCP_AUTH_MODE steuert, wie eine Streamable-HTTP-Bereitstellung eingehende Anfragen authentifiziert — das verwendet der gehostete Endpunkt:

MCP_AUTH_MODE=env (Standard) — jede Sitzung verwendet die RAD_SECURITY_*-Umgebungsanmeldedaten. Einzelmieter und auf HTTP-Ebene nicht authentifiziert, daher darf es nicht aus nicht vertrauenswürdigen Netzwerken erreichbar sein.
MCP_AUTH_MODE=header — jede Anfrage muss ihre eigene Anmeldedaten im Authorization-Header mitführen (die Bearer <access_key_id>:<secret_key>:<account_id>-Form oben); ein fehlender oder fehlerhafter Header wird mit 401 abgelehnt. Nur mit TRANSPORT_TYPE=streamable unterstützt. RAD_SECURITY_API_URL wird aus der Serverkonfiguration übernommen, nicht vom Aufrufer.

docker run \
  -e TRANSPORT_TYPE=streamable \
  -e MCP_AUTH_MODE=header \
  -e RAD_SECURITY_API_URL=https://api.rad.security \
  -p 3000:3000 \
  rad-security/mcp-server

Der SSE-Transport (TRANSPORT_TYPE=sse) ist zugunsten von Streamable HTTP veraltet und verwendet nur Umgebungsanmeldedaten.

Entwicklung

# Install dependencies
npm install

# Run type checking
npm run type-check

# Run linter
npm run lint

# Build
npm run build

Lizenz

MIT-Lizenz — siehe die Datei LICENSE für Details