RAD Security

oficial

Interaja com a plataforma RAD Security, que oferece insights de segurança baseados em IA para ambientes Kubernetes e em nuvem.

GitHub

O que você pode fazer com RAD Security MCP?

Listar descobertas de segurança — Peça ao seu assistente para listar e analisar descobertas de segurança em seus ambientes Kubernetes e de nuvem.
Investigar comportamento em tempo de execução — Obtenha árvores de processos, baselines de tempo de execução e análise de comportamento de processos para contêineres em execução.
Consultar imagens e vulnerabilidades — Recupere SBOMs, liste as imagens mais vulneráveis e gerencie disposições de CVE, como ignorar ou reativar CVEs.
Gerenciar automações — Liste, crie, atualize e execute automações (fluxos de trabalho) com agendamentos cron diretamente do chat.
Pesquisar a base de conhecimento — Pesquise coleções e documentos, e execute consultas estruturadas em documentos específicos.
Executar consultas RadQL — Execute consultas avançadas com filtragem, pesquisa e agregações em tipos de dados como contêineres e descobertas.

Documentação

Servidor MCP RAD Security

Um servidor Model Context Protocol (MCP) para RAD Security, fornecendo insights de segurança com IA para ambientes Kubernetes e nuvem.

Conectar (hospedado — recomendado)

A RAD Security executa o servidor MCP para você, então a maioria dos usuários não precisa instalar ou hospedar nada. Aponte seu cliente MCP para o endpoint hospedado e autentique-se com suas credenciais da RAD Security.

Endpoint: https://api.rad.security/mcp/ — observe a barra final.
Transporte: Streamable HTTP.
Autenticação: envie sua credencial no cabeçalho Authorization:
```
Authorization: Bearer <access_key_id>:<secret_key>:<account_id>
```
<access_key_id> e <secret_key> são uma chave de acesso à API da RAD Security (crie uma no console da RAD Security); <account_id> é o seu ID de conta. O servidor autentica cada solicitação contra a API da RAD Security — nenhuma credencial é armazenada no servidor.

