SSD Nodes Learn Hosting plans →
गाइड Matt Connorलेखक: Matt Connor · अपडेट किया गया: 2026-08-27

VPS पर MCP server कैसे सेटअप करें: पूरी गाइड

अपने VPS पर MCP server चलाने का तरीका जानें। इस गाइड में stdio और remote HTTP transports, systemd कॉन्फ़िगरेशन, TLS सुरक्षा और JSON-RPC स्ट्रीम की समस्याओं का समाधान दिया गया है।

आप क्या बना रहे हैं

एक VPS पर दो कार्यशील MCP सेटअप। पहला एक stdio सर्वर है, जो एक filesystem या database टूल है जिसे Claude Code एक child process के रूप में लॉन्च करता है और pipe के माध्यम से उससे संवाद करता है। दूसरा एक remote HTTP सर्वर है, जो systemd और TLS युक्त nginx reverse proxy के पीछे एक long-lived network service के रूप में चलता है, और जिसे किसी भी MCP client द्वारा एक्सेस किया जा सकता है। दोनों का इंस्टॉलेशन छोटा है। इस गाइड का अधिकांश भाग उन दो मुख्य चुनौतियों पर केंद्रित है जो अक्सर समस्या पैदा करती हैं: JSON-RPC stream को साफ रखना, और किसी भी unauthenticated टूल endpoint को कभी भी public internet पर न डालना।

MCP वास्तव में क्या है

Model Context Protocol एक मानक तरीका है जिसके माध्यम से एक AI client, जैसे Claude Code, Claude Desktop, VPS पर Gemini CLI, या आपकी अपनी script, बाहरी tools को call कर सकता है और बाहरी resources को पढ़ सकता है। model स्वयं कुछ भी run नहीं करता है। यह client से अनुरोध करता है, client एक MCP server के साथ JSON-RPC 2.0 में संवाद करता है, और server tool को run करके परिणाम वापस भेजता है। वह client ही वह घटक है जिसे लोग agent harness कहते हैं: यह model के चारों ओर का वह loop है जो tool list, permission checks और session state का प्रबंधन करता है, और MCP केवल वह तरीका है जिससे आप इसके tool वाले हिस्से का विस्तार करते हैं। यह एक एकल protocol है, इसलिए आपके द्वारा लिखा गया एक server उन सभी clients के साथ काम करता है जो MCP का समर्थन करते हैं। यदि यह विभाजन आपके लिए नया है, और विशेष रूप से यह प्रश्न कि model किसी tool का उपयोग करने का निर्णय कैसे लेता है, तो इन servers को वास्तविक credentials देने से पहले agent fundamentals के क्रमिक मार्ग को समझने में एक घंटा बिताना सार्थक है।

इसके दो transports हैं, और इस guide का शेष भाग इन्हीं के आधार पर विभाजित है:

  • stdio. client server को एक child process के रूप में spawn करता है और अपने standard input तथा standard output के माध्यम से newline-delimited JSON-RPC messages का आदान-प्रदान करता है। इसमें कोई network, कोई port, या कोई auth नहीं होता; trust boundary स्वयं process ही होती है। लगभग सभी local tools इसी तरह काम करते हैं।
  • Streamable HTTP (और इसका पुराना संस्करण, HTTP+SSE). server एक long-running web service होता है। client HTTP के माध्यम से connect होता है और server Server-Sent Events के रूप में responses को stream कर सकता है। इसी तरह आप एक server को कई clients के साथ साझा करते हैं, या कोई ऐसा tool run करते हैं जिसे स्थायी रूप से machine पर रहना आवश्यक है।

जब tool एक machine और एक user से संबंधित हो, तो stdio चुनें। जब यह एक shared service हो, तो HTTP चुनें।

पूर्वापेक्षाएँ और व्यावहारिक चुनौतियाँ

