RAD Security

Servidor MCP de RAD Security

Un servidor del Protocolo de Contexto de Modelo (MCP) para RAD Security, que proporciona información de seguridad basada en IA para entornos de Kubernetes y la nube.

Conectar (alojado — recomendado)

RAD Security ejecuta el servidor MCP por ti, así que la mayoría de los usuarios no necesitan instalar ni alojar nada. Configura tu cliente MCP para que use el endpoint alojado y autentícate con tus credenciales de RAD Security.

• Endpoint: https://api.rad.security/mcp/ — ten en cuenta la barra final.

• Transporte: HTTP transmisible.

• Autenticación: envía tu credencial en el encabezado Authorization:

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

  <access_key_id> y <secret_key> son una clave de acceso a la API de RAD Security (crea una en la consola de RAD Security); <account_id> es el ID de tu cuenta. El servidor autentica cada solicitud con la API de RAD Security; no se almacenan credenciales en el servidor.

También funciona una forma de corta duración Bearer ory_st_<session_token>:<account_id>, pero los tokens de sesión caducan: para cualquier uso prolongado (p. ej., Slack / Claude Tag), es preferible una clave de acceso.

Una conexión para todo un tenant

Para trabajar con todas tus cuentas desde una sola configuración de MCP, crea una clave de acceso en tu tenant y usa tenant=<tenant_id> en lugar del ID de cuenta:

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

En una sesión con ámbito de tenant:

• Una herramienta list_accounts devuelve las cuentas del tenant.
• Las herramientas con ámbito de cuenta requieren un argumento account_id, que debe ser una cuenta secundaria del tenant. Cada llamada abarca una cuenta; los resultados no se combinan entre cuentas.
• De forma predeterminada, solo están disponibles las herramientas de solo lectura, porque una credencial de tenant permite acceder a todas las cuentas. Para habilitar las herramientas de escritura, envía X-Rad-Readonly: false.

Para el servidor npx/stdio, configura RAD_SECURITY_TENANT_ID sin RAD_SECURITY_ACCOUNT_ID y usa RAD_SECURITY_READONLY=false para habilitar las herramientas de escritura.

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

O mediante la CLI, manteniendo el secreto en una variable de entorno (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 — ten en cuenta que la clave contenedora es servers, no 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 — ten en cuenta que el campo de URL es httpUrl (no 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 — ten en cuenta que type debe ser exactamente 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 — ten en cuenta que el campo de URL es serverUrl:

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

Otros clientes

La mayoría de los clientes MCP aceptan un servidor HTTP transmisible remoto con una URL y un encabezado Authorization; solo cambian los nombres de los campos. Mantén la barra final de la URL en todos los casos.

Cliente	Ubicación de la configuración	Campo de URL	Indicador de transporte	Campo del encabezado
Claude Code	claude mcp add	argumento posicional	--transport http	--header
OpenAI Codex CLI	~/.codex/config.toml	url	inferido	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	inferido	headers
Cline	cline_mcp_settings.json	url	type: "streamableHttp"	headers
Windsurf	~/.codeium/windsurf/mcp_config.json	serverUrl	inferido	headers

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

Estas interfaces añaden servidores MCP remotos como conectores, que usan sus propios ajustes de credenciales en lugar de un encabezado de solicitud sin procesar. Añade https://api.rad.security/mcp/ como conector personalizado y, luego, proporciona la credencial bearer en los ajustes del conector:

• Claude Tag (Slack): añade el servidor como un complemento cuyo .mcp.json apunta al endpoint y agrega la credencial bearer en la pestaña Credentials del paquete de acceso. Consulta Claude Tag — conectar un servidor MCP personalizado.
• Claude.ai / Desktop: añádelo en Settings → Connectors; consulta conectores personalizados.

Pruébalo (MCP Inspector o 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"}}}'

Limitar las herramientas que ve un agente

De forma predeterminada, una conexión obtiene todos los conjuntos de herramientas. Para proporcionar a un agente un conjunto más reducido —menos contexto y consumo de tokens, y privilegios mínimos—, añade un encabezado de limitación a esa conexión junto con Authorization. El subconjunto se aplica de forma estricta: las herramientas fuera del ámbito se ocultan de tools/list y se rechazan si se invocan.

Encabezado	Efecto
X-Rad-Toolkits: findings, images	solo estos conjuntos de herramientas
X-Rad-Exclude-Toolkits: workflows	todos los conjuntos de herramientas excepto estos
X-Rad-Readonly: true	solo herramientas de lectura (excluye las herramientas de escritura)

Conjuntos de herramientas: containers, clusters, audit, images, kubeobject, runtime, findings, inbox, workflows, knowledge_base, radql, dashboards, integrations. Todos están habilitados de forma predeterminada; limita el acceso con los encabezados anteriores y usa X-Rad-Readonly cuando quieras excluir todas las herramientas de escritura.

Ejemplo: un agente de solo lectura para hallazgos e imágenes (cualquier cliente que admita encabezados; se muestra 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"
      }
    }
  }
}

En Claude Code, pasa un --header adicional:

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"

Funciones

Todas las herramientas requieren autenticación y una cuenta en RAD Security. El endpoint alojado expone todos los conjuntos de herramientas siguientes de forma predeterminada; limita el acceso de un cliente con X-Rad-Toolkits / X-Rad-Exclude-Toolkits, o excluye todas las herramientas de escritura con X-Rad-Readonly: true.

