RAD Security

Serveur MCP RAD Security

Un serveur Model Context Protocol (MCP) pour RAD Security, offrant des informations de sécurité basées sur l'IA pour les environnements Kubernetes et cloud.

Connexion (hébergé — recommandé)

RAD Security exécute le serveur MCP pour vous, donc la plupart des utilisateurs n'ont pas besoin d'installer ou d'héberger quoi que ce soit. Pointez votre client MCP vers le point de terminaison hébergé et authentifiez-vous avec vos identifiants RAD Security.

• Point de terminaison : https://api.rad.security/mcp/ — notez la barre oblique de fin.

• Transport : HTTP streamable.

• Authentification : envoyez votre identifiant dans l'en-tête Authorization :

  Authorization: Bearer <access_key_id>:<secret_key>:<account_id>
  

  <access_key_id> et <secret_key> sont une clé d'accès API RAD Security (créez-en une dans la console RAD Security) ; <account_id> est votre ID de compte. Le serveur authentifie chaque requête auprès de l'API RAD Security — aucun identifiant n'est stocké côté serveur.

Un formulaire de courte durée Bearer ory_st_<session_token>:<account_id> fonctionne également, mais les jetons de session expirent — préférez une clé d'accès pour tout ce qui est de longue durée (par exemple 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>" }

Ou via la CLI, en conservant le secret dans une variable d'environnement (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 — notez que la clé wrapper est servers, pas 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 — notez que le champ URL est httpUrl (pas 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 — notez que type doit être exactement streamableHttp (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 — notez que le champ URL est serverUrl :

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

Autres clients

La plupart des clients MCP acceptent un serveur HTTP streamable distant avec une URL et un en-tête Authorization — seuls les noms de champs diffèrent. Conservez la barre oblique de fin sur l'URL dans tous les cas.

Client	Emplacement de la configuration	Champ URL	Marqueur de transport	Champ d'en-tête
Claude Code	claude mcp add	argument positionnel	--transport http	--header
OpenAI Codex CLI	~/.codex/config.toml	url	inféré	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	inféré	headers
Cline	cline_mcp_settings.json	url	type: "streamableHttp"	headers
Windsurf	~/.codeium/windsurf/mcp_config.json	serverUrl	inféré	headers

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

Ces surfaces ajoutent des serveurs MCP distants en tant que connecteurs, qui utilisent leurs propres paramètres d'identifiants plutôt qu'un en-tête de requête brut. Ajoutez https://api.rad.security/mcp/ en tant que connecteur personnalisé, puis fournissez l'identifiant bearer via les paramètres du connecteur :

• Claude Tag (Slack) : attachez le serveur en tant que plugin dont l'.mcp.json pointe vers le point de terminaison, et ajoutez l'identifiant bearer dans l'onglet Identifiants du bundle d'accès. Voir Claude Tag — connecter un serveur MCP personnalisé.
• Claude.ai / Desktop : ajoutez-le sous Paramètres → Connecteurs ; voir connecteurs personnalisés.