मान लें कि आपके पास root या sudo एक्सेस के साथ एक नया Ubuntu 24.04 KVM VPS है। इसके अलावा:

  • सर्वर जिस runtime में लिखा गया है। अधिकांश reference servers Node या Python में हैं। Ubuntu 24.04 में Node 18 आता है, और कई वर्तमान MCP packages को Node 20 या उससे नए वर्ज़न की आवश्यकता होती है, इसलिए apt पर भरोसा करने के बजाय NodeSource या nvm से वर्तमान LTS वर्ज़न इंस्टॉल करें। Python 3.12 पहले से मौजूद है।
  • एक domain और DNS A record, लेकिन केवल remote HTTP सर्वर के लिए, क्योंकि TLS के लिए एक ऐसे नाम की आवश्यकता होती है जो इस VPS पर resolve हो सके। stdio उदाहरण के लिए किसी DNS की आवश्यकता नहीं है।
  • 512 MB RAM पर्याप्त है। MCP servers हल्के JSON-RPC processes होते हैं; मेमोरी की खपत इस पर निर्भर करती है कि आपका tool क्या उपयोग कर रहा है (जैसे database driver, file cache), न कि protocol पर।
  • यह spec अभी नया है और इसमें बदलाव हो रहे हैं। 2025-03-26 के revision ने HTTP+SSE को Streamable HTTP से बदल दिया है और SSE को deprecated घोषित कर दिया है। SSE अभी भी काम करता है और कई servers अभी भी इसका उपयोग करते हैं, इसलिए किसी भी transport pin को अंतिम सत्य मानने के बजाय सर्वर के release notes के अनुसार दोबारा जाँचें।

चरण 1: Claude Code में stdio सर्वर को वायर करना

Filesystem सर्वर से शुरुआत करें। यह आधिकारिक है, सक्रिय रूप से मेंटेन किया जाता है, और इसके लिए केवल Node की आवश्यकता होती है। नीचे दिया गया एक कमांड इसे Claude Code के साथ रजिस्टर करता है और इसे वर्तमान प्रोजेक्ट तक सीमित करता है, ताकि यह एक committable फाइल में सेव हो जाए:

cd /home/matt/projects/api
claude mcp add --scope project --transport stdio filesystem \
  -- npx -y @modelcontextprotocol/server-filesystem /home/matt/projects/api

-- सेपरेटर महत्वपूर्ण है: इसके बाद जो कुछ भी है, वह वह कमांड है जिसे Claude Code चलाएगा, न कि Claude Code के लिए कोई फ्लैग। यह प्रोजेक्ट रूट पर एक .mcp.json लिखता है:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/home/matt/projects/api"
      ]
    }
  }
}

अभी कुछ भी नहीं चल रहा है। जब आप अगली बार इस डायरेक्टरी में Claude Code शुरू करेंगे, तो एजेंट .mcp.json को पढ़ेगा, npx -y @modelcontextprotocol/server-filesystem ... को चाइल्ड प्रोसेस के रूप में spawn करेगा, और उस प्रोसेस के stdin/stdout पर MCP हैंडशेक करेगा। पुष्टि करें कि यह सफल रहा:

claude mcp list

एक सही ढंग से काम कर रहा सर्वर अपना कमांड और एक हरा टिक, filesystem: npx -y @modelcontextprotocol/server-filesystem ... - ✓ Connected प्रिंट करता है। सेशन के अंदर, /mcp स्लैश कमांड उन टूल्स को लिस्ट करता है जिन्हें सर्वर एक्सपोज करता है (read_file, write_file, list_directory), और एजेंट अब उन्हें आपके द्वारा अनुमति दी गई पाथ्स पर कॉल कर सकता है। एक डेटाबेस टूल का स्वरूप भी ऐसा ही होता है, बस पैकेज को बदलें और अंतिम आर्ग्युमेंट के रूप में कनेक्शन स्ट्रिंग पास करें। हालांकि, वर्तमान पैकेज नाम के लिए सर्वर की अपनी रिपॉजिटरी देखें, क्योंकि रेफरेंस Postgres सर्वर कई बार हैंडओवर हो चुका है।

