असिस्टेंट के लिए Signal Lab: `signallab mcp`

signallab mcp एक Model Context Protocol सर्वर है। Claude Code, Claude Desktop, Cursor, VS Code या किसी भी दूसरे MCP क्लाइंट में मौजूद असिस्टेंट इसे शुरू करता है और फिर:

जान सकता है कि प्रयोग किन चीज़ों से बनता है, एक प्रयोग लिख सकता है, उसे जाँच सकता है, चला सकता है और चरण-दर-चरण पढ़ सकता है कि वह क्यों विफल हुआ;
एक OSC संदेश, डेटाग्राम, HTTP रिक्वेस्ट, WebSocket संदेश या MQTT पब्लिश भेज सकता है, और किसी पोर्ट पर सुन सकता है कि कोई डिवाइस क्या भेजता है;
आपकी लाइब्रेरी का कोई सिग्नल भेज सकता है;
किसी डिपेंडेंसी की भूमिका निभा सकता है — HTTP API, OSC, UDP या TCP डिवाइस, MQTT ब्रोकर — और पढ़ सकता है कि आपके सिस्टम ने उसे क्या भेजा;
पिछले रन फिर से पढ़ सकता है और उनमें से दो की तुलना कर सकता है।

हर क्रिया उन्हीं इंजन कमांड से होकर जाती है जिनका ऐप उपयोग करता है, इसलिए असिस्टेंट जो प्रयोग चलाता है, वह वही रन है जो ऐप बनाता, उसी रिपोर्ट के साथ, और हर विफलता उन्हीं शब्दों में बताई जाती है जिनमें इंटरफ़ेस बताता है।

WARNING

भेजना, रन और एमुलेटर नेटवर्क पर असली ट्रैफ़िक डालते हैं। असिस्टेंट को बताएँ कि किन डिवाइस से बात करना आपके अधिकार में है; साथ आने वाले टेम्पलेट लूपबैक (127.0.0.1) की ओर इशारा करते हैं।

इसे सेट अप करना

signallab डेस्कटॉप ऐप के साथ आता है और उसे इंस्टॉल करने के बाद आपके PATH में होता है (देखें इंस्टॉल करना)। क्लाइंट signallab mcp को ख़ुद शुरू करता है और stdin और stdout पर उससे बात करता है; आप इसे हाथ से नहीं चलाते।

कॉन्फ़िगरेशन छापना

--print-config वह छापता है जो क्लाइंट को चाहिए, इस signallab के पूरे पथ के साथ:

कमांड	यह क्या छापती है
`signallab mcp --print-config claude-code`	`claude mcp add` कमांड लाइन।
`signallab mcp --print-config claude-desktop`	Claude Desktop की कॉन्फ़िगरेशन फ़ाइल के लिए `mcpServers` प्रविष्टि।
`signallab mcp --print-config cursor`	वही `mcpServers` प्रविष्टि, Cursor की `mcp.json` के लिए।
`signallab mcp --print-config vscode`	VS Code की `.vscode/mcp.json` के लिए `servers` प्रविष्टि।

लैब सर्वर पर काम करने वाले असिस्टेंट के लिए --server URL जोड़ें: तब छपी हुई कॉन्फ़िगरेशन में यह होता है, टोकन के लिए एक प्लेसहोल्डर के साथ।

Claude Code

--print-config claude-code जो पंक्ति छापता है, उसे चलाएँ, उदाहरण के लिए:

bash

claude mcp add signallab -- "C:\Program Files\Signal Lab\signallab.exe" mcp

Claude Desktop और Cursor

प्रविष्टि को क्लाइंट की कॉन्फ़िगरेशन में रखें — Claude Desktop के लिए claude_desktop_config.json; Cursor के लिए mcp.json — और क्लाइंट को रीस्टार्ट करें:

json

{
  "mcpServers": {
    "signallab": {
      "command": "C:\\Program Files\\Signal Lab\\signallab.exe",
      "args": ["mcp"],
      "env": {}
    }
  }
}

VS Code

json

{
  "servers": {
    "signallab": {
      "type": "stdio",
      "command": "/usr/bin/signallab",
      "args": ["mcp"],
      "env": {}
    }
  }
}

दूसरे क्लाइंट

