Superserve Sandbox MCP

आधिकारिक

सुपरसर्व द्वारा होस्ट किए गए एजेंटों के लिए सुरक्षित वर्चुअल मशीनें

superserve.ai पर देखेंइस MCP को आज़माएँप्रायोजित

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

  • सैंडबॉक्स बनाएं और चलाएं — अपने असिस्टेंट से sandbox_create के साथ सैंडबॉक्स शुरू करने और sandbox_exec के माध्यम से python --version जैसे कमांड चलाने के लिए कहें।
  • सैंडबॉक्स में फ़ाइलें प्रबंधित करें — सैंडबॉक्स के अंदर फ़ाइलें बनाने, देखने या व्यवस्थित करने के लिए sandbox_files_write, sandbox_files_read, और sandbox_files_list का उपयोग करें।
  • सैंडबॉक्स जीवनचक्र नियंत्रित करें — संसाधनों को प्रबंधित करने के लिए sandbox_pause, sandbox_resume, और sandbox_kill के साथ सैंडबॉक्स को रोकें, फिर से शुरू करें, या स्थायी रूप से हटाएं।
  • पूर्वावलोकन URL प्रकाशित करें — सार्वजनिक या समाप्त होने वाला निजी लिंक पाने के लिए sandbox_preview_url को कॉल करके चल रही सेवा को उजागर करें।
  • सीक्रेट्स को सुरक्षित रूप से बांधें — कच्चे मानों को उजागर किए बिना sandbox_attach_secret और sandbox_detach_secret के माध्यम से संग्रहीत टीम सीक्रेट्स को सैंडबॉक्स से जोड़ें या हटाएं।
  • कस्टम टेम्पलेट बनाएं — sandbox_template_create के साथ विशिष्ट CPU/मेमोरी/डिस्क आकार वाले पुन: प्रयोज्य सैंडबॉक्स टेम्पलेट बनाएं और sandbox_template_list के साथ उन्हें सूचीबद्ध करें।

दस्तावेज़

MCP सर्वर

किसी भी MCP क्लाइंट से Superserve सैंडबॉक्स बनाएं, चलाएं और प्रबंधित करें।

क्या आप चाहते हैं कि कोई एजेंट खुद सैंडबॉक्स बनाए? यह MCP सर्वर ऐसा करता है।

Superserve MCP सर्वर (@superserve/mcp) सैंडबॉक्स प्रिमिटिव्स को Model Context Protocol टूल्स के रूप में उजागर करता है, ताकि कोई भी MCP-सक्षम क्लाइंट — Claude, Cursor, VS Code, Windsurf, Codex — सैंडबॉक्स बना सके, कमांड चला सके, फ़ाइलें पढ़ और लिख सके, टेम्पलेट बना सके, सीक्रेट्स को ब्रोकर कर सके, और एक अलग Firecracker microVM में नेटवर्क एक्सेस को नियंत्रित कर सके।

इसे दो तरीकों से चलाएं: स्थानीय रूप से stdio के माध्यम से npx का उपयोग करके, या होस्टेड एंडपॉइंट के खिलाफ https://mcp.superserve.ai पर बिना किसी स्थानीय इंस्टॉल के। दोनों आपके SUPERSERVE_API_KEY के साथ प्रमाणित होते हैं और प्रति कॉल ID द्वारा एक सैंडबॉक्स को लक्षित करते हैं। यह TypeScript SDK के ऊपर एक पतला रैपर है, इसलिए प्रति-सैंडबॉक्स डेटा-प्लेन टोकन कभी भी मॉडल तक नहीं पहुंचता।

त्वरित आरंभ

सर्वर को अपने क्लाइंट में जोड़ें (इंस्टॉल देखें), फिर एजेंट से कहें "एक सैंडबॉक्स बनाएं और उसमें python --version चलाएं।" एजेंट sandbox_create को कॉल करता है, फिर sandbox_exec को, और परिणाम रिपोर्ट करता है — आपकी ओर से कोई कोड नहीं।

आपको एक Superserve API कुंजी चाहिए — इसे API कुंजी पृष्ठ पर बनाएं। कोई वैश्विक इंस्टॉल नहीं है; npx पहले उपयोग पर सर्वर को लाता है।

इंस्टॉल

नोट

