VPSలో MCP servers ఎలా రన్ చేయాలి AI కోడింగ్ కోసం

మీరు నిర్మించేది

ఒక VPSపై రెండు పనిచేసే MCP సెటప్‌లు. మొదటగా ఒక stdio సర్వర్ — ఒక ఫైల్‌సిస్టమ్ లేదా డేటాబేస్ టూల్, దీన్ని Claude Code ఒక చైల్డ్ ప్రాసెస్‌గా ప్రారంభిస్తుంది మరియు పైప్ ద్వారా సంభాషిస్తుంది. తరువాత ఒక రిమోట్ HTTP సర్వర్, అది systemd మరియు TLSతో nginx రివర్స్ ప్రాక్సీ వెనుక ఒక దీర్ఘకాలిక నెట్‌వర్క్ సర్వీస్‌గా నడుస్తుంది, మీరు సూచించే ఏ MCP క్లయింట్ నుండి అయినా చేరుకోవచ్చు. రెండింటి ఇన్‌స్టాలేషన్ కూడా చిన్నదే. ఈ గైడ్‌లో ఎక్కువ భాగం వాస్తవానికి సమస్య కలిగించే రెండు అంశాలకు సంబంధించింది: JSON-RPC స్ట్రీమ్‌ను శుద్ధిగా ఉంచడం, మరియు పబ్లిక్ ఇంటర్నెట్‌పై ధృవీకరణ లేని టూల్ ఎండ్‌పాయింట్‌ను ఎప్పుడూ ఉంచకపోవడం.

MCP నిజంగా ఏమిటి

మోడల్ కాంటెక్స్ట్ ప్రోటోకాల్ అనేది ఒక AI క్లయింట్ — Claude Code, Claude Desktop, VPSలో Gemini CLI, లేదా మీ స్వంత స్క్రిప్ట్ — బాహ్య సాధనాలను పిలిచి బాహ్య వనరులను చదివే ఒక ప్రామాణిక మార్గం. మోడల్ ప్రత్యేకంగా ఏదీ నడపదు. అది క్లయింట్‌ను అభ్యర్థిస్తుంది. క్లయింట్, MCP సర్వర్‌తో JSON-RPC 2.0 లో మాట్లాడుతుంది. సర్వర్ ఆ సాధనాన్ని నడుపుతుంది. ఫలితాన్ని తిరిగి ఇస్తుంది. ఇది ఒకే ప్రోటోకాల్. కాబట్టి మీరు ఒకసారి వ్రాసిన సర్వర్, MCP మాట్లాడే ప్రతి క్లయింట్‌తో పనిచేస్తుంది.

రెండు రవాణా పద్ధతులు ఉన్నాయి. ఈ గైడ్ మొత్తం మిగిలిన భాగం వాటిని బట్టి రెండుగా విభజించబడింది:

• stdio. క్లయింట్ సర్వర్‌ను ఒక చైల్డ్ ప్రాసెస్‌గా ప్రారంభిస్తుంది. దాని స్టాండర్డ్ ఇన్‌పుట్ మరియు స్టాండర్డ్ అవుట్‌పుట్ ద్వారా న్యూలైన్-డిలిమిటెడ్ JSON-RPC సందేశాలను మార్పిడి చేసుకుంటుంది. నెట్‌వర్క్, పోర్ట్, ఆథ్ ఏవీ ఉండవు — విశ్వాస హద్దు ఆ ప్రాసెస్ ప్రత్యేకం. దాదాపు ప్రతి లోకల్ సాధనం ఈ విధంగానే వస్తుంది.
• Streamable HTTP (మరియు దాని పాత రూపం, HTTP+SSE). సర్వర్ అనేది ఎక్కువ సేపు నడిచే వెబ్ సేవ. క్లయింట్ HTTP ద్వారా కనెక్ట్ అవుతుంది. సర్వర్ ప్రత్యుత్తరాలను Server-Sent Events గా స్ట్రీమ్ చేస్తుంది. ఒకే సర్వర్‌ను అనేక క్లయింట్‌లతో పంచుకోవడానికి, లేదా శాశ్వతంగా ఆ బాక్స్‌లో ఉండాల్సిన సాధనాన్ని నడపడానికి ఇదే మార్గం.