एजेंट को बॉक्स पर चलाने का मुख्य उद्देश्य यही है: Claude Code सेशन VPS पर tmux के अंदर रहता है, और इसके stdio सर्वर सीधे प्रोजेक्ट फाइलों और लोकल सर्विसेज तक पहुंच के साथ इसके बगल में चलते हैं, जिसमें कोई नेटवर्क राउंड-ट्रिप नहीं होता। एक बार जब एजेंट के पास write_file के साथ-साथ read_file भी हो जाता है, तो उस पहुंच को ऐसी स्किल के साथ जोड़ना सार्थक है जो इसे सबसे छोटे काम करने वाले बदलाव की ओर ले जाए, क्योंकि एक filesystem टूल एक बड़े बदलाव (rewrite) को दो-लाइन के फिक्स जितना ही आसान बना देता है। यही वायरिंग लोकल फाइलों से आगे भी काम करती है: यदि आप पहले से ही VPS पर सर्च इंजन चला रहे हैं, तो आप एजेंट को अपना SearXNG इंस्टेंस सर्च टूल के रूप में दे सकते हैं, जो क्वेरीज को आपके बॉक्स पर ही रखता है लेकिन अनट्रस्टेड पेज टेक्स्ट को सीधे उस कॉन्टेक्स्ट में खींच लेता है जिस पर एजेंट फिर काम करता है।

चरण 2: एक रिमोट HTTP सर्वर बनाना

Stdio सर्वर अपने पैरेंट प्रोसेस के साथ समाप्त हो जाता है और प्रत्येक क्लाइंट के लिए एक बार स्पॉन होता है। इसलिए, यदि आप बॉक्स पर दो Claude Code सेशन चलाते हैं जो एक-दूसरे को काम सौंपते हैं, तो प्रत्येक को टूल की अपनी निजी कॉपी मिलती है। जब आपको ऐसा टूल चाहिए जो हर क्लाइंट के लिए चालू रहे, जैसे कि एक साझा ops टूल, डेटाबेस गेटवे, या कुछ ऐसा जिसे आपका लैपटॉप और CI दोनों कॉल करते हों, तो आपको HTTP ट्रांसपोर्ट और एक वास्तविक सर्विस की आवश्यकता होती है। यहाँ आधिकारिक SDK का उपयोग करने वाला एक न्यूनतम Python सर्वर है, जो एक टूल को एक्सपोज़ करता है:

# /opt/mcp-ops/server.py
from mcp.server.fastmcp import FastMCP
import subprocess

mcp = FastMCP("ops-tools", host="127.0.0.1", port=8000)

@mcp.tool()
def disk_free() -> str:
    """Return `df -h` for the server."""
    out = subprocess.run(["df", "-h"], capture_output=True, text=True)
    return out.stdout

if __name__ == "__main__":
    # Serves Streamable HTTP at /mcp on 127.0.0.1:8000
    mcp.run(transport="streamable-http")

ध्यान दें host="127.0.0.1"। सर्वर केवल localhost पर बाइंड होता है, बॉक्स के बाहर से कोई भी इसे सीधे एक्सेस नहीं कर सकता है, जो कि ऑथेंटिकेशन (auth) होने से पहले बिल्कुल वैसा ही है जैसा आप चाहते हैं। इसे अपने स्वयं के virtualenv में इंस्टॉल करें ताकि systemd के पास एक स्थिर इंटरप्रेटर पाथ हो:

sudo useradd --system --home /opt/mcp-ops --shell /usr/sbin/nologin mcp
sudo install -d -o mcp -g mcp /opt/mcp-ops
sudo -H -u mcp python3 -m venv /opt/mcp-ops/.venv
sudo -H -u mcp /opt/mcp-ops/.venv/bin/pip install "mcp[cli]"

चरण 3: systemd के साथ इसे चालू रखें

यदि कोई टूल तब डाउन हो जब एजेंट उसे एक्सेस करने की कोशिश करे, तो वह टूल न होने से भी बदतर है। यह तब सबसे अधिक मायने रखता है जब क्लाइंट स्वयं एक long-lived process हो: एक always-on agent जो रीबूट के बाद भी अपनी मेमोरी और शेड्यूल को बनाए रखता है वह इन टूल्स को बिना किसी की निगरानी के एक शेड्यूल पर कॉल करेगा, इसलिए सर्वर को अपने आप वापस आना चाहिए। /etc/systemd/system/mcp-ops.service लिखें:

[Unit]
Description=MCP ops-tools server
After=network.target

[Service]
Type=simple
User=mcp
WorkingDirectory=/opt/mcp-ops
ExecStart=/opt/mcp-ops/.venv/bin/python /opt/mcp-ops/server.py
Restart=on-failure
RestartSec=2
NoNewPrivileges=true
ProtectSystem=strict
ProtectHome=true

[Install]
WantedBy=multi-user.target

ExecStart में venv Python का absolute path वैकल्पिक नहीं है, इसे /usr/bin/python3 पर पॉइंट करें और प्रोसेस ModuleNotFoundError: No module named 'mcp' के साथ शुरू होगी, क्योंकि system interpreter ने कभी भी आपका pip install नहीं देखा था। इसे enable करें और जाँचें:

sudo systemctl daemon-reload
sudo systemctl enable --now mcp-ops
sudo systemctl status mcp-ops
curl -si -H 'Accept: application/json, text/event-stream' \
  -H 'Content-Type: application/json' \
  -X POST http://127.0.0.1:8000/mcp

status को active (running) पढ़ना चाहिए। curl वापस आता है HTTP/1.1 400 Bad Request, जिसमें बॉडी में एक JSON-RPC error होती है, अनुरोध में कोई session और कोई valid JSON payload नहीं था, और आप बिल्कुल यही चाहते हैं: यह साबित करता है कि पोर्ट जवाब देता है और प्रोटोकॉल का पालन करता है। Connection refused या खाली उत्तर का मतलब है कि प्रोसेस वहां bound नहीं है जहां आप सोचते हैं; journalctl -u mcp-ops -n 50 पढ़ें।

चरण 4: TLS और reverse proxy को सामने रखें

सर्वर localhost पर listen करता है। इसे कहीं से भी एक्सेस करने के लिए, आप nginx पर TLS terminate करें और traffic को अंदर proxy करें। nginx install करें, Certbot and Let's Encrypt on nginx का उपयोग करके certificate प्राप्त करें, और फिर location block लिखें। सबसे महत्वपूर्ण हिस्सा buffering को disable करना है, क्योंकि nginx का डिफ़ॉल्ट व्यवहार response को पूरा होने तक रोक कर रखता है, जिससे SSE stream हमेशा के लिए रुक जाती है:

server {
    listen 443 ssl;
    server_name mcp.example.com;

    # ssl_certificate lines managed by Certbot

    location /mcp {
        proxy_pass http://127.0.0.1:8000;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        proxy_set_header Host $host;

        # The four lines that make SSE work through nginx:
        proxy_buffering off;
        proxy_cache off;
        proxy_read_timeout 3600s;
        chunked_transfer_encoding off;
    }
}

sudo nginx -t && sudo systemctl reload nginx के साथ reload करें। यदि आप पहले से ही containers का उपयोग कर रहे हैं, तो यही काम आपके लिए Traefik reverse proxy with automatic TLS द्वारा किया जा सकता है; यह certificate जारी करता है और hostname के आधार पर routing करता है, और आपको बस MCP container में labels जोड़ने होते हैं। किसी भी स्थिति में, reverse proxy अब public port पर एकमात्र चीज़ है, और यह एक ऐसी service की ओर इशारा करता है जिसे आपने अभी तक सुरक्षित नहीं किया है। URL को कहीं भी register करने से पहले इसे ठीक करें।

चरण 5: सुरक्षा नियम जो इस विषय पर हावी है

बिना authentication वाला MCP endpoint कभी expose न करें। MCP server केवल read-only API नहीं है। यह आपके files, database और कभी-कभी shell तक tool access देता है। Public internet पर खुला हुआ /mcp किसी अनजान व्यक्ति को आपके AI agent जितनी ही पहुंच देता है: वह आपके tools की सूची देख सकता है और फिर उन्हें call कर सकता है। इसे ठीक उसी तरह unauthenticated admin socket मानें, क्योंकि वास्तव में यह वही है। चुराया गया token आपको कितना access देता है, यह उसके पीछे चल रहे server पर भी निर्भर करता है: openGym workout tracker के साथ आने वाला read-only MCP server केवल training data वापस दे सकता है, जबकि filesystem या shell tool पूरी machine तक पहुंच दे सकता है।