Uma forma de curta duração Bearer ory_st_<session_token>:<account_id> também funciona, mas os tokens de sessão expiram — prefira uma chave de acesso para qualquer coisa de longa duração (ex.: 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 CLI, mantendo o segredo em uma variável de ambiente (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 — observe que a chave do wrapper é servers, não 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 — observe que o campo de URL é httpUrl (não 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 — observe que type deve ser exatamente 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 — observe que o campo de URL é serverUrl:

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

Outros clientes

A maioria dos clientes MCP aceita um servidor Streamable HTTP remoto com uma URL e um cabeçalho Authorization — apenas os nomes dos campos diferem. Mantenha a barra final na URL em todos os casos.

Cliente	Local de configuração	Campo de URL	Marcador de transporte	Campo de cabeçalho
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)

Essas superfícies adicionam servidores MCP remotos como conectores, que usam suas próprias configurações de credenciais em vez de um cabeçalho de solicitação bruto. Adicione https://api.rad.security/mcp/ como um conector personalizado e forneça a credencial de portador através das configurações do conector:

Claude Tag (Slack): anexe o servidor como um plugin cujo .mcp.json aponta para o endpoint e adicione a credencial de portador na guia Credenciais do pacote de acesso. Veja Claude Tag — conectar um servidor MCP personalizado.
Claude.ai / Desktop: adicione-o em Configurações → Conectores; veja conectores personalizados.

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

Escopo das ferramentas que um agente vê

Por padrão, uma conexão recebe todos os kits de ferramentas. Para dar a um agente um conjunto menor — menos sobrecarga de contexto/token e privilégio mínimo — adicione um cabeçalho de escopo a essa conexão junto com Authorization. O subconjunto é aplicado: uma ferramenta fora do escopo fica oculta de tools/list e é rejeitada se for chamada.

Cabeçalho	Efeito
`X-Rad-Toolkits: findings, images`	apenas esses kits de ferramentas
`X-Rad-Exclude-Toolkits: workflows`	todos os kits de ferramentas exceto estes
`X-Rad-Readonly: true`	apenas ferramentas somente leitura (remove as ferramentas de escrita)

Kits de ferramentas: containers, clusters, audit, images, kubeobject, runtime, findings, inbox, workflows, knowledge_base, radql, dashboards, integrations. Todos estão habilitados por padrão — restrinja com os cabeçalhos acima e use X-Rad-Readonly quando quiser excluir todas as ferramentas de escrita.

Exemplo — um agente somente leitura de descobertas/imagens (qualquer cliente que suporte cabeçalhos; Cursor mostrado):

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

No Claude Code, passe um --header extra:

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"

Recursos

Todas as ferramentas exigem autenticação e uma conta na RAD Security. O endpoint hospedado expõe todos os kits de ferramentas abaixo por padrão; restrinja um cliente com X-Rad-Toolkits / X-Rad-Exclude-Toolkits, ou remova todas as ferramentas de escrita com X-Rad-Readonly: true.

Inventário de Contas
- Listar clusters e seus detalhes
Inventário de Contêineres
- Listar contêineres e seus detalhes
Descobertas de Segurança
- Listar e analisar descobertas de segurança
- Atualizar o status de uma descoberta de segurança
Segurança em Tempo de Execução
- Obter árvores de processos de contêineres em execução
- Obter linhas de base de tempo de execução de contêineres em execução
- Analisar o comportamento de processos de contêineres em execução
Auditoria
- Listar quem acessou um pod via shell
Imagens e Vulnerabilidades
- Obter SBOMs
- Listar imagens e suas vulnerabilidades
- Obter as imagens mais vulneráveis
- Ignorar / desconsiderar CVEs e listar disposições ativas de CVE
Objetos Kubernetes
- Obter detalhes de um recurso Kubernetes específico
- Listar recursos Kubernetes
Caixa de entrada
- Listar itens da caixa de entrada e seus detalhes
- Marcar um item da caixa de entrada como falso positivo
Automações (workflows)
- Listar automações, execuções e agendamentos
- Obter detalhes de automação e execução
- Executar uma automação
- Criar e atualizar automações e adicionar agendamentos cron
"Automação" é o nome do produto que os usuários veem; "workflow" é o objeto Windmill subjacente que a API e os nomes das ferramentas usam. Eles são a mesma coisa.
Base de Conhecimento
- Pesquisar na base de conhecimento
- Listar coleções e documentos
- Executar consultas estruturadas em um documento
Painéis
- Listar painéis e obter seus detalhes
- Listar e obter modelos de painéis e widgets
- Criar um painel e atualizar um no local (campos omitidos permanecem inalterados, então uma pequena edição não exige reenviar o painel inteiro)
Integrações
- Listar integrações externas
RadQL (Consultas Avançadas)
- Listar tipos de dados disponíveis para consulta (containers, findings, kubernetes_resources, etc.)
- Obter esquema/metadados para tipos de dados específicos
- Listar valores possíveis para campos de filtro
- Executar consultas RadQL com filtragem, pesquisa e agregações
- Construir consultas programaticamente a partir de condições estruturadas
- Executar múltiplas consultas em paralelo

Auto-hospedagem

Prefere executar o servidor você mesmo — por exemplo, um ambiente isolado, requisitos de residência de dados, ou se você não quiser rotear pelo gateway hospedado? Ele é publicado no npm e como uma imagem de contêiner.

Pré-requisitos

Node.js 20.x ou superior

Credenciais

Forneça suas credenciais da RAD Security por meio de variáveis de ambiente:

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) — ex.: 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

Filtragem de kits de ferramentas

Controle quais kits de ferramentas um servidor auto-hospedado expõe:

INCLUDE_TOOLKITS: lista separada por vírgulas de kits de ferramentas a incluir (apenas estes são habilitados).
EXCLUDE_TOOLKITS: lista separada por vírgulas de kits de ferramentas a excluir (todos os outros são habilitados). Ignorado se INCLUDE_TOOLKITS estiver definido.

Kits de ferramentas disponíveis: containers, clusters, audit, images, kubeobject, runtime, findings, inbox, workflows, knowledge_base, radql, dashboards, integrations. Todos estão habilitados por padrão.

# Only the workflows toolkit
INCLUDE_TOOLKITS="workflows"

# Everything except runtime
EXCLUDE_TOOLKITS="runtime"

Multi-tenant (autenticação por solicitação)

MCP_AUTH_MODE controla como uma implantação HTTP transmissível autentica solicitações recebidas — é isso que o endpoint hospedado usa:

MCP_AUTH_MODE=env (padrão) — cada sessão usa as credenciais de ambiente RAD_SECURITY_*. Single-tenant e não autenticado na camada HTTP, portanto não deve ser acessível a partir de redes não confiáveis.
MCP_AUTH_MODE=header — cada solicitação deve conter sua própria credencial no cabeçalho Authorization (o formulário Bearer <access_key_id>:<secret_key>:<account_id> acima); um cabeçalho ausente ou malformado é rejeitado com 401. Suportado apenas com TRANSPORT_TYPE=streamable. RAD_SECURITY_API_URL é obtido da configuração do servidor, não do chamador.

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

O transporte SSE (TRANSPORT_TYPE=sse) está obsoleto em favor do Streamable HTTP e usa apenas credenciais de ambiente.

Desenvolvimento

# Install dependencies
npm install

# Run type checking
npm run type-check

# Run linter
npm run lint

# Build
npm run build

Licença

Licença MIT - veja o arquivo LICENSE para detalhes