సాధనం ఒకే మెషీన్‌కు, ఒకే వినియోగదారునికి చెందినప్పుడు stdio ఎంచుకోండి. అది ఒక భాగస్వామ్య సేవ అయినప్పుడు HTTP ఎంచుకోండి.

ముందస్తు అవసరాలు మరియు ఆచరణాత్మక సమస్యలు

root లేదా sudo హక్కులతో కొత్త Ubuntu 24.04 KVM VPS ఉందని అనుకోండి. దీనికి మించి:

• సర్వర్ రాయడానికి ఒక రన్‌టైమ్. చాలా రిఫరెన్స్ సర్వర్‌లు Node లేదా Python లో ఉంటాయి. Ubuntu 24.04 లో Node 18 అంతర్గతంగా వస్తుంది. ప్రస్తుత MCP ప్యాకేజీలకు Node 20 లేదా అంతకంటే కొత్త వెర్షన్ కావాలి. కాబట్టి apt పై ఆధారపడకుండా NodeSource లేదా nvm నుండి ప్రస్తుత LTS వెర్షన్‌ను ఇన్‌స్టాల్ చేయండి. Python 3.12 ఇప్పటికే అందుబాటులో ఉంది.
• ఒక డొమైన్ మరియు DNS A రికార్డ్, కానీ అది రిమోట్ HTTP సర్వర్‌కు మాత్రమే — TLS కు ఈ VPS కి పరిష్కరించే ఒక పేరు కావాలి. stdio ఉదాహరణకు DNS అసలు అవసరం లేదు.
• 512 MB RAM సరిపోతుంది. MCP సర్వర్‌లు చిన్న JSON-RPC ప్రాసెస్‌లు. మెమరీ ఖర్చు మీ టూల్ ఏమి ఉపయోగిస్తుందో (డేటాబేస్ డ్రైవర్, ఫైల్ క్యాష్) దానిపై ఆధారపడి ఉంటుంది, ప్రోటోకాల్ పై కాదు.
• స్పెక్ ఇంకా కొత్తది మరియు మారుతోంది. 2025-03-26 రివిజన్ HTTP+SSE స్థానంలో Streamable HTTP ను తీసుకువచ్చింది. SSE ని డిప్రికేటెడ్‌గా గుర్తించింది. SSE ఇంకా పనిచేస్తుంది. చాలా సర్వర్‌లు దాన్ని ఇంకా ఉపయోగిస్తున్నాయి. కాబట్టి ఏ ట్రాన్స్‌పోర్ట్ పిన్‌నైనా నిశ్చితాంశంగా కాకుండా, సర్వర్ రిలీజ్ నోట్స్‌తో సరిపోల్చి మళ్లీ తనిఖీ చేయండి.

దశ 1: stdio సర్వర్‌ను Claude Code లోకి అనుసంధానించండి

ఫైల్‌సిస్టమ్ సర్వర్‌తో ప్రారంభించండి — ఇది అధికారికమైనది, క్రియాశీలంగా నిర్వహించబడుతున్నది, మరియు Node తప్ప మరేమీ అవసరం లేదు. దిగువ ఒక్క కమాండ్ దాన్ని Claude Code తో నమోదు చేస్తుంది. అలాగే దాన్ని ప్రస్తుత ప్రాజెక్ట్‌కు పరిమితం చేస్తుంది, తద్వారా అది కమిట్ చేయదగిన ఫైల్‌లో చేరుతుంది:

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 ... ను చైల్డ్ ప్రాసెస్‌గా సృష్టిస్తుంది, మరియు ఆ ప్రాసెస్ యొక్క 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 సర్వర్‌లు ప్రాజెక్ట్ ఫైళ్లు మరియు లోకల్ సర్వీసులకు ప్రత్యక్ష యాక్సెస్‌తో దాని పక్కనే నడుస్తాయి, నెట్‌వర్క్ రౌండ్-ట్రిప్ అవసరం లేదు.

దశ 2: రిమోట్ HTTP సర్వర్‌ను బిల్డ్ చేయండి