प्राथमिकता के क्रम में तीन सुरक्षा उपाय:

  1. इसे publish न करें। सर्वर को 127.0.0.1 पर रखें और अपने laptop से SSH tunnel के माध्यम से उस तक पहुँचें: ssh -L 8000:127.0.0.1:8000 matt@vps, फिर client को http://127.0.0.1:8000/mcp पर point करें। कुछ भी कभी expose नहीं होता।
  2. इसे private network पर रखें। इसे self-hosted WireGuard VPN के tunnel address पर bind करें और केवल VPN peers को ही इस तक पहुँचने दें। public internet को एक बंद port दिखाई देगा।
  3. यदि इसे public होना ही है, तो token की आवश्यकता रखें। सही उत्तर MCP OAuth flow है जिसे HTTP transport मूल रूप से support करता है। व्यावहारिक न्यूनतम उपाय proxy पर check किया जाने वाला एक shared bearer token है, जो सस्ता है और यह drive-by हमलों को पूरी तरह से रोकता है:
location /mcp {
    if ($http_authorization != "Bearer REPLACE_WITH_LONG_RANDOM") {
        return 401;
    }
    proxy_pass http://127.0.0.1:8000;
    # ...buffering-off block from above...
}

Token को openssl rand -hex 32 के साथ generate करें, और इनमें से किसी एक के बिना सर्वर को कभी भी 0.0.0.0 पर bind न करें। इसके बाद client token को header के रूप में भेजता है। Claude Code में:

claude mcp add --scope project --transport http ops-tools https://mcp.example.com/mcp \
  --header 'Authorization: Bearer ${MCP_TOKEN}'

अपने shell में MCP_TOKEN set करें ताकि secret कभी भी plaintext में .mcp.json में न जाए, Claude Code read time पर environment से ${MCP_TOKEN} को expand करता है।

ऊपर दिए गए सभी सुरक्षा उपाय agent के बजाय endpoint की रक्षा करते हैं, जिसके पास पहले से ही token होता है, जो समस्या का दूसरा हिस्सा है: यदि आपका client DeepSeek Harness है, तो plugins जो यह नियंत्रित करते हैं कि agent किन tools को call कर सकता है और injected instructions के लिए tool output को scan करते हैं उस पक्ष को कवर करते हैं।

Step 6: MCP Inspector के साथ debug करें

जब सर्वर ठीक से काम न करे, तो agent के भीतर से अनुमान लगाने के बजाय, इसे आधिकारिक वेब-आधारित test client, Inspector के साथ सीधे चलाएं। Stdio सर्वर के लिए, इसे वही कमांड दें जिसे agent चलाता है:

npx @modelcontextprotocol/inspector \
  npx -y @modelcontextprotocol/server-filesystem /tmp

यह http://localhost:6274 पर एक UI शुरू करता है (हाल के versions एक URL को MCP_PROXY_AUTH_TOKEN query string के साथ print करते हैं, उसी सटीक link का उपयोग करें अन्यथा UI आपको reject कर देगा) और 6277 पर एक proxy शुरू करता है। Connect पर click करें, फिर List Tools पर, और अंत में वास्तविक arguments के साथ Call Tool का उपयोग करें। यदि यह Inspector में काम करता है लेकिन agent में विफल रहता है, तो bug आपके client config में है, सर्वर में नहीं। Remote HTTP सर्वर के लिए, Streamable HTTP transport चुनें, https://mcp.example.com/mcp दर्ज करें, Authorization header जोड़ें, और connect करें। किसी भी agent के शामिल होने से पहले auth और proxy के सही होने की पुष्टि करने का यह सबसे तेज़ तरीका है।

सर्वर को अपडेट रखना