stdio सर्वर शुरू करने वाला कोई भी क्लाइंट इसी तरह काम करता है: कमांड signallab (या उसका पूरा पथ) है, आर्ग्युमेंट mcp और कोई भी विकल्प। Linux पर सर्वर इमेज भी कमांड का काम कर सकती है:

bash

docker run -i --rm --network host --entrypoint signallab ghcr.io/proanima/signallab:1.0.0 mcp

विकल्प

विकल्प	यह क्या करता है	डिफ़ॉल्ट
`--server URL`	प्रयोग, भेजना और एमुलेटर इस Signal Lab सर्वर पर चलाएँ (देखें लैब सर्वर पर)।	`SIGNALLAB_SERVER`
`--token-file PATH`	सर्वर का टोकन रखने वाली फ़ाइल।	`SIGNALLAB_TOKEN_FILE`, वरना `SIGNALLAB_TOKEN`
`--data-dir PATH`	रन और उनकी रिपोर्ट कहाँ रखी जाती हैं। `--server` के साथ नहीं।	ऐप का डेटा फ़ोल्डर (`Documents/SignalLab`)
`--library PATH`	`list_signals` और `fire_signal` के लिए सिग्नल लाइब्रेरी।	ऐप की `signals.json`
`--emulators PATH`	`list_emulators` और `start_emulator` के लिए एमुलेटर लाइब्रेरी।	ऐप की `emulators.json`
`--secrets files\|system`	इस मशीन पर रन के लिए सीक्रेट मान कहाँ से आते हैं, जैसे `run` में। `--server` के साथ नहीं।	`files`
`--secrets-dir PATH`	सीक्रेट फ़ाइलों का फ़ोल्डर, हर नाम के लिए एक। `--server` के साथ नहीं।	`/run/secrets/signallab`, अगर मौजूद हो
`--lang <code>`	परिणामों और विफलताओं की भाषा।	`SIGNALLAB_LANG`, वरना लोकेल, वरना `en`
`--print-config CLIENT`	किसी क्लाइंट की कॉन्फ़िगरेशन छापें और बाहर निकलें: `claude-code`, `claude-desktop`, `cursor` या `vscode`।

रन अपनी रिपोर्ट ऐप के डेटा फ़ोल्डर में रखते हैं, जहाँ ऐप अपनी रखता है, इसलिए वे सेशन के बाद भी बनी रहती हैं।

टूल

जो टूल केवल पढ़ते हैं, उन पर read-only का निशान होता है, ताकि क्लाइंट उन्हें बिना पूछे चलने दे सके। जो टूल बाहरी दुनिया तक पहुँचते हैं — कुछ भेजते हैं, सुनते हैं या शुरू करते हैं — उन पर भी इसका निशान होता है, और क्लाइंट हर कॉल से पहले आपसे पूछ सकता है। किसी पर भी destructive का निशान नहीं है।

टूल	यह क्या करता है	बाहरी दुनिया तक पहुँचता है
`describe_nodes`	प्रयोग दस्तावेज़, हर तरह का नोड अपने फ़ील्ड, आउटपुट और एक उदाहरण के साथ, `{{template}}` भाषा, लोड प्रोफ़ाइल और एमुलेटर दस्तावेज़।	नहीं
`list_templates`	साथ आने वाले प्रयोग, उनके पैरामीटर के साथ।	नहीं
`get_template`	साथ आने वाला एक प्रयोग, दस्तावेज़ के रूप में।	नहीं
`validate_experiment`	प्रयोग को वैसे ही जाँचता है जैसे एडिटर रन से पहले जाँचता है; कुछ नहीं भेजता।	नहीं
`run_experiment`	प्रयोग को अंत तक चलाता है और हर चरण की रिपोर्ट देता है।	हाँ
`send_osc`	एक OSC संदेश।	हाँ
`send_udp`	एक UDP डेटाग्राम।	हाँ
`send_http`	एक HTTP रिक्वेस्ट।	हाँ
`send_mqtt`	एक MQTT 3.1.1 पब्लिश।	हाँ
`send_ws`	एक WebSocket आदान-प्रदान।	हाँ
`listen`	कुछ देर तक किसी UDP पोर्ट पर क्या आता है।	हाँ
`list_signals`	आपकी लाइब्रेरी के सिग्नल।	नहीं
`fire_signal`	लाइब्रेरी का कोई सिग्नल भेजता है।	हाँ
`list_emulators`	आपकी लाइब्रेरी के एमुलेटर।	नहीं
`start_emulator`	कोई एमुलेटर शुरू करता है।	हाँ
`emulator_exchanges`	चल रहे एमुलेटर को क्या मिला और उसने क्या जवाब दिया।	नहीं
`set_emulator_down`	चल रहे एमुलेटर को बंद करता है, या वापस चालू करता है।	हाँ
`list_runs`	पिछले रन की रिपोर्ट।	नहीं
`compare_runs`	दो रन, आमने-सामने।	नहीं
`list_jobs`	क्या चल रहा है।	नहीं
`stop_job`	चल रहा जॉब रोकता है।	हाँ