ఒక stdio సర్వర్ దాని పేరెంట్‌తో పాటు ముగుస్తుంది. ప్రతి క్లయింట్ కోసం నిలిచి ఉండే టూల్ మీకు కావాలంటే — ఒక షేర్డ్ ఆప్స్ టూల్, డేటాబేస్ గేట్‌వే, మీ ల్యాప్‌టాప్ మరియు మీ CI రెండూ పిలిచే ఏదైనా — మీకు HTTP ట్రాన్స్‌పోర్ట్ మరియు నిజమైన సర్వీస్ అవసరం. అధికారిక SDK ఉపయోగించి ఒక టూల్‌ను బహిర్గతం చేసే కనీస పైథాన్ సర్వర్ ఇక్కడ ఉంది:

# /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 కు మాత్రమే బైండ్ అవుతుంది — బాక్స్ బయట నుండి ఏదీ దీనిని నేరుగా చేరుకోలేదు, ఆథెంటికేషన్ లేకుండా ఉండగా మీకు సరిగ్గా అదే కావాలి. దీన్ని దాని స్వంత 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 తో దాన్ని నడుపుతూ ఉంచండి

ఏజెంట్ పిలిచేటప్పుడు ఆగిపోయే సాధనం ఉన్నంత లేకపోవడమే మంచిది. /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 కు సంబంధించిన పూర్తి పాత్ ఐచ్ఛికం కాదు — దాన్ని /usr/bin/python3 వైపు చూపండి, ప్రక్రియ ModuleNotFoundError: No module named 'mcp' తో మొదలవుతుంది, ఎందుకంటే సిస్టమ్ ఇంటర్‌ప్రెటర్ మీ pip install ను ఎప్పుడూ చూడలేదు. చేతనం చేసి తనిఖీ చేయండి:

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 దోషం ఉంటుంది — అభ్యర్థనలో సెషన్ లేదు, సరైన JSON పేలోడ్ కూడా లేదు — మరియు అది మీరు కోరుకున్నదే: పోర్ట్ స్పందిస్తుందని, ప్రొటోకాల్ మాట్లాడుతుందని ఇది రుజువు. Connection refused లేదా ఖాళీ ప్రత్యుత్తరం అంటే ప్రక్రియ మీరు అనుకున్న చోట బైండ్ కాలేదు; journalctl -u mcp-ops -n 50 చదవండి.

దశ 4: TLS మరియు రివర్స్ ప్రాక్సీని ముందు ఉంచండి

సర్వర్ localhost వద్ద వింటుంది. ఎక్కడ నుండయినా దాన్ని చేరుకోవడానికి, మీరు nginx వద్ద TLSని అంతం చేసి లోపలికి ప్రాక్సీ చేస్తారు. nginxని ఇన్‌స్టాల్ చేయండి, nginxపై Certbot మరియు Let's Encryptతో సర్టిఫికేట్ పొందండి, తర్వాత location బ్లాక్‌ని వ్రాయండి. అత్యంత ముఖ్యమైన భాగం బఫరింగ్‌ని అచేతనం చేయడం. ఎందుకంటే nginx యొక్క అప్రమేయ ప్రవర్తన ప్రతిస్పందన పూర్తయ్యే వరకు ఆపి ఉంచుతుంది. దీనివల్ల SSE స్ట్రీమ్ శాశ్వతంగా ఆగిపోతుంది:

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తో రీలోడ్ చేయండి. మీరు ఇప్పటికే కంటైనర్ల సమూహాన్ని నడుపుతుంటే, అదే పని స్వయంచాలక TLSతో Traefik రివర్స్ ప్రాక్సీ ద్వారా మీ కోసం చేయబడుతుంది. అది సర్టిఫికేట్‌ని జారీ చేస్తుంది మరియు హోస్ట్‌పేరు ద్వారా రూట్ చేస్తుంది. మీరు MCP కంటైనర్‌కు కేవలం లేబుల్‌లను జోడించాలి. ఏ మార్గంలో అయినా, రివర్స్ ప్రాక్సీ ఇప్పుడు పబ్లిక్ పోర్ట్‌పై ఉన్న ఏకైక అంశం. అది మీరు ఇంకా సురక్షితం చేయని సర్వీస్‌ని సూచిస్తోంది. URLని ఎక్కడైనా రిజిస్టర్ చేయడానికి ముందు దాన్ని సరిచేయండి.