MCP तेजी से विकसित होता है, इसलिए एक निश्चित समय-सारणी के अनुसार पैच करें। npx -y के साथ लॉन्च किए गए Node सर्वर हर बार spawn होने पर नवीनतम संस्करण प्राप्त करते हैं, जो सुविधाजनक तो है लेकिन इसे reproduce करना कठिन है; जब कोई सर्वर महत्वपूर्ण हो जाए, तो उस सटीक संस्करण को पिन करें जिसका आपने परीक्षण किया है, इसे npm view @modelcontextprotocol/server-filesystem version से पढ़ें और .mcp.json (@modelcontextprotocol/server-filesystem@<version>) में पैकेज नाम के साथ जोड़ें, और इसे सोच-समझकर ही अपडेट करें। systemd के अंतर्गत चलने वाले Python सर्वर sudo -H -u mcp /opt/mcp-ops/.venv/bin/pip install -U "mcp[cli]" और उसके बाद sudo systemctl restart mcp-ops चलाकर अपडेट होते हैं। अपग्रेड करते समय उस spec revision पर ध्यान दें जिसे आपका SDK target करता है, क्योंकि SSE-से-Streamable-HTTP boundary के बीच का बदलाव उस transport को बदल सकता है जिसका आपके clients को अनुरोध करना चाहिए।

विफलता के प्रकार और दिखाई देने वाले संदेश

एजेंट दिखाता है कि सर्वर विफल हो गया है। claude mcp list प्रिंट करता है ✗ Failed to connect, और TUI रिपोर्ट करता है MCP server 'filesystem' failed to start। claude --debug चलाएं और आपको आमतौर पर Error: spawn npx ENOENT दिखाई देगा, यह कमांड एजेंट के PATH में नहीं है। रनटाइम गायब है या वहां नहीं है जहां एजेंट उसे खोज रहा है: Node इंस्टॉल नहीं है, npx अनुपस्थित है, या कोई virtualenv Python जिसे केवल नाम से संदर्भित किया गया है। कमांड को एब्सोल्यूट पाथ (absolute path) में बदलें या रनटाइम इंस्टॉल करें, फिर पुनः कनेक्ट करें।

एक stdio सर्वर कनेक्ट होता है, फिर तुरंत बंद हो जाता है। क्लाइंट लॉग में JSON पार्स एरर आता है, जैसे Unexpected token 'S', "Server sta"... is not valid JSON या Failed to parse message। इसका कारण हमेशा एक ही होता है: सर्वर ने stdout पर एक लॉग लाइन लिखी है। stdio पर, stdout ही JSON-RPC चैनल होता है, इसलिए कोई भी अतिरिक्त टेक्स्ट स्ट्रीम को दूषित कर देता है और हैंडशेक विफल हो जाता है। Node में, console.log stdout पर जाता है, इसके बजाय console.error का उपयोग करें। Python में, एक साधारण print() stdout पर जाता है, लॉग्स को logging के साथ लिखें जिसे sys.stderr पर कॉन्फ़िगर किया गया हो, या file=sys.stderr पास करें। नियम स्पष्ट है: stdio पर, stdout पर केवल JSON-RPC होना चाहिए, बाकी सब कुछ stderr पर।

एक रिमोट सर्वर टाइम आउट हो जाता है या हैंडशेक के बीच में बंद हो जाता है। क्लाइंट MCP error -32000: Connection closed के साथ विफल हो जाता है, या इंस्पेक्टर Connect पर अटक जाता है और टूल्स की सूची नहीं दिखाता है। nginx के पीछे इसका कारण बफरिंग है: प्रॉक्सी SSE स्ट्रीम को फ्लश करने के बजाय उसे होल्ड कर लेती है, इसलिए क्लाइंट उस रिस्पॉन्स की प्रतीक्षा करता है जो कभी नहीं आता। proxy_buffering off; (और स्टेप 4 का शेष ब्लॉक) को location में जोड़ें। पब्लिक URL के विरुद्ध curl -N के साथ पुष्टि करें, आपको इवेंट डेटा धीरे-धीरे आता हुआ दिखना चाहिए, न कि अंत में एक साथ।

