RAD Security

आधिकारिक

RAD Security प्लेटफ़ॉर्म के साथ इंटरैक्ट करें जो Kubernetes और क्लाउड वातावरण के लिए AI-संचालित सुरक्षा अंतर्दृष्टि प्रदान करता है।

GitHub

RAD Security MCP के साथ आप क्या कर सकते हैं?

सुरक्षा निष्कर्षों की समीक्षा करें — सुरक्षा निष्कर्षों की सूची बनाएँ और उनका विश्लेषण करें, फिर किसी निष्कर्ष की स्थिति अपडेट करें।
इमेज और CVE का निरीक्षण करें — SBOM प्राप्त करें, कमज़ोरियों वाली इमेज की सूची बनाएँ, सबसे अधिक कमज़ोर इमेज खोजें, और CVE को अनदेखा करें या अनदेखा करना बंद करें।
रनटाइम व्यवहार का पता लगाएँ — चल रहे कंटेनरों के लिए प्रोसेस ट्री और रनटाइम बेसलाइन प्राप्त करें, और उनके प्रोसेस व्यवहार का विश्लेषण करें।
पॉड एक्सेस का ऑडिट करें — उन लोगों की सूची बनाएँ जिन्होंने पॉड में शेल एक्सेस किया।
RadQL क्वेरी चलाएँ — डेटा प्रकारों की सूची बनाएँ, स्कीमा प्राप्त करें, और फ़िल्टर की गई या एग्रीगेट की गई क्वेरी चलाएँ, जिनमें कई क्वेरी समानांतर रूप से चलाना भी शामिल है।
ऑटोमेशन प्रबंधित करें — ऑटोमेशन, रन और शेड्यूल की सूची बनाएँ; रन का विवरण प्राप्त करें; ऑटोमेशन चलाएँ; या नया ऑटोमेशन बनाएँ और उसे अपडेट करें।

दस्तावेज़

RAD Security MCP Server

Kubernetes और क्लाउड परिवेशों के लिए AI-संचालित सुरक्षा जानकारी प्रदान करने वाला RAD Security का Model Context Protocol (MCP) सर्वर।

कनेक्ट करें (होस्टेड — अनुशंसित)

RAD Security आपके लिए MCP सर्वर चलाता है, इसलिए अधिकांश उपयोगकर्ताओं को कुछ भी इंस्टॉल या होस्ट करने की ज़रूरत नहीं होती। अपने MCP क्लाइंट को होस्ट किए गए एंडपॉइंट पर इंगित करें और अपने RAD Security क्रेडेंशियल से प्रमाणित करें।

एंडपॉइंट: https://api.rad.security/mcp/ — अंत में लगा स्लैश न हटाएँ।
ट्रांसपोर्ट: Streamable HTTP।
प्रमाणीकरण: अपना क्रेडेंशियल Authorization हेडर में भेजें:
```
Authorization: Bearer <access_key_id>:<secret_key>:<account_id>
```
<access_key_id> और <secret_key> RAD Security API एक्सेस कुंजी हैं (RAD Security कंसोल में एक बनाएँ); <account_id> आपका खाता ID है। सर्वर हर अनुरोध को RAD Security API के विरुद्ध प्रमाणित करता है — सर्वर-साइड पर कोई क्रेडेंशियल संग्रहीत नहीं किया जाता।

अल्पकालिक रूप Bearer ory_st_<session_token>:<account_id> भी काम करता है, लेकिन सेशन टोकन की समय-सीमा समाप्त हो जाती है — लंबे समय तक चलने वाली किसी भी चीज़ (जैसे Slack / Claude Tag) के लिए एक्सेस कुंजी को प्राथमिकता दें।

पूरे टेनेंट के लिए एक कनेक्शन

एक MCP कॉन्फ़िगरेशन से अपने सभी खातों पर काम करने के लिए, अपने टेनेंट पर एक एक्सेस कुंजी बनाएँ और खाता ID की जगह tenant=<tenant_id> का उपयोग करें:

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

टेनेंट-स्कोप वाले सेशन में:

list_accounts टूल टेनेंट के खाते लौटाता है।
खाता-स्कोप वाले टूल के लिए account_id आर्ग्युमेंट आवश्यक है, जो टेनेंट का चाइल्ड खाता होना चाहिए। हर कॉल एक खाते पर लागू होती है; अलग-अलग खातों के परिणाम एक साथ नहीं जोड़े जाते।
डिफ़ॉल्ट रूप से केवल रीड-ओनली टूल उपलब्ध होते हैं, क्योंकि टेनेंट क्रेडेंशियल हर खाते तक पहुँचता है। राइट टूल सक्षम करने के लिए X-Rad-Readonly: false भेजें।

npx/stdio सर्वर के लिए, RAD_SECURITY_ACCOUNT_ID के बिना RAD_SECURITY_TENANT_ID सेट करें, और राइट टूल सक्षम करने के लिए RAD_SECURITY_READONLY=false का उपयोग करें।

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

या CLI के ज़रिए, सीक्रेट को 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

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 — ध्यान दें कि रैपर कुंजी servers है, 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 — ध्यान दें कि URL फ़ील्ड httpUrl है (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 — ध्यान दें कि type बिल्कुल 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 — ध्यान दें कि URL फ़ील्ड serverUrl है:

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

अन्य क्लाइंट

अधिकांश MCP क्लाइंट URL और Authorization हेडर वाले रिमोट Streamable HTTP सर्वर को स्वीकार करते हैं — केवल फ़ील्ड के नाम अलग होते हैं। हर स्थिति में URL के अंत में लगा स्लैश बनाए रखें।

क्लाइंट	कॉन्फ़िगरेशन स्थान	URL फ़ील्ड	ट्रांसपोर्ट मार्कर	हेडर फ़ील्ड
Claude Code	`claude mcp add`	positional arg	`--transport http`	`--header`
OpenAI Codex CLI	`~/.codex/config.toml`	`url`	inferred	`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`	inferred	`headers`
Cline	`cline_mcp_settings.json`	`url`	`type: "streamableHttp"`	`headers`
Windsurf	`~/.codeium/windsurf/mcp_config.json`	`serverUrl`	inferred	`headers`

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

ये इंटरफ़ेस रिमोट MCP सर्वर को कनेक्टर के रूप में जोड़ते हैं, जिनकी अपनी क्रेडेंशियल सेटिंग होती हैं, न कि सामान्य अनुरोध हेडर। https://api.rad.security/mcp/ को कस्टम कनेक्टर के रूप में जोड़ें, फिर कनेक्टर की सेटिंग में bearer क्रेडेंशियल दें:

Claude Tag (Slack): सर्वर को ऐसे प्लगइन के रूप में जोड़ें जिसका .mcp.json एंडपॉइंट पर इंगित करता हो, और Access bundle के Credentials टैब में bearer क्रेडेंशियल जोड़ें। Claude Tag — कस्टम MCP सर्वर से कनेक्ट करें देखें।
Claude.ai / Desktop: इसे Settings → Connectors में जोड़ें; कस्टम कनेक्टर देखें।

इसका परीक्षण करें (MCP Inspector या 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"}}}'

एजेंट को दिखने वाले टूल का दायरा सीमित करना

डिफ़ॉल्ट रूप से, कनेक्शन को हर टूलकिट मिलता है। एजेंट को छोटा सेट देने के लिए — ताकि संदर्भ/टोकन का खर्च कम हो और न्यूनतम विशेषाधिकार लागू हो — उस कनेक्शन में Authorization के साथ स्कोपिंग हेडर जोड़ें। इस सबसेट को लागू किया जाता है: स्कोप से बाहर का टूल tools/list से छिपा रहता है और कॉल किए जाने पर अस्वीकार कर दिया जाता है।

हेडर	प्रभाव
`X-Rad-Toolkits: findings, images`	केवल ये टूलकिट
`X-Rad-Exclude-Toolkits: workflows`	इन टूलकिट को छोड़कर सभी
`X-Rad-Readonly: true`	केवल रीड-ओनली टूल (राइट टूल हटाता है)

टूलकिट: containers, clusters, audit, images, kubeobject, runtime, findings, inbox, workflows, knowledge_base, radql, dashboards, integrations। डिफ़ॉल्ट रूप से सभी सक्षम होते हैं — ऊपर दिए गए हेडर से दायरा सीमित करें, और सभी राइट टूल हटाने के लिए X-Rad-Readonly का उपयोग करें।

उदाहरण — रीड-ओनली findings/images एजेंट (हेडर का समर्थन करने वाला कोई भी क्लाइंट; यहाँ 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"
      }
    }
  }
}

