RAD Security

by MCP-Mirror

284 downloads

Not rated

GitHub

About

Interact with the RAD Security platform which provides AI-powered security insights for Kubernetes and cloud environments.

Details

Author: MCP-Mirror
Downloads: 284
Categories: Cloud Service, Other, Infrastructure, Security, AI, Developer Tools

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name RAD Security

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "rad security": {
            "rad-security_mcp-server": {
                "command": "docker",
                "args": [
                    "build",
                    "-t",
                    "rad-security/mcp-server",
                    "."
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "rad security": {
            "rad-security_mcp-server": {
                "command": "docker",
                "args": [
                    "build",
                    "-t",
                    "rad-security/mcp-server",
                    "."
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "rad security": {
            "rad-security_mcp-server": {
                "command": "docker",
                "args": [
                    "build",
                    "-t",
                    "rad-security/mcp-server",
                    "."
                ]
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "rad security": {
            "rad-security_mcp-server": {
                "command": "docker",
                "args": [
                    "build",
                    "-t",
                    "rad-security/mcp-server",
                    "."
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "rad security": {
            "rad-security_mcp-server": {
                "command": "docker",
                "args": [
                    "build",
                    "-t",
                    "rad-security/mcp-server",
                    "."
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "rad security": {
            "rad-security_mcp-server": {
                "command": "docker",
                "args": [
                    "build",
                    "-t",
                    "rad-security/mcp-server",
                    "."
                ]
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "rad security": {
            "rad-security_mcp-server": {
                "command": "docker",
                "args": [
                    "build",
                    "-t",
                    "rad-security/mcp-server",
                    "."
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "rad security": {
            "rad-security_mcp-server": {
                "command": "docker",
                "args": [
                    "build",
                    "-t",
                    "rad-security/mcp-server",
                    "."
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "rad security": {
            "rad-security_mcp-server": {
                "command": "docker",
                "args": [
                    "build",
                    "-t",
                    "rad-security/mcp-server",
                    "."
                ]
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "rad security": {
            "rad-security_mcp-server": {
                "command": "docker",
                "args": [
                    "build",
                    "-t",
                    "rad-security/mcp-server",
                    "."
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "rad security": {
            "rad-security_mcp-server": {
                "command": "docker",
                "args": [
                    "build",
                    "-t",
                    "rad-security/mcp-server",
                    "."
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "rad security": {
            "rad-security_mcp-server": {
                "command": "docker",
                "args": [
                    "build",
                    "-t",
                    "rad-security/mcp-server",
                    "."
                ]
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "rad security": {
            "rad-security_mcp-server": {
                "command": "docker",
                "args": [
                    "build",
                    "-t",
                    "rad-security/mcp-server",
                    "."
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "rad security": {
            "rad-security_mcp-server": {
                "command": "docker",
                "args": [
                    "build",
                    "-t",
                    "rad-security/mcp-server",
                    "."
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "rad security": {
            "rad-security_mcp-server": {
                "command": "docker",
                "args": [
                    "build",
                    "-t",
                    "rad-security/mcp-server",
                    "."
                ]
            }
        }
    }
}

From the repository

Install via npm: npm install @rad-security/mcp-server. Requires Node.js 20.x or higher. Set three environment variables (RAD_SECURITY_ACCESS_KEY_ID, RAD_SECURITY_SECRET_KEY, RAD_SECURITY_ACCOUNT_ID) for full functionality. The server can be run directly, configured in Cursor IDE or Claude Desktop, or deployed as a Docker container using either Streamable HTTP (recommended) or SSE (deprecated) transport.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "rad security": {
            "rad-security_mcp-server": {
                "command": "docker",
                "args": [
                    "build",
                    "-t",
                    "rad-security/mcp-server",
                    "."
                ]
            }
        }
    }
}

McpServers

{
    "rad-security_mcp-server": {
        "command": "docker",
        "args": [
            "build",
            "-t",
            "rad-security/mcp-server",
            "."
        ]
    }
}

- List security findings— Ask your assistant to list and analyze security findings across your Kubernetes and cloud environments.
- Investigate runtime behavior— Get process trees, runtime baselines, and process behavior analysis for running containers.
- Query images and vulnerabilities— Retrieve SBOMs, list top vulnerable images, and manage CVE dispositions like ignoring or unignoring CVEs.
- Manage automations— List, create, update, and run automations (workflows) with cron schedules directly from chat.
- Search the knowledge base— Search collections and documents, and run structured queries against specific documents.
- Execute RadQL queries— Run advanced queries with filtering, searching, and aggregations across data types like containers and findings.

A Model Context Protocol (MCP) server for RAD Security, providing AI-powered security insights for Kubernetes and cloud environments.

RAD Security runs the MCP server for you, so most users don't need to install or host anything. Point your MCP client at the hosted endpoint and authenticate with your RAD Security credentials.

Endpoint:https://api.rad.security/mcp/— note thetrailing slash.

Authentication:send your credential in theAuthorizationheader:

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

<access_key_id>and<secret_key>are a RAD Security API access key (create one in the RAD Security console);<account_id>is your account ID. The server authenticates every request against the RAD Security API — no credentials are stored server-side.

A short-lived formBearer ory_st_<session_token>:<account_id>also works, but session tokens expire — prefer an access key for anything long-lived (e.g. Slack / Claude Tag).

claude mcp add --transport http rad-security https://api.rad.security/mcp/ \ --header "Authorization: Bearer <access_key_id>:<secret_key>:<account_id>"

[mcp_servers.rad-security] url = "https://api.rad.security/mcp/" http_headers = { "Authorization" = "Bearer <access_key_id>:<secret_key>:<account_id>" }

Or via the CLI, keeping the secret in an env var (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

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

.vscode/mcp.json— note the wrapper key isservers, notmcpServers:

{ "servers": { "rad-security": { "type": "http", "url": "https://api.rad.security/mcp/", "headers": { "Authorization": "Bearer <access_key_id>:<secret_key>:<account_id>" } } } }

~/.gemini/settings.json— note the URL field ishttpUrl(noturl):

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

cline_mcp_settings.json— notetypemust be exactlystreamableHttp(camelCase):

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

~/.codeium/windsurf/mcp_config.json— note the URL field isserverUrl:

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

Most MCP clients accept a remote Streamable HTTP server with a URL and anAuthorizationheader — only the field names differ. Keep thetrailing slashon the URL in every case.

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

These surfaces add remote MCP servers asconnectors, which use their own credential settings rather than a raw request header. Addhttps://api.rad.security/mcp/as a custom connector, then supply the bearer credential through the connector's settings:

- Claude Tag (Slack):attach the server as a plugin whose.mcp.jsonpoints at the endpoint, and add the bearer credential on the Access bundle'sCredentialstab. SeeClaude Tag — connect a custom MCP server.
- Claude.ai / Desktop:add it under Settings → Connectors; see custom connectors.

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

By default a connection gets every toolkit. To give an agent a smaller set — less context/token overhead, and least privilege — add a scoping header to that connection alongsideAuthorization. The subset is enforced: an out-of-scope tool is hidden fromtools/listandrejected if called.

Toolkits:containers,clusters,audit,images,kubeobject,runtime,findings,inbox,workflows,knowledge_base,radql,dashboards,integrations. All are enabled by default — narrow with the headers above, and useX-Rad-Readonlywhen you want to exclude every write tool.

Example — a read-only findings/images agent (any client that supports headers; Cursor shown):

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

In Claude Code, pass an extra--header:

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"

All tools require authentication and an account in RAD Security. The hosted endpoint exposes every toolkit below by default; scope a client down withX-Rad-Toolkits/X-Rad-Exclude-Toolkits, or drop all write tools withX-Rad-Readonly: true.

- List and analyze security findings
- Update the status of a security finding

- Get process trees of running containers
- Get runtime baselines of running containers
- Analyze process behavior of running containers

- Get SBOMs
- List images and their vulnerabilities
- Get top vulnerable images
- Ignore / unignore CVEs and list active CVE dispositions

- Get details of a specific Kubernetes resource
- List Kubernetes resources

- List inbox items and their details
- Mark an inbox item as a false positive

- List automations, runs and schedules
- Get automation and run details
- Run an automation
- Create and update automations, and add cron schedules

"Automation" is the product name users see; "workflow" is the underlying Windmill object the API and tool names use. They are the same thing.

- Search the knowledge base
- List collections and documents
- Run structured queries against a document

- List dashboards and get their details
- List and get dashboard and widget templates
- Create a dashboard, and update one in place (omitted fields are left unchanged, so a small edit does not require resending the whole dashboard)

- List available data types for querying (containers, findings, kubernetes_resources, etc.)
- Get schema/metadata for specific data types
- List possible values for filter fields
- Execute RadQL queries with filtering, searching, and aggregations
- Build queries programmatically from structured conditions
- Execute multiple queries in parallel

Prefer to run the server yourself — for example an air-gapped environment, data-residency requirements, or if you don't want to route through the hosted gateway? It's published to npm and as a container image.

Provide your RAD Security credentials via environment variables:

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"

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

Control which toolkits a self-hosted server exposes:

- INCLUDE_TOOLKITS: comma-separated list of toolkits to include (only these are enabled).
- EXCLUDE_TOOLKITS: comma-separated list of toolkits to exclude (all others are enabled). Ignored ifINCLUDE_TOOLKITSis set.

Available toolkits:containers,clusters,audit,images,kubeobject,runtime,findings,inbox,workflows,knowledge_base,radql,dashboards,integrations. All are enabled by default.

# Only the workflows toolkit INCLUDE_TOOLKITS="workflows" # Everything except runtime EXCLUDE_TOOLKITS="runtime"

MCP_AUTH_MODEcontrols how a streamable HTTP deployment authenticates inbound requests — this is what the hosted endpoint uses:

- MCP_AUTH_MODE=env(default) — every session uses theRAD_SECURITY_*environment credentials. Single-tenant, andunauthenticated at the HTTP layer, so it must not be reachable from untrusted networks.
- MCP_AUTH_MODE=header— every request must carry its own credential in theAuthorizationheader (theBearer <access_key_id>:<secret_key>:<account_id>form above); a missing or malformed header is rejected with401. Only supported withTRANSPORT_TYPE=streamable.RAD_SECURITY_API_URLis taken from server config, not the caller.

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

The SSE transport (TRANSPORT_TYPE=sse) is deprecated in favor of Streamable HTTP and uses env credentials only.

# Install dependencies npm install # Run type checking npm run type-check # Run linter npm run lint # Build npm run build

MIT License - see theLICENSEfile for details

AI health, token usage, LLM cost optimization, BYOK vault, and cleanup audits for MCP agents.

This AWS Labs Model Context Protocol (MCP) server for CloudTrail enables your AI agents to query AWS account activity for security investigations, compliance auditing, and operational troubleshooting.

Query and interact with kubernetes environments monitored by Metoro

Provides a unified interface to AWS services for security investigations and incident response.

A comprehensive Model Context Protocol (MCP) server for the Cloudability API, providing advanced cost management, Kubernetes container analytics, and budget forecasting capabilities.

Provides direct access to CORTEX infrastructure for orchestration, monitoring, AI flow management, model routing, and Docker administration.

Manage Kubernetes applications safely by creating and updating Cyclops Modules for AI agents.

Behavioral trust scoring for MCP servers and AI agents. Live registry tracking 4,500+ servers with trust scores based on interaction history, success rates, and latency.

A server for Kubernetes CLI tools like kubectl, istioctl, helm, and argocd, supporting multi-cluster management via dynamic kubeconfig.

An MCP server for kubectl, enabling AI assistants to interact with Kubernetes clusters through a standardized protocol.

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

Claude Desktop / Cursor

McpServers

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

Install

More like this

Sequential Thinking

Aws Kb Retrieval Server

Filesystem

EverArt

Google Drive

Reactive Resume