• Inventario de cuentas

  • Enumerar clústeres y sus detalles

• Inventario de contenedores

  • Enumerar contenedores y sus detalles

• Hallazgos de seguridad

  • Enumerar y analizar hallazgos de seguridad
  • Actualizar el estado de un hallazgo de seguridad

• Seguridad en tiempo de ejecución

  • Obtener árboles de procesos de contenedores en ejecución
  • Obtener líneas base de tiempo de ejecución de contenedores en ejecución
  • Analizar el comportamiento de los procesos de contenedores en ejecución

• Auditoría

  • Enumerar quién abrió una shell en un pod

• Imágenes y vulnerabilidades

  • Obtener SBOM
  • Enumerar imágenes y sus vulnerabilidades
  • Obtener las imágenes más vulnerables
  • Ignorar / dejar de ignorar CVE y enumerar las disposiciones activas de CVE

• Objetos de Kubernetes

  • Obtener detalles de un recurso específico de Kubernetes
  • Enumerar recursos de Kubernetes

• Bandeja de entrada

  • Enumerar elementos de la bandeja de entrada y sus detalles
  • Marcar un elemento de la bandeja de entrada como falso positivo

• Automatizaciones (workflows)

  • Enumerar automatizaciones, ejecuciones y programaciones
  • Obtener detalles de automatizaciones y ejecuciones
  • Ejecutar una automatización
  • Crear y actualizar automatizaciones, y añadir programaciones cron

  «Automation» es el nombre del producto que ven los usuarios; «workflow» es el objeto subyacente de Windmill que usan los nombres de la API y las herramientas. Son lo mismo.

• Base de conocimientos

  • Buscar en la base de conocimientos
  • Enumerar colecciones y documentos
  • Ejecutar consultas estructuradas en un documento

• Paneles

  • Enumerar paneles y obtener sus detalles
  • Enumerar y obtener plantillas de paneles y widgets
  • Crear un panel y actualizar uno existente (los campos omitidos no cambian, por lo que una edición pequeña no requiere volver a enviar el panel completo)

• Integraciones

  • Enumerar integraciones externas

• RadQL (consultas avanzadas)

  • Enumerar los tipos de datos disponibles para consultas (containers, findings, kubernetes_resources, etc.)
  • Obtener el esquema y los metadatos de tipos de datos específicos
  • Enumerar los valores posibles de los campos de filtro
  • Ejecutar consultas RadQL con filtrado, búsqueda y agregaciones
  • Crear consultas mediante programación a partir de condiciones estructuradas
  • Ejecutar varias consultas en paralelo

Alojamiento propio

¿Prefieres ejecutar el servidor por tu cuenta —por ejemplo, en un entorno aislado, por requisitos de residencia de datos o porque no quieres pasar por la puerta de enlace alojada? Está publicado en npm y como imagen de contenedor.

Requisitos previos

• Node.js 20.x o superior

Credenciales

Proporciona tus credenciales de RAD Security mediante variables de entorno:

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) — p. ej., 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 transmisible)

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

Filtrado de conjuntos de herramientas

Controla qué conjuntos de herramientas expone un servidor alojado por tu cuenta:

• INCLUDE_TOOLKITS: lista de conjuntos de herramientas separados por comas que se incluirán (solo estos estarán habilitados).
• EXCLUDE_TOOLKITS: lista de conjuntos de herramientas separados por comas que se excluirán (todos los demás estarán habilitados). Se ignora si se establece INCLUDE_TOOLKITS.

Conjuntos de herramientas disponibles: containers, clusters, audit, images, kubeobject, runtime, findings, inbox, workflows, knowledge_base, radql, dashboards, integrations. Todos están habilitados de forma predeterminada.

# Only the workflows toolkit
INCLUDE_TOOLKITS="workflows"

# Everything except runtime
EXCLUDE_TOOLKITS="runtime"

Multiinquilino (autenticación por solicitud)

MCP_AUTH_MODE controla cómo una implementación HTTP transmisible autentica las solicitudes entrantes; es el modo que usa el endpoint alojado:

• MCP_AUTH_MODE=env (predeterminado): todas las sesiones usan las credenciales de entorno RAD_SECURITY_*. Es de un solo tenant y no está autenticado en la capa HTTP, por lo que no debe ser accesible desde redes no confiables.
• MCP_AUTH_MODE=header: cada solicitud debe incluir su propia credencial en el encabezado Authorization (el formato Bearer <access_key_id>:<secret_key>:<account_id> anterior); si el encabezado falta o tiene un formato incorrecto, se rechaza con 401. Solo se admite con TRANSPORT_TYPE=streamable. RAD_SECURITY_API_URL se obtiene de la configuración del servidor, no de quien realiza la llamada.

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

El transporte SSE (TRANSPORT_TYPE=sse) está obsoleto y se recomienda usar HTTP transmisible; solo utiliza credenciales de entorno.

Desarrollo

# Install dependencies
npm install

# Run type checking
npm run type-check

# Run linter
npm run lint

# Build
npm run build

Licencia

Licencia MIT: consulta el archivo LICENSE para obtener más información.