RAD Security

आधिकारिक

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

GitHub

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

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

दस्तावेज़

RAD Security MCP सर्वर

RAD Security के लिए एक Model Context Protocol (MCP) सर्वर, जो Kubernetes और क्लाउड वातावरण के लिए AI-संचालित सुरक्षा अंतर्दृष्टि प्रदान करता है।

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

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)।

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 बंडल के 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 शेड्यूल जोड़ें
"ऑटोमेशन" उत्पाद नाम है जो उपयोगकर्ता देखते हैं; "वर्कफ़्लो" अंतर्निहित Windmill ऑब्जेक्ट है जो API और टूल नाम उपयोग करते हैं। वे एक ही चीज़ हैं।
ज्ञान आधार
- ज्ञान आधार खोजें
- संग्रह और दस्तावेज़ सूचीबद्ध करें
- एक दस्तावेज़ के विरुद्ध संरचित क्वेरी चलाएँ
डैशबोर्ड
- डैशबोर्ड सूचीबद्ध करें और उनके विवरण प्राप्त करें
- डैशबोर्ड और विजेट टेम्पलेट सूचीबद्ध करें और प्राप्त करें
- एक डैशबोर्ड बनाएं, और एक को स्थान पर अपडेट करें (छोड़े गए फ़ील्ड अपरिवर्तित रहते हैं, इसलिए एक छोटा संपादन पूरे डैशबोर्ड को फिर से भेजने की आवश्यकता नहीं है)
एकीकरण
- बाहरी एकीकरण सूचीबद्ध करें
RadQL (उन्नत क्वेरी)
- क्वेरी के लिए उपलब्ध डेटा प्रकार सूचीबद्ध करें (कंटेनर, निष्कर्ष, 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
RAD_SECURITY_TENANT_ID="your_tenant_id"

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 फ़ाइल देखें