सर्वर के env में SUPERSERVE_API_KEY सेट करें — MCP क्लाइंट इसे आपके शेल से विरासत में नहीं लेते। जहां आपका क्लाइंट समर्थन करता है, वहां कच्ची कुंजी चिपकाने के बजाय सीक्रेट-इनपुट प्रॉम्प्ट पसंद करें (नीचे VS Code देखें)।

```bash theme={"theme":{"light":"github-light","dark":"vitesse-dark"}} claude mcp add superserve \ --env SUPERSERVE_API_KEY=ss_live_xxxxxxxxxxxxxxxx \ -- npx -y @superserve/mcp ``` `claude_desktop_config.json` में जोड़ें (macOS: `~/Library/Application Support/Claude/`): 
```json theme={"theme":{"light":"github-light","dark":"vitesse-dark"}}
{
  "mcpServers": {
    "superserve": {
      "command": "npx",
      "args": ["-y", "@superserve/mcp"],
      "env": { "SUPERSERVE_API_KEY": "ss_live_xxxxxxxxxxxxxxxx" }
    }
  }
}
```
`.cursor/mcp.json` (प्रोजेक्ट) या `~/.cursor/mcp.json` (वैश्विक) में जोड़ें: 
```json theme={"theme":{"light":"github-light","dark":"vitesse-dark"}}
{
  "mcpServers": {
    "superserve": {
      "command": "npx",
      "args": ["-y", "@superserve/mcp"],
      "env": { "SUPERSERVE_API_KEY": "ss_live_xxxxxxxxxxxxxxxx" }
    }
  }
}
```
`.vscode/mcp.json` में जोड़ें। `inputs` ब्लॉक इसे सादे पाठ में संग्रहीत करने के बजाय कुंजी के लिए प्रॉम्प्ट करता है: 
```json theme={"theme":{"light":"github-light","dark":"vitesse-dark"}}
{
  "inputs": [
    {
      "id": "superserve-key",
      "type": "promptString",
      "description": "Superserve API key",
      "password": true
    }
  ],
  "servers": {
    "superserve": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@superserve/mcp"],
      "env": { "SUPERSERVE_API_KEY": "${input:superserve-key}" }
    }
  }
}
```
`~/.codeium/windsurf/mcp_config.json` में जोड़ें: 
```json theme={"theme":{"light":"github-light","dark":"vitesse-dark"}}
{
  "mcpServers": {
    "superserve": {
      "command": "npx",
      "args": ["-y", "@superserve/mcp"],
      "env": { "SUPERSERVE_API_KEY": "ss_live_xxxxxxxxxxxxxxxx" }
    }
  }
}
```
`~/.codex/config.toml` में जोड़ें। `env_vars` आपके वातावरण से `SUPERSERVE_API_KEY` को आगे भेजता है, इसलिए कच्ची कुंजी कॉन्फ़िगरेशन फ़ाइल में संग्रहीत नहीं होती (इसे पहले अपने शेल में निर्यात करें)। Codex क्रॉस-टूल वर्कफ़्लो मार्गदर्शन के लिए सर्वर का `instructions` भी पढ़ता है। 
```toml theme={"theme":{"light":"github-light","dark":"vitesse-dark"}}
[mcp_servers.superserve]
command = "npx"
args = ["-y", "@superserve/mcp"]
env_vars = ["SUPERSERVE_API_KEY"]
```