దశ 5: ఈ అంశాన్ని ప్రభావితం చేసే భద్రతా నియమం

ధృవీకరణ లేని MCP ఎండ్‌పాయింట్‌ను ఎప్పుడూ బహిర్గతం చేయవద్దు. MCP సర్వర్ అనేది చదువుకోవడానికి మాత్రమే ఉండే API కాదు. ఇది మీ ఫైళ్లు, మీ డేటాబేస్, కొన్నిసార్లు షెల్‌కు టూల్ యాక్సెస్‌ను మంజూరు చేస్తుంది. పబ్లిక్ ఇంటర్నెట్‌లో ఓపెన్ /mcp అనేది మీ AI ఏజెంట్‌కు ఉన్నంతే పరిధి కలిగిన ఒక అపరిచితుడికి సమానం: వారు మీ టూల్స్ జాబితాను చూస్తారు, తర్వాత వాటిని పిలుస్తారు. దాన్ని ధృవీకరణ లేని అడ్మిన్ సాకెట్‌గా పరిగణించండి, ఎందుకంటే అది నిజంగా అదే.

మూడు రక్షణలు, ప్రాధాన్యత క్రమంలో:

1. దాన్ని ప్రచురించవద్దు. సర్వర్‌ను 127.0.0.1 పై ఉంచండి మరియు దానిని SSH టన్నెల్ ద్వారా మీ ల్యాప్‌టాప్ నుండి చేరుకోండి: ssh -L 8000:127.0.0.1:8000 matt@vps, తర్వాత క్లయింట్‌ను http://127.0.0.1:8000/mcp వైపు పాయింట్ చేయండి. ఏదీ ఎప్పుడూ బహిర్గతం కాదు.
2. దాన్ని ప్రైవేట్ నెట్‌వర్క్‌లో ఉంచండి. సెల్ఫ్-హోస్టెడ్ WireGuard VPN యొక్క టన్నెల్ చిరునామాను బైండ్ చేయండి మరియు VPN పీర్లు మాత్రమే దానిని చేరుకోనివ్వండి. పబ్లిక్ ఇంటర్నెట్ క్లోజ్డ్ పోర్ట్‌ను చూస్తుంది.
3. ఒకవేళ అది తప్పనిసరిగా పబ్లిక్‌గా ఉంటే, టోకెన్‌ను కోరండి. సరైన సమాధానం HTTP ట్రాన్స్‌పోర్ట్ స్థానికంగా సపోర్ట్ చేసే MCP OAuth ఫ్లో. ప్రాక్టికల్ కనీసం ప్రాక్సీ వద్ద తనిఖీ చేసిన షేర్డ్ బేరర్ టోకెన్ — చౌకగా ఉంటుంది, మరియు ఇది డ్రైవ్-బై దాడిని పూర్తిగా ఆపుతుంది:

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

టోకెన్‌ను openssl rand -hex 32 తో జనరేట్ చేయండి, మరియు వీటిలో ఒకటి ముందు లేకుండా సర్వర్‌ను 0.0.0.0 కు ఎప్పుడూ బైండ్ చేయవద్దు. క్లయింట్ టోకెన్‌ను హెడర్‌గా పంపుతుంది. Claude Code లో:

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

MCP_TOKEN ను మీ షెల్‌లో సెట్ చేయండి తద్వారా రహస్యం .mcp.json లో ప్లెయిన్‌టెక్స్ట్‌లో ఎప్పుడూ చేరదు — Claude Code చదివే సమయంలో ${MCP_TOKEN} ను ఎన్విరాన్‌మెంట్ నుండి విస్తరిస్తుంది.

దశ 6: MCP Inspectorతో డీబగ్ చేయండి

సర్వర్ తప్పుగా ప్రవర్తించినప్పుడు, ఏజెంట్ లోపల నుండి ఊహించకండి — దాన్ని నేరుగా Inspectorతో నడపండి, అది అధికారిక వెబ్ ఆధారిత టెస్ట్ క్లయింట్. stdio సర్వర్ కోసం, ఏజెంట్ నడిపే అదే కమాండ్‌ను అందించండి:

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

