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 überprüfen — Sicherheitsbefunde auflisten und analysieren und anschließend den Status eines Befunds aktualisieren.
Images und CVEs untersuchen — SBOMs abrufen, Images mit Schwachstellen auflisten, die am stärksten gefährdeten Images finden und CVEs ignorieren oder wieder berücksichtigen.
Laufzeitverhalten nachverfolgen — Prozessbäume und Laufzeit-Baselines für laufende Container abrufen und ihr Prozessverhalten analysieren.
Pod-Zugriffe prüfen — Auflisten, wer sich in eine Pod-Shell eingeloggt hat.
RadQL-Abfragen ausführen — Datentypen auflisten, Schemas abrufen und gefilterte oder aggregierte Abfragen ausführen, auch mehrere parallel.
Automatisierungen verwalten — Automatisierungen, Ausführungen und Zeitpläne auflisten, Ausführungsdetails abrufen, eine Automatisierung ausführen oder eine erstellen und aktualisieren.

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 bereitstellt.

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 aus und authentifizieren Sie sich mit Ihren RAD Security-Anmeldedaten.

Endpunkt: https://api.rad.security/mcp/ — beachten Sie den abschließenden Schrägstrich.
Transport: Streamable HTTP.
Authentifizierung: Senden Sie Ihre Anmeldedaten im Header Authorization:
```
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 Konto-ID. Der Server authentifiziert jede Anfrage bei der RAD Security API — serverseitig werden keine Anmeldedaten gespeichert.

Eine kurzlebige Form Bearer ory_st_<session_token>:<account_id> funktioniert ebenfalls, aber Sitzungstoken laufen ab — für alles, was längerfristig genutzt wird (z. B. Slack / Claude Tag), sollten Sie einen Zugriffsschlüssel bevorzugen.

Eine Verbindung für einen ganzen Mandanten

Um über eine MCP-Konfiguration auf alle Ihre Konten zuzugreifen, erstellen Sie einen Zugriffsschlüssel für Ihren Mandanten und verwenden Sie tenant=<tenant_id> anstelle der Konto-ID:

Authorization: Bearer <access_key_id>:<secret_key>:tenant=<tenant_id>

In einer mandantenbezogenen Sitzung:

Ein list_accounts-Tool gibt die Konten des Mandanten zurück.
Tools mit Kontobezug erfordern ein Argument account_id, das ein untergeordnetes Konto des Mandanten sein muss. Jeder Aufruf gilt für ein Konto; Ergebnisse werden nicht kontenübergreifend zusammengeführt.
Standardmäßig sind nur schreibgeschützte Tools verfügbar, da ein Mandanten-Zugriffsschlüssel Zugriff auf jedes Konto ermöglicht. Um Schreibtools zu aktivieren, senden Sie X-Rad-Readonly: false.

Legen Sie für den npx/stdio-Server RAD_SECURITY_TENANT_ID ohne RAD_SECURITY_ACCOUNT_ID fest und verwenden Sie RAD_SECURITY_READONLY=false, um Schreibtools zu aktivieren.

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 Umgebungsvariablen bleibt (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 und nicht mcpServers lautet:

{
  "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 lautet (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 exakt streamableHttp lauten 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 lautet:

{
  "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 Remote-Streamable-HTTP-Server mit einer URL und einem Header Authorization — nur die Feldnamen unterscheiden sich. Behalten Sie in jedem Fall den abschließenden Schrägstrich in der URL bei.

Client	Speicherort der Konfiguration	URL-Feld	Transportkennzeichnung	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 Remote-MCP-Server als Connectors hinzu, die eigene Anmeldedateneinstellungen anstelle eines rohen Anfrage-Headers verwenden. Fügen Sie https://api.rad.security/mcp/ als benutzerdefinierten Connector hinzu und geben Sie dann die Bearer-Anmeldedaten in den Einstellungen des Connectors an:

Claude Tag (Slack): Binden Sie den Server als Plugin ein, dessen .mcp.json auf den Endpunkt verweist, und fügen Sie die Bearer-Anmeldedaten im Tab Credentials des Access-Bundles hinzu. Siehe Claude Tag — benutzerdefinierten MCP-Server verbinden.
Claude.ai / Desktop: Fügen Sie ihn unter Einstellungen → Connectors hinzu; siehe benutzerdefinierte Connectors.

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"}}}'

Sichtbare Tools für einen Agenten einschränken

Standardmäßig erhält eine Verbindung Zugriff auf jedes Toolkit. Um einem Agenten eine kleinere Auswahl bereitzustellen — mit weniger Kontext-/Token-Aufwand und nach dem Prinzip der geringsten Berechtigungen — fügen Sie dieser Verbindung zusätzlich zu Authorization einen Einschränkungs-Header hinzu. Die Teilmenge wird durchgesetzt: Ein Tool außerhalb des festgelegten Umfangs wird in tools/list ausgeblendet und bei einem Aufruf abgelehnt.

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 (Schreibtools werden entfernt)

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

Beispiel — ein schreibgeschützter Agent für Findings/Bilder (beliebiger Client, der Header unterstützt; hier Cursor):

{
  "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"
      }
    }
  }
}

Fügen Sie in Claude Code ein zusätzliches --header hinzu:

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 der folgenden Toolkits bereit; schränken Sie einen Client mit X-Rad-Toolkits / X-Rad-Exclude-Toolkits ein oder entfernen Sie alle Schreibtools mit X-Rad-Readonly: true.

Kontoinventar
- Cluster und deren Details auflisten
Containerinventar
- Container und deren Details auflisten
Sicherheitsbefunde
- Sicherheitsbefunde auflisten und analysieren
- Status eines Sicherheitsbefunds aktualisieren
Laufzeitsicherheit
- Prozessbäume laufender Container abrufen
- Laufzeit-Baselines laufender Container abrufen
- Prozessverhalten laufender Container analysieren
Audit
- Auflisten, wer sich in einen Pod eingeloggt hat
Images und Schwachstellen
- SBOMs abrufen
- Images und deren Schwachstellen auflisten
- Images mit den meisten Schwachstellen abrufen
- CVEs ignorieren / nicht mehr ignorieren und aktive CVE-Dispositionen auflisten
Kubernetes-Objekte
- Details einer bestimmten Kubernetes-Ressource abrufen
- Kubernetes-Ressourcen auflisten
Posteingang
- Elemente im Posteingang und deren Details auflisten
- Ein Element im Posteingang als falsch positiv markieren
Automatisierungen (workflows)
- Automatisierungen, Ausführungen und Zeitpläne auflisten
- Details zu Automatisierungen und Ausführungen abrufen
- Eine Automatisierung ausführen
- Automatisierungen erstellen und aktualisieren sowie Cron-Zeitpläne hinzufügen
„Automation“ ist der Produktname, den Benutzer sehen; „workflow“ ist das zugrunde liegende Windmill-Objekt, das von der API und den Toolnamen verwendet wird. Es handelt sich um dasselbe.
Wissensdatenbank
- Wissensdatenbank durchsuchen
- Sammlungen und Dokumente auflisten
- Strukturierte Abfragen für ein Dokument ausführen
Dashboards
- Dashboards auflisten und deren Details abrufen
- Dashboard- und Widget-Vorlagen auflisten und abrufen
- Ein Dashboard erstellen und ein vorhandenes direkt aktualisieren (ausgelassene Felder bleiben unverändert, sodass für eine kleine Änderung nicht das gesamte Dashboard erneut gesendet werden muss)
Integrationen
- Externe Integrationen auflisten
RadQL (erweiterte Abfragen)
- Verfügbare Datentypen für Abfragen auflisten (containers, findings, kubernetes_resources usw.)
- Schema/Metadaten für bestimmte Datentypen abrufen
- Mögliche Werte für Filterfelder auflisten
- RadQL-Abfragen mit Filtern, Suche und Aggregationen ausführen
- Abfragen programmgesteuert aus strukturierten Bedingungen erstellen
- Mehrere Abfragen parallel ausführen

Selbst hosten

Möchten Sie den Server lieber selbst betreiben — beispielsweise in einer air-gapped Umgebung, bei Anforderungen an den Datenstandort oder wenn Sie den gehosteten Gateway nicht nutzen möchten? Er ist auf npm und als Container-Image veröffentlicht.

Voraussetzungen

Node.js 20.x oder höher

Anmeldedaten

Stellen Sie Ihre RAD Security-Anmeldedaten über Umgebungsvariablen bereit:

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.
# Set this without RAD_SECURITY_ACCOUNT_ID for a session across all the tenant's accounts.
RAD_SECURITY_TENANT_ID="your_tenant_id"

# Optional: true exposes only read-only tools. Tenant-scoped sessions are read-only unless this is false.
RAD_SECURITY_READONLY="true"

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

Legen Sie fest, welche Toolkits ein selbst gehosteter Server bereitstellt:

INCLUDE_TOOLKITS: durch Kommas getrennte Liste der einzuschließenden Toolkits (nur diese werden aktiviert).
EXCLUDE_TOOLKITS: durch Kommas getrennte Liste der auszuschließenden Toolkits (alle anderen werden 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"

Mandantenfähig (Authentifizierung pro Anfrage)

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

MCP_AUTH_MODE=env (Standard) — jede Sitzung verwendet die Umgebungsanmeldedaten RAD_SECURITY_*. Einzelmandantig und auf HTTP-Ebene nicht authentifiziert, daher darf der Server nicht aus nicht vertrauenswürdigen Netzwerken erreichbar sein.
MCP_AUTH_MODE=header — jede Anfrage muss eigene Anmeldedaten im Header Authorization enthalten (die oben gezeigte Form Bearer <access_key_id>:<secret_key>:<account_id>); ein fehlender oder fehlerhafter Header wird mit 401 abgelehnt. Wird 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 ausschließlich 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 – Einzelheiten finden Sie in der Datei LICENSE.