[होस्टेड](#hosted-remote) एंडपॉइंट के लिए, `url = "https://mcp.superserve.ai"` का उपयोग `bearer_token_env_var = "SUPERSERVE_API_KEY"` के साथ करें।

होस्टेड (रिमोट)

कुछ भी स्थानीय रूप से नहीं चलाना चाहते? https://mcp.superserve.ai पर होस्टेड एंडपॉइंट Streamable HTTP बोलता है — कोई npx नहीं, कोई Node नहीं। अपनी Superserve API कुंजी को बेयरर टोकन के रूप में भेजें। एंडपॉइंट स्टेटलेस और खाता-स्कोप्ड है (आपकी कुंजी पहले से ही आपकी टीम से मैप होती है), और प्रति-सैंडबॉक्स डेटा-प्लेन टोकन कभी भी सर्वर नहीं छोड़ता।

नोट

बेयरर प्रमाणीकरण किसी भी क्लाइंट में काम करता है जो आपको एक अनुरोध हेडर सेट करने देता है — Claude Code, Cursor, VS Code, और Anthropic Messages API कनेक्टर। Claude.ai, Claude Desktop का Custom Connector UI, और ChatGPT डेवलपर मोड एक स्थिर-बेयरर / कस्टम-हेडर फ़ील्ड प्रदान नहीं करते (वे OAuth की उम्मीद करते हैं), जिसे होस्टेड एंडपॉइंट अभी तक समर्थन नहीं करता — वहां स्थानीय इंस्टॉल का उपयोग करें।

```bash theme={"theme":{"light":"github-light","dark":"vitesse-dark"}} claude mcp add --transport http superserve https://mcp.superserve.ai \ --header "Authorization: Bearer ss_live_xxxxxxxxxxxxxxxx" ``` `.cursor/mcp.json` (प्रोजेक्ट) या `~/.cursor/mcp.json` (वैश्विक) में जोड़ें: 
```json theme={"theme":{"light":"github-light","dark":"vitesse-dark"}}
{
  "mcpServers": {
    "superserve": {
      "url": "https://mcp.superserve.ai",
      "headers": { "Authorization": "Bearer ss_live_xxxxxxxxxxxxxxxx" }
    }
  }
}
```
`.vscode/mcp.json` में जोड़ें। `inputs` ब्लॉक इसे सादे पाठ में संग्रहीत करने के बजाय कुंजी के लिए प्रॉम्प्ट करता है: 
```json theme={"theme":{"light":"github-light","dark":"vitesse-dark"}}
{
  "inputs": [
    {
      "id": "superserve-key",
      "type": "promptString",
      "description": "Superserve API key",
      "password": true
    }
  ],
  "servers": {
    "superserve": {
      "type": "http",
      "url": "https://mcp.superserve.ai",
      "headers": { "Authorization": "Bearer ${input:superserve-key}" }
    }
  }
}
```
इसे [Anthropic Messages API](https://docs.anthropic.com/en/docs/agents-and-tools/mcp-connector) अनुरोध में एक कनेक्टर के रूप में पास करें: 
```json theme={"theme":{"light":"github-light","dark":"vitesse-dark"}}
{
  "mcp_servers": [
    {
      "type": "url",
      "name": "superserve",
      "url": "https://mcp.superserve.ai",
      "authorization_token": "ss_live_xxxxxxxxxxxxxxxx"
    }
  ]
}
```

स्थानीय सर्वर के समान टूल और व्यवहार — एकमात्र अंतर परिवहन है और यह कि कुंजी एक env वेरिएबल के बजाय बेयरर हेडर के रूप में यात्रा करती है।

टूल्स

टूलयह क्या करता है
sandbox_createएक नया सैंडबॉक्स बनाएं; इसका id लौटाता है। secrets, ईग्रेस नियम, और preview_access स्वीकार करता है।
sandbox_updateमेटाडेटा, ईग्रेस नियम, लाइफसाइकल विंडो, या preview_access बदलें।
sandbox_listअपने सैंडबॉक्स (सक्रिय और रोके गए) सूचीबद्ध करें, मेटाडेटा द्वारा फ़िल्टर करने योग्य।
sandbox_infoएक सैंडबॉक्स की स्थिति, संसाधन, मेटाडेटा, नेटवर्क नियम, और सीक्रेट बाइंडिंग प्राप्त करें। केवल-पठनीय।
sandbox_execएक शेल कमांड चलाएं; stdout, stderr, निकास कोड लौटाता है। रोके गए सैंडबॉक्स को स्वचालित रूप से फिर से शुरू करता है।
sandbox_files_readएक फ़ाइल पढ़ें (UTF-8 पाठ, या बाइनरी के लिए base64)।
sandbox_files_writeएक फ़ाइल बनाएं या अधिलेखित करें। मूल निर्देशिकाएं स्वचालित रूप से बनाई जाती हैं।
sandbox_files_listएक निर्देशिका की प्रविष्टियां सूचीबद्ध करें (नाम, प्रकार, आकार, संशोधन समय)।
sandbox_files_download_dirएक निर्देशिका को base64 ZIP के रूप में डाउनलोड करें (सिमलिंक छोड़े गए)। 10 MiB पर सीमित; बड़ा → SDK/CLI।
sandbox_pauseएक सैंडबॉक्स रोकें; स्थिति संरक्षित है।
sandbox_resumeएक रोके गए सैंडबॉक्स को फिर से शुरू करें (आमतौर पर अनावश्यक — exec स्वचालित रूप से फिर से शुरू करता है)।
sandbox_killएक सैंडबॉक्स को स्थायी रूप से हटाएं।
sandbox_preview_urlएक पोर्ट प्रकाशित करें और एक स्वच्छ सार्वजनिक URL या एक समाप्त होने वाला निजी हस्ताक्षरित URL लौटाएं।
sandbox_network_logएक सैंडबॉक्स के आउटबाउंड कनेक्शन (होस्ट, निर्णय, बाइट्स) का ऑडिट करें बिना इसे फिर से शुरू किए।
sandbox_template_listउन टेम्पलेट्स (बेस इमेज) को सूचीबद्ध करें जिनसे आपकी टीम लॉन्च कर सकती है।
sandbox_template_createएक विशिष्ट vCPU/मेमोरी/डिस्क आकार या पूर्व-स्थापित सॉफ़्टवेयर के साथ एक कस्टम टेम्पलेट बनाएं (async — तैयार के लिए पोल करें)।
secret_listबाइंड करने योग्य टीम सीक्रेट्स सूचीबद्ध करें (केवल मेटाडेटा — कभी मान नहीं)।
sandbox_attach_secretएक संग्रहीत सीक्रेट को एक चल रहे सैंडबॉक्स में एक env वेरिएबल के तहत बाइंड करें।
sandbox_detach_secretएक सैंडबॉक्स से एक सीक्रेट बाइंडिंग हटाएं।

अधिकांश टूल एक sandbox_id लेते हैं; अपवाद हैं sandbox_create, sandbox_list, sandbox_template_list, sandbox_template_create, और secret_list। एक ID प्राप्त करने के लिए उनमें से एक से शुरू करें, फिर इसे बाद के कॉल में थ्रेड करें। केवल-पठनीय टूल (sandbox_list, sandbox_info, sandbox_files_read, sandbox_files_list, sandbox_files_download_dir, sandbox_network_log, sandbox_template_list, secret_list) एनोटेट किए गए हैं ताकि क्लाइंट पुष्टिकरण प्रॉम्प्ट छोड़ सकें; sandbox_preview_url एक आइडेम्पोटेंट लेखन है क्योंकि यह अनुरोधित पोर्ट प्रकाशित करता है, और sandbox_kill विनाशकारी के रूप में एनोटेट किया गया है।

उदाहरण

"एक सैंडबॉक्स स्पिन करें, एक Python स्क्रिप्ट लिखें जो पहले प्राइम्स को प्रिंट करती है, और इसे चलाएं" के लिए एक विशिष्ट एजेंट प्रवाह:

sandbox_create       { name: "primes" }
                       → { id: "a1b2c3…", name: "primes", status: "active" }

sandbox_files_write  { sandbox_id: "a1b2c3…", path: "/app/primes.py", content: "…" }
                       → { path: "/app/primes.py", bytes: 142 }

sandbox_exec         { sandbox_id: "a1b2c3…", command: "python /app/primes.py" }
                       → { exit_code: 0, stdout: "2 3 5 7 11 13 17 19 23 29", stderr: "" }

जब यह समाप्त हो जाता है, तो एजेंट sandbox_pause (स्थिति संरक्षित, रखने के लिए सस्ता) या sandbox_kill (स्थायी) कर सकता है।

कॉन्फ़िगरेशन

वेरिएबलआवश्यकविवरण
SUPERSERVE_API_KEYहाँआपकी Superserve API कुंजी (ss_live_ से शुरू होती है)।
SUPERSERVE_BASE_URLनहींनियंत्रण-प्लेन URL ओवरराइड करें (डिफ़ॉल्ट https://api.superserve.ai है)।

व्यवहार और सीमाएं

  • स्वचालित फिर से शुरू। sandbox_exec और फ़ाइल टूल एक रोके गए सैंडबॉक्स को पारदर्शी रूप से फिर से शुरू करते हैं, इसलिए एजेंटों को कभी भी पहले sandbox_resume कॉल करने की आवश्यकता नहीं होती। sandbox_resume केवल एक सैंडबॉक्स को स्पष्ट रूप से गर्म करने के लिए मौजूद है।
  • संदर्भ के लिए आउटपुट सीमित है। sandbox_exec stdout और stderr को प्रत्येक 32 KiB तक छोटा करता है — एक छोटा परिणाम truncated: true सेट करता है और मूल बाइट लंबाई रिपोर्ट करता है। sandbox_files_read 1 MiB से बड़ी फ़ाइलों को अस्वीकार करता है (यह आंशिक सामग्री नहीं लौटाता); त्रुटि आपको sandbox_exec के साथ एक स्लाइस पढ़ने (जैसे head -c) या SDK/CLI के साथ पूरी फ़ाइल डाउनलोड करने के लिए कहती है। sandbox_files_write इनलाइन सामग्री 8 MiB पर सीमित है।
  • डिफ़ॉल्ट कमांड टाइमआउट 60s है, अधिकतम 10 मिनट। इसे प्रति कॉल timeout_ms के साथ ओवरराइड करें।
  • ईग्रेस नियंत्रणीय है। allow_out (डोमेन पैटर्न या CIDRs) अनुमत गंतव्य जोड़ता है; deny_out (केवल CIDRs) उन्हें ब्लॉक करता है। allow_out अकेले एक सैंडबॉक्स को लॉक नहीं करता — एक सख्त अनुमतिसूची के लिए, इसे deny_out: ["0.0.0.0/0"] (सभी अस्वीकार करें, फिर सूचीबद्ध गंतव्यों की अनुमति दें) के साथ जोड़ें। इन्हें sandbox_create या sandbox_update पर सेट करें, और sandbox_network_log के साथ ऑडिट करें कि एक सैंडबॉक्स वास्तव में क्या पहुंचा।
  • त्रुटियां कार्रवाई योग्य हैं। एक असफल टूल कॉल एजेंट को बताने वाला एक छोटा संदेश लौटाता है कि आगे क्या करना है — जैसे "सैंडबॉक्स कोटा पूरा हो गया। एक सैंडबॉक्स रोकें या मारें, या बाद में पुनः प्रयास करें।" — एक कच्चे स्टैक ट्रेस के बजाय, ताकि एजेंट स्वयं सुधार कर सके।

सीक्रेट्स, टेम्पलेट्स, और पोर्ट्स

सीक्रेट्स। क्रेडेंशियल्स को सादे पाठ env_vars के रूप में पास न करें। इसके बजाय:

  1. सीक्रेट को एक बार TypeScript SDK (Secret.create()) या कंसोल के साथ बनाएं — कच्चा मान कभी भी एजेंट या MCP सर्वर के माध्यम से यात्रा नहीं करता, इसलिए सीक्रेट निर्माण जानबूझकर एक MCP टूल नहीं है।
  2. secret_list के साथ बाइंड करने योग्य सीक्रेट्स खोजें (केवल मेटाडेटा — मान कभी भी प्लेटफ़ॉर्म नहीं छोड़ते)।
  3. निर्माण पर बाइंड करें — sandbox_create पर secrets: { ANTHROPIC_API_KEY: "anthropic-prod" } — या बाद में sandbox_attach_secret / sandbox_detach_secret के साथ।

सैंडबॉक्स एक प्रॉक्सी टोकन देखता है; प्लेटफ़ॉर्म केवल सीक्रेट के अनुमत होस्ट्स के लिए आउटबाउंड अनुरोधों के लिए वास्तविक क्रेडेंशियल स्वैप करता है।

टेम्पलेट्स। एक सैंडबॉक्स अपने टेम्पलेट से अपना vCPU/मेमोरी/डिस्क विरासत में लेता है और sandbox_create समय पर उन्हें ओवरराइड नहीं कर सकता। एक विशिष्ट आकार (जैसे, 4 vCPU सैंडबॉक्स) या पूर्व-स्थापित सॉफ़्टवेयर प्राप्त करने के लिए, sandbox_template_create के साथ एक टेम्पलेट बनाएं, फिर sandbox_template_list को पोल करें जब तक कि इसका status ready न हो जाए, इसे from_template के रूप में पास करने से पहले।

पोर्ट्स। नए MCP सैंडबॉक्स नए प्रकाशित पोर्ट्स के लिए डिफ़ॉल्ट एक्सेस के रूप में public का उपयोग करते हैं; केवल स्पष्ट रूप से प्रकाशित पोर्ट्स पहुंच योग्य हैं। भविष्य के पोर्ट्स के लिए डिफ़ॉल्ट बदलने के लिए sandbox_create (या sandbox_update) को preview_access: "private" पास करें। मौजूदा पोर्ट्स अपना स्वयं का मोड बनाए रखते हैं। सर्वर को sandbox_exec के साथ शुरू करें, फिर sandbox_preview_url कॉल करें; टूल आइडेम्पोटेंट रूप से उस एक पोर्ट को प्रकाशित करता है और लौटाए गए पोर्ट मोड का उपयोग करके या तो एक स्वच्छ सार्वजनिक URL या एक समाप्त होने वाला निजी हस्ताक्षरित URL लौटाता है। निजी लिंक डिफ़ॉल्ट रूप से एक घंटे के लिए होते हैं; expires_in_seconds को 1 से 604800 सेकंड के बीच के मान पर सेट करें। पूर्वावलोकन URL देखें।

अभी तक MCP सतह में नहीं

MCP सर्वर सामान्य एजेंट लूप को कवर करता है; उपरोक्त तालिका पूर्ण v1 टूल सेट है। कुछ SDK क्षमताएं अभी तक उजागर नहीं हैं — सीधे TypeScript SDK तक पहुंचें:

  • गुप्त (Secret) निर्माण — Secret.create() (MCP सर्वर केवल मौजूदा गुप्तों को बाइंड करता है)।
  • स्ट्रीमिंग और इंटरैक्टिव कमांड — स्ट्रीमिंग run() कॉलबैक और commands.spawn (stdin, सिग्नल, लंबे समय तक चलने वाली प्रक्रियाएँ)।
  • बड़े या स्ट्रीमिंग ट्रांसफर — डायरेक्टरी डाउनलोड sandbox_files_download_dir के माध्यम से 10 MiB तक समर्थित है; उससे अधिक (और आर्काइव/स्ट्रीमिंग अपलोड या 1 MiB रीड / 8 MiB इनलाइन-राइट सीमा से अधिक एकल फ़ाइलों के लिए), SDK/CLI का उपयोग करें (files.downloadDir, स्ट्रीमिंग अपलोड)।
  • बिलिंग और प्रदाता खोज — उपयोग डेटा और गुप्त-प्रदाता सेटअप के लिए Provider.list()।

इन्हें अनुवर्ती कार्यों के रूप में ट्रैक किया जाता है।

यह कैसे काम करता है

सर्वर TypeScript SDK को रैप करता है और केवल आपके कंट्रोल-प्लेन SUPERSERVE_API_KEY को रखता है। प्रत्येक टूल कॉल ID द्वारा लक्षित सैंडबॉक्स से जुड़ता है; SDK प्रति-सैंडबॉक्स डेटा-प्लेन एक्सेस टोकन को आंतरिक रूप से प्रबंधित करता है और रिज़्यूम पर इसे घुमाता है, इसलिए यह मॉडल को कभी उजागर नहीं होता या टूल आउटपुट में वापस नहीं आता। टूल स्टेटलेस हैं — कोई छिपा हुआ "वर्तमान सैंडबॉक्स" नहीं है — जो मल्टी-टर्न और समानांतर टूल कॉल में व्यवहार को पूर्वानुमेय रखता है।

समस्या निवारण

  • टूल दिखाई नहीं देते, या सर्वर शुरू नहीं होता। API कुंजी लगभग हमेशा कारण होती है — MCP क्लाइंट आपके शेल से पर्यावरण चर विरासत में नहीं लेते। सर्वर के env ब्लॉक में SUPERSERVE_API_KEY सेट करें (इंस्टॉल देखें), न कि केवल अपने टर्मिनल में।
  • Authentication failed। कुंजी गायब या अमान्य है। प्रोडक्शन कुंजियाँ ss_live_ से शुरू होती हैं; API कुंजी पृष्ठ पर एक बनाएँ।
  • पहली कॉल धीमी है। npx पहले उपयोग पर पैकेज डाउनलोड करता है और कैश करता है; बाद के स्टार्ट तेज़ होते हैं।
  • Node 18+ आवश्यक है। स्थानीय सर्वर npx के माध्यम से Node पर चलता है। (होस्टेड एंडपॉइंट में कोई स्थानीय रनटाइम आवश्यकता नहीं है।)
  • होस्टेड एंडपॉइंट से 401 Unauthorized। बियरर टोकन गायब है या मान्य ss_live_ कुंजी नहीं है। इसे Authorization: Bearer ss_live_… के रूप में भेजें (होस्टेड देखें)।

संबंधित

सैंडबॉक्स को रोकें, फिर से शुरू करें और हटाएँ। Exec, स्ट्रीमिंग, cwd, env और टाइमआउट। सैंडबॉक्स को उजागर किए बिना प्रदाता कुंजियाँ ब्रोकर करें। वह लाइब्रेरी जिसे MCP सर्वर रैप करता है।