RAD Security

Serveur MCP RAD Security

Un serveur Model Context Protocol (MCP) pour RAD Security, qui fournit des informations de sécurité optimisées par l’IA pour les environnements Kubernetes et cloud.

Connexion (hébergée — recommandée)

RAD Security exécute le serveur MCP pour vous : la plupart des utilisateurs n’ont donc rien à installer ni à héberger. Configurez votre client MCP pour utiliser 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 finale.

• Transport : HTTP avec flux.

• 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 à l’API RAD Security (créez-en une dans la console RAD Security) ; <account_id> est l’identifiant de votre compte. Le serveur authentifie chaque requête auprès de l’API RAD Security : aucun identifiant n’est stocké côté serveur.

Une forme Bearer ory_st_<session_token>:<account_id> à courte durée de vie fonctionne également, mais les jetons de session expirent : préférez une clé d’accès pour tout usage de longue durée (par exemple Slack / Claude Tag).

Une connexion pour tout un tenant

Pour accéder à tous vos comptes depuis une seule configuration MCP, créez une clé d’accès sur votre tenant et utilisez tenant=<tenant_id> à la place de l’identifiant du compte :

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

Dans une session limitée au tenant :

• Un outil list_accounts renvoie les comptes du tenant.
• Les outils limités à un compte nécessitent un argument account_id, qui doit correspondre à un compte enfant du tenant. Chaque appel porte sur un seul compte ; les résultats ne sont pas regroupés entre les comptes.
• Seuls les outils en lecture seule sont disponibles par défaut, car un identifiant de tenant donne accès à tous les comptes. Pour activer les outils d’écriture, envoyez X-Rad-Readonly: false.

Pour le serveur npx/stdio, définissez RAD_SECURITY_TENANT_ID sans RAD_SECURITY_ACCOUNT_ID, et utilisez RAD_SECURITY_READONLY=false pour activer les outils d’écriture.

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é d’enveloppe est servers, et non 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 (et non 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 avec flux distant, une URL et un en-tête Authorization — seuls les noms des champs diffèrent. Conservez la barre oblique finale de l’URL dans tous les cas.

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

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

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

• Claude Tag (Slack) : ajoutez le serveur comme plug-in dont .mcp.json pointe vers le point de terminaison, puis ajoutez l’identifiant bearer dans l’onglet Credentials du bundle Access. Consultez Claude Tag — connecter un serveur MCP personnalisé.
• Claude.ai / Desktop : ajoutez-le sous Settings → Connectors ; consultez connecteurs personnalisés.

Le tester (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"}}}'

Définir la portée des outils visibles par un agent

Par défaut, une connexion donne accès à tous les toolkits. Pour fournir à un agent un ensemble plus restreint — moins de contexte et de surcharge liée aux jetons, et le principe du moindre privilège — ajoutez un en-tête de portée à cette connexion, en plus de Authorization. Le sous-ensemble est appliqué : un outil hors portée est masqué dans tools/list et son appel est rejeté.

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

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

Exemple — un agent en lecture seule pour les résultats et les images (tout client prenant en charge les en-têtes ; exemple avec 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"
      }
    }
  }
}

Dans Claude Code, transmettez 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 RAD Security. Le point de terminaison hébergé expose par défaut tous les toolkits ci-dessous ; réduisez la portée d’un client avec X-Rad-Toolkits / X-Rad-Exclude-Toolkits, ou excluez 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é à l’exécution

  • Obtenir les arbres de processus des conteneurs en cours d’exécution
  • Obtenir les références de comportement à l’exécution des conteneurs en cours d’exécution
  • Analyser le comportement des processus des conteneurs en cours d’exécution

• Audit

  • Lister les utilisateurs qui ont ouvert un shell dans 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 / rétablir l’ignorance des CVE et lister les décisions actives concernant les CVE

• 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

  « Automation » est le nom du produit visible par les utilisateurs ; « workflow » est l’objet Windmill sous-jacent utilisé par l’API et les noms des outils. Il s’agit de 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 ; une modification mineure ne nécessite donc 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 (containers, findings, kubernetes_resources, etc.)
  • Obtenir le schéma et les métadonnées de types de données spécifiques
  • Lister les valeurs possibles des 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

Hébergement autonome

Vous préférez exécuter le serveur vous-même — par exemple dans un environnement isolé, pour répondre à des exigences de résidence des données ou pour éviter de passer par la passerelle hébergée ? Il est publié sur npm et sous forme d’image de conteneur.

Prérequis

• Node.js 20.x ou version ultérieure

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.
# 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) — 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 avec flux)

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 exposés par un serveur hébergé de manière autonome :

• INCLUDE_TOOLKITS : liste de toolkits séparés par des virgules à inclure (seuls ceux-ci sont activés).
• EXCLUDE_TOOLKITS : liste de toolkits séparés par des virgules à 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-tenant (authentification par requête)

MCP_AUTH_MODE contrôle la manière dont un déploiement HTTP avec flux authentifie les requêtes entrantes — c’est le mode utilisé par le point de terminaison hébergé :

• MCP_AUTH_MODE=env (par défaut) — chaque session utilise les identifiants d’environnement RAD_SECURITY_*. Mode mono-tenant et sans authentification au niveau HTTP : le serveur ne doit donc pas être accessible depuis des réseaux non fiables.
• MCP_AUTH_MODE=header — chaque requête doit inclure son propre identifiant dans l’en-tête Authorization (la forme Bearer <access_key_id>:<secret_key>:<account_id> ci-dessus) ; un en-tête manquant ou mal formé est rejeté avec 401. Pris en charge uniquement avec TRANSPORT_TYPE=streamable. RAD_SECURITY_API_URL provient de la configuration du serveur, et non 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 et remplacé par HTTP avec flux ; il 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 - consultez le fichier LICENSE pour plus de détails