प्रयोग

प्रयोग लिखने से पहले असिस्टेंट describe_nodes पढ़ता है; यह signallab nodes जैसा ही है। list_templates और get_template चलाने या ढालने के लिए काम करने वाले उदाहरण देते हैं।

validate_experiment और run_experiment प्रयोग को तीन में से किसी एक तरीके से लेते हैं — ठीक एक से:

आर्ग्युमेंट	यह क्या है
`document`	प्रयोग दस्तावेज़, जैसा ऐप उसे सहेजता है।
`file`	उस मशीन पर प्रयोग फ़ाइल का पथ, जिस पर `signallab` चलता है।
`template`	साथ आने वाले किसी टेम्पलेट का नाम।
`params`	इस रन के लिए पैरामीटर मान: `{"name": "value"}`; संख्याएँ और बूलियन टेक्स्ट के रूप में लिए जाते हैं।
`profile`	दस्तावेज़ की इस प्रोफ़ाइल के साथ चलाएँ; डिफ़ॉल्ट के लिए `""`।
`seed`	`run_experiment`: रैंडम मानों का सीड।
`timeout`	`run_experiment`: रन को कितने सेकंड लग सकते हैं, 1 से 300 (डिफ़ॉल्ट 300)।

run_experiment रन समाप्त होने पर जवाब देता है: सफल, विफल या रोका गया, उसकी अवधि और सीड, हर चरण और उसने क्या किया या वह क्यों विफल हुआ, हर एमुलेटर से क्या माँगा गया, हर बाधा रिले ने क्या किया, और रिपोर्ट का पथ। विफल होने वाला रन एक सामान्य जवाब है — चरण बताते हैं कि क्यों — कोई विफल कॉल नहीं।

अकेले संदेश

टूल	आर्ग्युमेंट
`send_osc`	`target` (`host:port`), `address`, `args`: संख्याएँ (पूर्णांक → int32, या उसकी सीमा से बाहर int64; वरना float32), स्ट्रिंग, बूलियन, `null`, या `{"type": "int"\|"float"\|"str"\|"long"\|"double"\|"bool"\|"blob"\|"nil", "value": …}`।
`send_udp`	`target`, और `text` या `hex` (`"de ad be ef"`)।
`send_http`	`method`, `url`, `headers` (`{"Name": "value"}`), `body`, `timeout_ms` (डिफ़ॉल्ट 10000), `auth`: `{"scheme": "basic"\|"digest", "username", "password"}` या `{"scheme": "bearer", "token"}`। स्टेटस, समय, हेडर और बॉडी — उसके पहले 16 KiB — लौटाता है।
`send_mqtt`	`broker` (`host:port`, पोर्ट न हो तो 1883), `topic`, `payload`, `qos` (0, 1 या 2), `retain`। `retain` के साथ ख़ाली पेलोड retained मान साफ़ करता है।
`send_ws`	`url` (`ws://` या `wss://`), `text` या `hex`, `headers`, `protocols`, और जवाब की प्रतीक्षा के लिए `expect` (शामिल है), `expect_regex` या `wait` (कोई भी संदेश); `timeout_ms` 1 से 120000 (डिफ़ॉल्ट 2000)। हैंडशेक, जो भेजा गया और जवाब लौटाता है, JSON होने पर उसे पार्स करके।

ये वही कमांड हैं जिनका ऐप की स्क्रीन उपयोग करती हैं; देखें signallab send।

सुनना

listen कुछ देर के लिए उस मशीन पर जिस पर signallab mcp चलता है एक UDP पोर्ट खोलता है, और जो आया उसे लौटाता है: OSC संदेश डिकोड करके, बाकी डेटाग्राम टेक्स्ट और hex के रूप में।