Testez-le (MCP Inspector ou 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"}}}'

Limiter les outils qu'un agent voit

Par défaut, une connexion reçoit l'ensemble complet des outils. Pour donner à un agent un ensemble plus restreint — moins de surcharge de contexte/jetons, et moindre privilège — ajoutez un en-tête de limitation à cette connexion en plus de Authorization. Le sous-ensemble est appliqué : un outil hors périmètre est masqué de tools/list et rejeté s'il est appelé.

En-tête	Effet
X-Rad-Toolkits: findings, images	seulement ces toolkits
X-Rad-Exclude-Toolkits: workflows	tous les toolkits sauf ceux-ci
X-Rad-Readonly: true	seulement les outils en lecture seule (supprime les outils d'écriture)

Toolkits : containers, clusters, audit, images, kubeobject, runtime, findings, inbox, workflows, knowledge_base, radql, dashboards, integrations. Tous sont activés par défaut — réduisez avec les en-têtes ci-dessus, et utilisez X-Rad-Readonly lorsque vous souhaitez exclure tous les outils d'écriture.

Exemple — un agent en lecture seule pour les résultats/images (tout client prenant en charge les en-têtes ; Cursor illustré) :

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

Dans Claude Code, passez un --header supplémentaire :

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"

Fonctionnalités

Tous les outils nécessitent une authentification et un compte dans RAD Security. Le point de terminaison hébergé expose chaque toolkit ci-dessous par défaut ; limitez un client avec X-Rad-Toolkits / X-Rad-Exclude-Toolkits, ou supprimez tous les outils d'écriture avec X-Rad-Readonly: true.

• Inventaire des comptes

  • Lister les clusters et leurs détails

• Inventaire des conteneurs

  • Lister les conteneurs et leurs détails

• Résultats de sécurité

  • Lister et analyser les résultats de sécurité
  • Mettre à jour le statut d'un résultat de sécurité

• Sécurité d'exécution

  • Obtenir les arbres de processus des conteneurs en cours d'exécution
  • Obtenir les bases de référence d'exécution des conteneurs en cours d'exécution
  • Analyser le comportement des processus des conteneurs en cours d'exécution

• Audit

  • Lister qui s'est connecté à un pod

• Images et vulnérabilités

  • Obtenir les SBOM
  • Lister les images et leurs vulnérabilités
  • Obtenir les images les plus vulnérables
  • Ignorer / ne plus ignorer les CVE et lister les dispositions CVE actives

• Objets Kubernetes

  • Obtenir les détails d'une ressource Kubernetes spécifique
  • Lister les ressources Kubernetes

• Boîte de réception

  • Lister les éléments de la boîte de réception et leurs détails
  • Marquer un élément de la boîte de réception comme faux positif

• Automatisations (workflows)

  • Lister les automatisations, les exécutions et les planifications
  • Obtenir les détails d'une automatisation et d'une exécution
  • Exécuter une automatisation
  • Créer et mettre à jour des automatisations, et ajouter des planifications cron

  "Automatisation" est le nom du produit que les utilisateurs voient ; "workflow" est l'objet Windmill sous-jacent auquel l'API et les noms d'outils font référence. C'est la même chose.

• Base de connaissances

  • Rechercher dans la base de connaissances
  • Lister les collections et les documents
  • Exécuter des requêtes structurées sur un document

• Tableaux de bord

  • Lister les tableaux de bord et obtenir leurs détails
  • Lister et obtenir les modèles de tableaux de bord et de widgets
  • Créer un tableau de bord et en mettre un à jour sur place (les champs omis restent inchangés, donc une petite modification ne nécessite pas de renvoyer l'intégralité du tableau de bord)

• Intégrations

  • Lister les intégrations externes

• RadQL (Requêtes avancées)

  • Lister les types de données disponibles pour les requêtes (conteneurs, résultats, kubernetes_resources, etc.)
  • Obtenir le schéma/les métadonnées pour des types de données spécifiques
  • Lister les valeurs possibles pour les champs de filtre
  • Exécuter des requêtes RadQL avec filtrage, recherche et agrégations
  • Construire des requêtes par programmation à partir de conditions structurées
  • Exécuter plusieurs requêtes en parallèle

Auto-hébergement

Vous préférez exécuter le serveur vous-même — par exemple un environnement isolé, des exigences de résidence des données, ou si vous ne souhaitez pas passer par la passerelle hébergée ? Il est publié sur npm et en tant qu'image conteneur.

Prérequis

• Node.js 20.x ou supérieur

Identifiants

Fournissez vos identifiants RAD Security via des variables d'environnement :

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) — par exemple 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 (HTTP streamable)

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

Filtrage des toolkits

Contrôlez les toolkits qu'un serveur auto-hébergé expose :

• INCLUDE_TOOLKITS : liste séparée par des virgules des toolkits à inclure (seulement ceux-ci sont activés).
• EXCLUDE_TOOLKITS : liste séparée par des virgules des toolkits à exclure (tous les autres sont activés). Ignoré si INCLUDE_TOOLKITS est défini.

Toolkits disponibles : containers, clusters, audit, images, kubeobject, runtime, findings, inbox, workflows, knowledge_base, radql, dashboards, integrations. Tous sont activés par défaut.

# Only the workflows toolkit
INCLUDE_TOOLKITS="workflows"

# Everything except runtime
EXCLUDE_TOOLKITS="runtime"

Multi-locataire (authentification par requête)

MCP_AUTH_MODE contrôle comment un déploiement HTTP streamable authentifie les requêtes entrantes — c'est ce qu'utilise le point de terminaison hébergé :

• MCP_AUTH_MODE=env (par défaut) — chaque session utilise les identifiants d'environnement RAD_SECURITY_*. Mono-locataire, et non authentifié au niveau de la couche HTTP, donc il ne doit pas être accessible depuis des réseaux non fiables.
• MCP_AUTH_MODE=header — chaque requête doit porter son propre identifiant dans l'en-tête Authorization (le formulaire Bearer <access_key_id>:<secret_key>:<account_id> ci-dessus) ; un en-tête manquant ou mal formé est rejeté avec 401. Uniquement pris en charge avec TRANSPORT_TYPE=streamable. RAD_SECURITY_API_URL est tiré de la configuration du serveur, pas de l'appelant.

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

Le transport SSE (TRANSPORT_TYPE=sse) est obsolète au profit du HTTP streamable et utilise uniquement les identifiants d'environnement.

Développement

# Install dependencies
npm install

# Run type checking
npm run type-check

# Run linter
npm run lint

# Build
npm run build

Licence

Licence MIT — voir le fichier LICENSE pour plus de détails