ఇది http://localhost:6274 పై UIని ప్రారంభిస్తుంది (తాజా వెర్షన్‌లు MCP_PROXY_AUTH_TOKEN క్వెరీ స్ట్రింగ్‌తో ఒక URLను ప్రింట్ చేస్తాయి — ఆ ఖచ్చితమైన లింక్‌ను ఉపయోగించండి, లేదంటే UI మిమ్మల్ని తిరస్కరిస్తుంది) మరియు 6277 పై ప్రాక్సీని ప్రారంభిస్తుంది. Connect క్లిక్ చేయండి, తర్వాత List Tools, తర్వాత వాస్తవ ఆర్గ్యుమెంట్‌లతో Call Tool క్లిక్ చేయండి. అది Inspectorలో పనిచేసి ఏజెంట్‌లో విఫలమైతే, బగ్ మీ క్లయింట్ కాన్ఫిగ్‌లో ఉంది, సర్వర్‌లో కాదు. రిమోట్ HTTP సర్వర్ కోసం, Streamable HTTP ట్రాన్స్‌పోర్ట్‌ను ఎంచుకోండి, https://mcp.example.com/mcp నమోదు చేయండి, Authorization హెడర్‌ను జోడించండి, మరియు కనెక్ట్ అవ్వండి — ఏదైనా ఏజెంట్ పాల్గొనకముందే ప్రామాణీకరణ మరియు ప్రాక్సీ సరైనవే అని నిరూపించడానికి ఇదే అత్యంత వేగవంతమైన మార్గం.

సర్వర్‌లను నవీకరించచి ఉంచడం

MCP వేగంగా మారుతుంది, కాబట్టి ఒక షెడ్యూల్‌లో ప్యాచ్ వేయండి. npx -yతో ప్రారంభించబడిన Node సర్వర్‌లు ప్రతి స్పాన్‌లో తాజా వెర్షన్‌ను పొందుతాయి. ఇది సౌకర్యవంతంగా ఉంటుంది కానీ పునరుత్పాదించలేనిది. మీరు టెస్ట్ చేసిన సరైన వెర్షన్‌ను పిన్ చేయండి — దాన్ని 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తో నవీకరించబడతాయి. మీరు అప్‌గ్రేడ్ చేసేటప్పుడు మీ SDK లక్ష్యంగా చేసుకున్న స్పెక్ రివిజన్‌ను గమనించండి — SSE-to-Streamable-HTTP హద్దును దాటే మార్పు మీ క్లయింట్‌లు అభ్యర్థించాల్సిన ట్రాన్స్‌పోర్ట్‌ను మార్చగలదు.

వైఫల్య రకాలు, మీరు చూసే స్ట్రింగ్‌లతో