आर्ग्युमेंट	यह क्या है	डिफ़ॉल्ट
`bind`	`IP:port`, जैसे `0.0.0.0:9000`।	ज़रूरी
`protocol`	`osc` या `udp`।	`osc`
`seconds`	कितनी देर सुनना है, 0.1 से 60।	5
`max`	इतने डेटाग्राम के बाद रुकें, 1 से 1000।	100

जब 0.0.0.0 पर कुछ नहीं आता, तो जवाब असिस्टेंट को फ़ायरवॉल जाँचने की याद दिलाता है (signallab doctor)। --server के साथ listen अस्वीकार किया जाता है: सर्वर पर, प्रतीक्षा नोड वाला प्रयोग वहीं सुनता है।

सिग्नल और एमुलेटर

list_signals और fire_signal आपकी सिग्नल लाइब्रेरी का उपयोग करते हैं — ऐप की signals.json, --library, या कॉल को दिया गया library पथ। सिग्नल उसकी id या नाम से भेजा जाता है, ठीक वैसे ही जैसे ऐप उसे भेजता है।

list_emulators आपकी लाइब्रेरी के एमुलेटर के नाम बताता है। start_emulator एक शुरू करता है — emulator में दस्तावेज़, या name में लाइब्रेरी प्रविष्टि की id या नाम — और उसकी जॉब id और पता लौटाता है; यह stop_job तक अपने नियमों से जवाब देता है। bind उसे दूसरे IP:port पर ले जाता है, params वे मान देता है जिन्हें उसके टेम्पलेट पढ़ते हैं, seed उसके रैंडम चुनाव तय करता है। emulator_exchanges (job_id, और केवल नए आदान-प्रदान के लिए after) बताता है कि क्या आया और हर नियम ने क्या जवाब दिया। set_emulator_down (job_id, down, और fault: unavailable, reset या timeout) चल रहे एमुलेटर का प्लग तब तक खींच देता है जब तक उसे फिर से चालू न किया जाए: HTTP को फ़ॉल्ट मिलता है (unavailable का जवाब 503 है), TCP डिवाइस और MQTT ब्रोकर कनेक्शन तोड़ देते हैं, OSC और UDP कोई जवाब नहीं देते। देखें एमुलेटर।

रन और जॉब

list_runs पिछले रन की रिपोर्ट पढ़ता है, सबसे नई सबसे पहले — जब experiment किसी प्रयोग का नाम दे, तो केवल उसकी, अधिकतम limit (1 से 500, डिफ़ॉल्ट 50) — हर लोड चरण के आँकड़ों के साथ। compare_runs उनमें से दो के नाम लेता है, a (पहले) और b (बाद में), और हर लोड चरण की लेटेंसी, त्रुटि दर, हासिल की गई दर और छूटी रिक्वेस्ट को आमने-सामने रखता है, और ग़लत दिशा में 5 % या उससे अधिक के बदलाव को रिग्रेशन के रूप में चिह्नित करता है। देखें रन और रिपोर्ट।

list_jobs बताता है कि क्या चल रहा है — मॉनिटर, जनरेटर, एमुलेटर, रन — और stop_job किसी एक को उसकी id से रोकता है।

परिणाम और त्रुटियाँ

हर जवाब मॉडल के लिए टेक्स्ट होता है और वही संरचित डेटा के रूप में भी। विफलता पर त्रुटि का निशान होता है और उसमें इंजन की त्रुटि होती है — एक स्थिर code, उसके मान, वह नोड और फ़ील्ड जिसके बारे में वह है — जिसे --lang से चुनी गई भाषा में लिखा जाता है। जो आर्ग्युमेंट असिस्टेंट ने ग़लत दिए, वे ऐसे शब्दों में लौटते हैं जिनसे वह उन्हें सुधार सके।

प्रगति और रद्द करना

जब क्लाइंट run_experiment पर प्रगति माँगता है, तो हर चरण होते ही बताया जाता है (नोड और उसकी स्थिति), ताकि असिस्टेंट — और आप — रन को आगे बढ़ते देख सकें। कॉल रद्द करने से वह रुक जाती है; run_experiment रद्द करने से रन ही रुक जाता है, जैसे ऐप में रोकें करता है।