Claude Code में, एक अतिरिक्त --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"

सुविधाएँ

सभी टूल के लिए प्रमाणीकरण और RAD Security में एक खाते की आवश्यकता होती है। होस्टेड एंडपॉइंट डिफ़ॉल्ट रूप से नीचे दिए गए हर टूलकिट को उपलब्ध कराता है; X-Rad-Toolkits / X-Rad-Exclude-Toolkits से क्लाइंट का दायरा सीमित करें, या X-Rad-Readonly: true से सभी राइट टूल हटाएँ।

खाता इन्वेंटरी
- क्लस्टर और उनके विवरण सूचीबद्ध करें
कंटेनर इन्वेंटरी
- कंटेनर और उनके विवरण सूचीबद्ध करें
सुरक्षा निष्कर्ष
- सुरक्षा निष्कर्ष सूचीबद्ध करें और उनका विश्लेषण करें
- सुरक्षा निष्कर्ष की स्थिति अपडेट करें
रनटाइम सुरक्षा
- चल रहे कंटेनरों के प्रोसेस ट्री प्राप्त करें
- चल रहे कंटेनरों के रनटाइम बेसलाइन प्राप्त करें
- चल रहे कंटेनरों के प्रोसेस व्यवहार का विश्लेषण करें
ऑडिट
- सूचीबद्ध करें कि किसने किसी पॉड में शेल खोला
इमेज और कमज़ोरियाँ
- SBOM प्राप्त करें
- इमेज और उनकी कमज़ोरियाँ सूचीबद्ध करें
- सबसे अधिक कमज़ोरियों वाली इमेज प्राप्त करें
- CVE को अनदेखा करें / अनदेखा करना बंद करें और सक्रिय CVE निपटान सूचीबद्ध करें
Kubernetes ऑब्जेक्ट
- किसी विशिष्ट Kubernetes संसाधन का विवरण प्राप्त करें
- Kubernetes संसाधन सूचीबद्ध करें
इनबॉक्स
- इनबॉक्स आइटम और उनके विवरण सूचीबद्ध करें
- किसी इनबॉक्स आइटम को गलत सकारात्मक के रूप में चिह्नित करें
ऑटोमेशन (workflows)
- ऑटोमेशन, रन और शेड्यूल सूचीबद्ध करें
- ऑटोमेशन और रन का विवरण प्राप्त करें
- ऑटोमेशन चलाएँ
- ऑटोमेशन बनाएँ और अपडेट करें, और cron शेड्यूल जोड़ें
उपयोगकर्ताओं को दिखने वाला उत्पाद नाम "Automation" है; "workflow" वह अंतर्निहित Windmill ऑब्जेक्ट है जिसका उपयोग API और टूल के नाम करते हैं। दोनों एक ही चीज़ हैं।
नॉलेज बेस
- नॉलेज बेस में खोजें
- कलेक्शन और दस्तावेज़ सूचीबद्ध करें
- किसी दस्तावेज़ पर संरचित क्वेरी चलाएँ
डैशबोर्ड
- डैशबोर्ड सूचीबद्ध करें और उनका विवरण प्राप्त करें
- डैशबोर्ड और विजेट टेम्पलेट सूचीबद्ध करें और प्राप्त करें
- डैशबोर्ड बनाएँ और उसे वहीं अपडेट करें (छोड़े गए फ़ील्ड अपरिवर्तित रहते हैं, इसलिए छोटे बदलाव के लिए पूरा डैशबोर्ड दोबारा भेजने की ज़रूरत नहीं होती)
इंटीग्रेशन
- बाहरी इंटीग्रेशन सूचीबद्ध करें
RadQL (उन्नत क्वेरी)
- क्वेरी के लिए उपलब्ध डेटा प्रकार सूचीबद्ध करें (containers, findings, kubernetes_resources आदि)
- विशिष्ट डेटा प्रकारों के लिए स्कीमा/मेटाडेटा प्राप्त करें
- फ़िल्टर फ़ील्ड के संभावित मान सूचीबद्ध करें
- फ़िल्टरिंग, खोज और एग्रीगेशन के साथ RadQL क्वेरी चलाएँ
- संरचित शर्तों से प्रोग्रामेटिक रूप से क्वेरी बनाएँ
- कई क्वेरी समानांतर रूप से चलाएँ