ऑथेंटिकेशन अस्वीकार कर दिया गया है। क्लाइंट Error POSTing to endpoint (HTTP 401) रिपोर्ट करता है या स्पष्ट रूप से 401 Unauthorized दिखाता है। या तो हेडर गायब है, टोकन गलत है, या क्लाइंट द्वारा कॉन्फ़िगरेशन पढ़ते समय शेल वेरिएबल खाली था। यह एक सामान्य समस्या है, क्योंकि यदि वेरिएबल सेट नहीं है तो ${MCP_TOKEN} कुछ भी एक्सपैंड नहीं करता है और nginx को Bearer बिना किसी वैल्यू के मिलता है। वेरिएबल को echo करें, हेडर को पुनः जोड़ें, और सत्यापित करें कि बाइट्स nginx if में मौजूद टोकन से बिल्कुल मेल खाते हैं।

सर्विस systemd के तहत स्टार्ट नहीं हो रही है। journalctl -u mcp-ops दिखाता है ModuleNotFoundError: No module named 'mcp', ExecStart venv इंटरप्रेटर के बजाय सिस्टम Python की ओर इशारा करता है। या Address already in use, कोई अन्य प्रोसेस 8000 पोर्ट का उपयोग कर रही है; इसे sudo ss -ltnp | grep 8000 के साथ खोजें।

FAQ

MCP server वास्तव में क्या है?

यह एक ऐसा प्रोग्राम है जो Model Context Protocol के माध्यम से JSON-RPC 2.0 का उपयोग करके AI client को tools और resources उपलब्ध कराता है। AI model कभी भी स्वयं tool को run नहीं करता है, बल्कि वह अपने client से अनुरोध करता है, client MCP server को call करता है, और server उसे निष्पादित (execute) करके परिणाम वापस भेजता है। चूंकि यह protocol मानक है, इसलिए एक server किसी भी compliant client के साथ काम करता है, चाहे वह Claude Code हो, Claude Desktop हो, या Gemini CLI हो।

stdio और HTTP transport में क्या अंतर है?

एक stdio server को client द्वारा child process के रूप में launch किया जाता है और यह stdin/stdout के माध्यम से संचार करता है, इसलिए यह एक मशीन पर एक client के साथ ही चलता है और इसे किसी network या auth की आवश्यकता नहीं होती है। एक HTTP server एक लंबे समय तक चलने वाली network service है जिसे कई clients एक साथ access कर सकते हैं, इसीलिए इसे TLS और authentication की आवश्यकता होती है। स्थानीय, single-user tools के लिए stdio का उपयोग करें; किसी भी साझा या persistent सेवा के लिए HTTP (वर्तमान servers पर Streamable HTTP) का उपयोग करें।

मैं remote MCP server को सुरक्षित कैसे करूँ?

यह मानकर चलें कि यह आपकी फाइलों, database या shell तक tool access प्रदान करता है, और इसे कभी भी बिना authentication के expose न करें। सबसे अच्छा तरीका यह है कि इसे localhost तक सीमित रखें और SSH tunnel या private VPN के माध्यम से access करें; यदि इसे public होना ही है, तो इसे एक reverse proxy के पीछे रखें जो bearer token या MCP OAuth flow को लागू करता हो। openssl rand -hex 32 के साथ token generate करें और इनके बिना server को कभी भी 0.0.0.0 पर bind न करें।

मैं उस server को debug कैसे करूँ जो start नहीं हो रहा है?

सबसे पहले claude mcp list, ✗ Failed to connect की जाँच करें। spawn ... ENOENT का अर्थ है कि command या runtime मौजूद नहीं है, इसलिए path को ठीक करें या उसे install करें। यदि यह connect होता है और फिर JSON parse error के साथ बंद हो जाता है, तो server stdout पर logging कर रहा है और JSON-RPC stream को दूषित कर रहा है; सभी logging को stderr पर ले जाएं। किसी अन्य समस्या के लिए, MCP Inspector के तहत सटीक command चलाएं, जो server को अलग-थलग (isolation) चलाता है ताकि आप server bug और client-config bug के बीच अंतर बता सकें।

#mcp#claude-code#ai-agents#सेल्फ़-होस्टिंग#systemd