जब क्लाइंट कनेक्शन बंद करता है, तो जो कॉल अभी चल रही हैं वे पूरी होती हैं, फिर signallab mcp बाहर निकल जाता है।

लैब सर्वर पर

--server http://192.0.2.10:1430 के साथ प्रयोग, भेजना, सिग्नल और एमुलेटर उस सर्वर पर होते हैं, उसके API के ज़रिए — उसके नेटवर्क, उसके सीक्रेट और उसके डेटा फ़ोल्डर के साथ — ताकि असिस्टेंट उन उपकरणों तक पहुँचे जिन तक केवल लैब पहुँच सकती है। टोकन क्लाइंट के एनवायरनमेंट में दें:

json

{
  "mcpServers": {
    "signallab": {
      "command": "signallab",
      "args": ["mcp", "--server", "http://192.0.2.10:1430"],
      "env": { "SIGNALLAB_TOKEN": "<the server's token>" }
    }
  }
}

इस मशीन पर क्या रहता है: सिग्नल और एमुलेटर लाइब्रेरी (ऐप की, या --library और --emulators) और किसी कॉल में नामित फ़ाइलें (file, library) यहीं पढ़ी जाती हैं, और उनमें जो है वह सर्वर को भेजा जाता है; listen अस्वीकार किया जाता है। देखें Signal Lab को सर्वर के रूप में चलाना।

सुरक्षा

असिस्टेंट केवल वही कर सकता है जो टूल करते हैं, और हर टूल ऐप की अपनी कमांड में से एक है: वह ऐसी किसी चीज़ तक नहीं पहुँच सकता जहाँ तक ऐप नहीं पहुँच सकता।
जो टूल कुछ भेजते हैं, सुनते हैं या शुरू करते हैं, उन पर बाहरी दुनिया तक पहुँचने का निशान होता है; आपका क्लाइंट तय करता है कि हर कॉल से पहले आपसे पूछे या नहीं।
सीक्रेट मान कभी असिस्टेंट तक नहीं पहुँचते: प्रयोग उन्हें {{secret.NAME}} के रूप में नाम देता है, और हर परिणाम में उनकी जगह •••• दिखता है।
एमुलेटर या लिसनर उस मशीन पर पोर्ट खोलता है जिस पर वह चलता है; list_jobs और stop_job दिखाते और समाप्त करते हैं कि अभी भी क्या चल रहा है।

प्रोटोकॉल

क्लाइंट लिखने वालों के लिए: stdio पर JSON-RPC 2.0, हर पंक्ति में एक संदेश; stdout पर केवल प्रोटोकॉल संदेश होते हैं, और किसी व्यक्ति के लिए कुछ भी stderr पर जाता है। प्रोटोकॉल संस्करण 2025-06-18, 2025-03-26 और 2024-11-05 (क्लाइंट कोई और माँगे, तो सबसे नया), बैच, ping, tools/list और tools/call; progressToken भेजने वाली कॉल के लिए प्रगति notifications/progress के रूप में, और रद्द करना notifications/cancelled से। सर्वर के instructions मॉडल को बताते हैं कि टूल आपस में कैसे जुड़ते हैं।

असिस्टेंट के लिए Signal Lab: signallab mcp ​

इसे सेट अप करना ​

कॉन्फ़िगरेशन छापना ​

Claude Code ​

Claude Desktop और Cursor ​

VS Code ​

दूसरे क्लाइंट ​

विकल्प ​

टूल ​

प्रयोग ​

अकेले संदेश ​

सुनना ​

सिग्नल और एमुलेटर ​

रन और जॉब ​

परिणाम और त्रुटियाँ ​

प्रगति और रद्द करना ​

लैब सर्वर पर ​

सुरक्षा ​

प्रोटोकॉल ​

असिस्टेंट के लिए Signal Lab: `signallab mcp`

इसे सेट अप करना

कॉन्फ़िगरेशन छापना

Claude Code

Claude Desktop और Cursor

VS Code

दूसरे क्लाइंट

विकल्प

टूल

प्रयोग

अकेले संदेश

सुनना

सिग्नल और एमुलेटर

रन और जॉब

परिणाम और त्रुटियाँ

प्रगति और रद्द करना

लैब सर्वर पर

सुरक्षा

प्रोटोकॉल