स्वयं होस्ट करना

क्या आप सर्वर को स्वयं चलाना पसंद करेंगे — उदाहरण के लिए, एयर-गैप्ड परिवेश में, डेटा-रेज़िडेंसी की आवश्यकताओं के कारण, या यदि आप होस्टेड गेटवे के ज़रिए ट्रैफ़िक नहीं भेजना चाहते? यह npm और कंटेनर इमेज के रूप में प्रकाशित है।

आवश्यकताएँ

Node.js 20.x या उच्चतर

क्रेडेंशियल

अपने RAD Security क्रेडेंशियल पर्यावरण वेरिएबल के ज़रिए दें:

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) — जैसे 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

टूलकिट फ़िल्टर करना

स्वयं होस्ट किया गया सर्वर कौन-से टूलकिट उपलब्ध कराए, यह नियंत्रित करें:

INCLUDE_TOOLKITS: शामिल करने के लिए टूलकिट की कॉमा से अलग की गई सूची (केवल ये सक्षम होंगे)।
EXCLUDE_TOOLKITS: बाहर रखने के लिए टूलकिट की कॉमा से अलग की गई सूची (बाकी सभी सक्षम होंगे)। यदि INCLUDE_TOOLKITS सेट है, तो इसे अनदेखा किया जाता है।

उपलब्ध टूलकिट: containers, clusters, audit, images, kubeobject, runtime, findings, inbox, workflows, knowledge_base, radql, dashboards, integrations। डिफ़ॉल्ट रूप से सभी सक्षम होते हैं।

# Only the workflows toolkit
INCLUDE_TOOLKITS="workflows"

# Everything except runtime
EXCLUDE_TOOLKITS="runtime"

मल्टी-टेनेंट (हर अनुरोध पर प्रमाणीकरण)

MCP_AUTH_MODE नियंत्रित करता है कि Streamable HTTP डिप्लॉयमेंट आने वाले अनुरोधों का प्रमाणीकरण कैसे करता है — होस्टेड एंडपॉइंट इसी का उपयोग करता है:

MCP_AUTH_MODE=env (डिफ़ॉल्ट) — हर सेशन RAD_SECURITY_* पर्यावरण क्रेडेंशियल का उपयोग करता है। यह सिंगल-टेनेंट है और HTTP लेयर पर अप्रमाणित है, इसलिए इसे अविश्वसनीय नेटवर्क से पहुँच योग्य नहीं होना चाहिए।
MCP_AUTH_MODE=header — हर अनुरोध में Authorization हेडर में अपना क्रेडेंशियल होना चाहिए (ऊपर दिया गया Bearer <access_key_id>:<secret_key>:<account_id> रूप); हेडर अनुपस्थित या गलत फ़ॉर्मैट में होने पर अनुरोध 401 के साथ अस्वीकार कर दिया जाता है। केवल TRANSPORT_TYPE=streamable के साथ समर्थित। RAD_SECURITY_API_URL कॉलर से नहीं, बल्कि सर्वर कॉन्फ़िगरेशन से लिया जाता है।

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

SSE ट्रांसपोर्ट (TRANSPORT_TYPE=sse) अब अप्रचलित है; इसके स्थान पर Streamable HTTP का उपयोग करें। यह केवल env क्रेडेंशियल का उपयोग करता है।

विकास

# Install dependencies
npm install

# Run type checking
npm run type-check

# Run linter
npm run lint

# Build
npm run build

लाइसेंस

MIT License - विवरण के लिए LICENSE फ़ाइल देखें