ఏజెంట్ సర్వర్ విఫలమైందని చూపిస్తుంది. claude mcp list అనేది ✗ Failed to connect ప్రింట్ చేస్తుంది. TUI MCP server 'filesystem' failed to start ని విఫలమైందని నివేదిస్తుంది. claude --debug నడిపితే మీరు సాధారణంగా Error: spawn npx ENOENT చూస్తారు — ఆ కమాండ్ ఏజెంట్ PATH లో లేదు. రన్‌టైమ్ లేదు లేదా ఏజెంట్ వెతుకుతున్న చోట లేదు: Node ఇన్‌స్టాల్ కాలేదు, npx లేదు, లేదా వర్చువలెన్వ్ Python ను సాధారణ పేరుతో సూచించారు. కమాండ్‌ను పూర్తి పాత్‌కి మార్చండి లేదా రన్‌టైమ్‌ను ఇన్‌స్టాల్ చేయండి, తర్వాత మళ్లీ కనెక్ట్ చేయండి.

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; (మరియు Step 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

సర్వర్ అంటే ఖచ్చితంగా ఏమిటి?

ఇది JSON-RPC 2.0 ని ఉపయోగించి, Model Context Protocol ద్వారా ఒక AI క్లయింట్‌కు టూల్స్ మరియు వనరులను అందించే ఒక ప్రోగ్రామ్. AI మోడల్ టూల్‌ను ఎప్పుడూ స్వయంగా అమలు చేయదు — అది దాని క్లయింట్‌ను అభ్యర్థిస్తుంది, క్లయింట్ MCP సర్వర్‌ను పిలుస్తుంది, సర్వర్ దాన్ని అమలు చేసి ఫలితాన్ని అందిస్తుంది. ప్రోటోకాల్ ప్రామాణికమైనది కాబట్టి, ఒకే సర్వర్ ఏ అనువర్తిత క్లయింట్‌తోనైనా పనిచేస్తుంది, అది Claude Code, Claude Desktop, లేదా Gemini CLI అయినా సరే.

stdio మరియు HTTP ట్రాన్స్‌పోర్ట్ మధ్య తేడా ఏమిటి?

stdio సర్వర్‌ను క్లయింట్ ఒక చైల్డ్ ప్రాసెస్‌గా ప్రారంభిస్తుంది మరియు stdin/stdout ద్వారా సందేశాలు పంపుకుంటుంది, కాబట్టి అది ఒకే మెషీన్‌లో ఒకే క్లయింట్‌తో పుడుతుంది మరియు మరణిస్తుంది, నెట్‌వర్క్ లేదా ప్రామాణీకరణ అవసరం లేదు. HTTP సర్వర్ అనేది ఎక్కువ కాలం నడిచే నెట్‌వర్క్ సేవ, దీనిని ఒకేసారి అనేక క్లయింట్‌లు చేరుకోగలవు, అందుకే ఇది TLS మరియు ప్రామాణీకరణను కలిగి ఉండటం అవసరం. స్థానిక, ఒంటరి వినియోగదారు టూల్స్ కోసం stdio ఉపయోగించండి; పంచుకున్న లేదా నిలిపివేయబడిన వాటి కోసం HTTP (ప్రస్తుత సర్వర్‌లలో Streamable HTTP) ఉపయోగించండి.

రిమోట్ MCP సర్వర్‌ను నేను ఎలా సురక్షితం చేయాలి?

ఇది మీ ఫైళ్లు, డేటాబేస్ లేదా షెల్‌కు టూల్ యాక్సెస్‌ను మంజూరు చేస్తుందని భావించండి, మరియు దీన్ని ప్రామాణీకరణ లేకుండా ఎప్పుడూ బహిర్గతం చేయవద్దు. ఉత్తమంగా దీన్ని localhost కు బంధించి, SSH టన్నెల్ లేదా ప్రైవేట్ VPN ద్వారా చేరుకోండి; ఇది తప్పనిసరిగా పబ్లిక్‌గా ఉంటే, దాన్ని బేరర్ టోకెన్ లేదా MCP OAuth ఫ్లోను అమలు చేసే రివర్స్ ప్రాక్సీ వెనుక ఉంచండి. టోకెన్‌ను openssl rand -hex 32 తో సృష్టించండి మరియు ఈ రెండిటిలో ఒకటి ముందు లేకుండా సర్వర్‌ను 0.0.0.0 కు ఎప్పుడూ బంధించవద్దు.

ప్రారంభం కాని సర్వర్‌ను నేను ఎలా డీబగ్ చేయాలి?

ముందుగా claude mcp list తనిఖీ చేయండి — spawn ... ENOENT తో ✗ Failed to connect అంటే కమాండ్ లేదా రన్‌టైమ్ లేదని అర్థం, కాబట్టి పాత్‌ను సరిచేయండి లేదా దాన్ని ఇన్‌స్టాల్ చేయండి. అది కనెక్ట్ అయిన తర్వాత JSON పార్స్ ఎర్రర్‌తో డ్రాప్ అయితే, సర్వర్ stdout కు లాగింగ్ చేస్తోంది మరియు JSON-RPC స్ట్రీమ్‌ను పాడుచేస్తోంది; అన్ని లాగింగ్‌ను stderr కు తరలించండి. మరేదైనా ఉంటే, MCP ఇన్స్పెక్టర్ కింద సరైన కమాండ్‌ను అమలు చేయండి, ఇది సర్వర్‌ను ఒంటరిగా నడుపుతుంది తద్వారా మీరు సర్వర్ బగ్‌ను క్లయింట్-కాన్ఫిగ్ బగ్ నుండి వేరుగా గుర్తించగలుగుతారు.