SSD Nodes Learn
கல்வி வழிகாட்டிகள் Matt Connorஆல் Matt Connor · புதுப்பிக்கப்பட்டது 2026-07-25

VPS-இல் MCP server இயக்கம் AI coding agent-களுக்கு

VPS-இல் MCP server-ஐ stdio மற்றும் remote HTTP transport மூலம் இயக்குவது எப்படி. systemd, TLS, auth அமைப்பும் JSON-RPC stream பிழைகளும் விரிவாக விளக்கப்பட்டுள்ளன.

நீங்கள் உருவாக்குவது என்ன

ஒரே VPS-இல் இரண்டு செயல்படும் MCP அமைப்புகள். முதலாவது ஒரு stdio சர்வர் — filesystem அல்லது database கருவி. Claude Code இதை child process-ஆகத் தொடங்கும். தகவல்தொடர்பு ஒரு pipe வழியாக நடைபெறும். அடுத்தது ஒரு remote HTTP சர்வர். இது systemd மற்றும் TLS கொண்ட nginx reverse proxy-க்குப் பின்னால் இயங்கும் நீண்ட கால network service. நீங்கள் சுட்டிக்கும் எந்த MCP client-உம் இதை அணுக முடியும். இரண்டின் நிறுவலும் சிறியது. இந்த வழிகாட்டியின் பெரும்பகுதி இரண்டு உண்மையில் பிரச்சினை உருவாக்கும் விஷயங்களைப் பற்றியது: JSON-RPC stream-ஐ சுத்தமாக வைத்திருப்பது, மற்றும் அங்கீகரிக்கப்படாத tool endpoint-ஐ பொது இணையத்தில் வைக்காதிருப்பது.

MCP உண்மையில் என்ன

Model Context Protocol என்பது ஒரு AI கிளையன்ட் — Claude Code, Claude Desktop, VPS-இல் உள்ள Gemini CLI, அல்லது உங்கள் சொந்த ஸ்கிரிப்ட் — வெளிப்புற கருவிகளை அழைத்து வெளிப்புற வளங்களைப் படிக்கப் பயன்படும் ஒரு நிலையான முறையாகும். மாதிரி அதாவது model எதையும் இயக்குவதில்லை. அது கிளையன்டிடம் கேட்கிறது. கிளையன்ட் ஒரு MCP சர்வருடன் JSON-RPC 2.0 மூலம் பேசுகிறது. சர்வர் கருவியை இயக்கி முடிவைத் திருப்பித் தருகிறது. இது ஒரே ஒரு நெறிமுறை என்பதால், நீங்கள் ஒரு முறை எழுதும் சர்வர் MCP பேசும் ஒவ்வொரு கிளையன்டுடனும் வேலை செய்யும்.

இரண்டு போக்குவரத்து முறைகள் உள்ளன. இந்த வழிகாட்டியின் மீதமுள்ள முழுப் பகுதியும் இவற்றின் அடிப்படையில் பிரிக்கப்படுகிறது:

  • stdio. கிளையன்ட் சர்வரை ஒரு child process ஆக உருவாக்கி, அதன் standard input மற்றும் standard output வழியாக newline-delimited JSON-RPC செய்திகளைப் பரிமாறிக்கொள்கிறது. நெட்வொர்க் இல்லை, port இல்லை, auth இல்லை — நம்பிக்கை எல்லை அந்த process தான். ஏறக்குறைய ஒவ்வொரு உள்ளக கருவியும் இந்த வழியில் வருகிறது.
  • Streamable HTTP (மற்றும் இதன் பழைய வடிவமான HTTP+SSE). சர்வர் என்பது தொடர்ந்து இயங்கும் ஒரு web service ஆகும். கிளையன்ட் HTTP வழியாக இணைகிறது. சர்வர் பதில்களை Server-Sent Events ஆக stream செய்து திருப்பித் தர முடியும். ஒரு சர்வரை பல கிளையன்ட்களுடன் பகிர்வதற்கு அல்லது நிரந்தரமாக அந்த சர்வரிலேயே இயங்க வேண்டிய ஒரு கருவியை இயக்குவதற்கு இதுவே வழியாகும்.

கருவி ஒரு கணினிக்கும் ஒரு பயனருக்கும் சொந்தமானதாக இருந்தால் stdio ஐத் தேர்ந்தெடுக்கவும். அது ஒரு பகிரப்பட்ட சேவையாக இருந்தால் HTTP ஐத் தேர்ந்தெடுக்கவும்.

முன்தேவைகள் மற்றும் நேர்மையான சிக்கல்கள்

ஒரு புதிய Ubuntu 24.04 KVM VPS, root அல்லது sudo அணுகலுடன் இருப்பதாகக் கருதுங்கள். இதற்கு அப்பால்:

  • சேவையகம் எழுதப்பட்ட ஒரு இயக்க நேரம். பெரும்பாலான குறிப்பு சேவையகங்கள் Node அல்லது Python கொண்டவை. Ubuntu 24.04 இல் Node 18 உள்ளது. தற்போதைய பல MCP தொகுப்புகளுக்கு Node 20 அல்லது அதற்கு மேற்பட்ட பதிப்பு தேவை. எனவே apt-ஐ நம்பாமல் NodeSource அல்லது nvm மூலம் தற்போதைய LTS பதிப்பை நிறுவவும். Python 3.12 ஏற்கனவே உள்ளது.
  • ஒரு டொமைன் மற்றும் DNS A record, ஆனால் இது தொலை HTTP சேவையகத்திற்கு மட்டுமே — TLS-க்கு இந்த VPS-ஐ நோக்கி தீர்க்கும் ஒரு பெயர் தேவை. stdio உதாரணத்திற்கு DNS தேவையே இல்லை.
  • 512 MB RAM போதுமானது. MCP சேவையகங்கள் எளிய JSON-RPC செயல்கள். நினைவகச் செலவு உங்கள் கருவி எதைத் தொடுகிறதோ அதைப் பொறுத்தது (தரவுத்தள இயக்கி, கோப்பு cache), நெறமுறையை அல்ல.
  • விவரக்குறிப்பு புதியது மற்றும் மாறிக்கொண்டிருக்கிறது. 2025-03-26 திருத்தம் HTTP+SSE-ஐ Streamable HTTP கொண்டு மாற்றியது. SSE-ஐ நிராகரிக்கப்பட்டதாகக் குறித்தது. SSE இன்னும் செயல்படுகிறது. பல சேவையகங்கள் இன்னும் அதைப் பயன்படுத்துகின்றன. எனவே எந்தப் போக்குவரத்து பின்னிணைப்பையும் முழுமையான உண்மையாக ஏற்றுக்கொள்ளாமல், சேவையகத்தின் வெளியீட்டுக் குறிப்புகளுக்கு எதிராக மறுபரிசீலனை செய்ய வேண்டிய ஒன்றாகக் கருதுங்கள்.

படி 1: ஒரு stdio சேவையகத்தை Claude Code உடன் இணைக்கவும்

filesystem சேவையகத்தில் தொடங்கவும் — இது அதிகாரப்பூர்வமானது, தீவிரமாக பராமரிக்கப்படுகிறது, மேலும் Node தவிர வேறொன்றும் தேவையில்லை. கீழே உள்ள ஒரே ஒரு கட்டளை அதை Claude Code உடன் பதிவுசெய்கிறது, தற்போதைய திட்டத்திற்கு மட்டும் வரம்பிடுகிறது, எனவே அது commit செய்யக்கூடிய ஒரு கோப்பில் சேமிக்கப்படுகிறது:

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 க்கான flag அல்ல. அது திட்ட வேரில் ஒரு .mcp.json கோப்பை எழுதுகிறது:

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

இதுவரை எதுவும் இயங்கவில்லை. நீங்கள் அடுத்து இந்த அடைவில் Claude Code ஐ தொடங்கும்போது, agent .mcp.json ஐ படிக்கிறது, npx -y @modelcontextprotocol/server-filesystem ... ஐ ஒரு child process ஆக உருவாக்குகிறது, மேலும் அந்த process இன் stdin/stdout வழியாக MCP handshake ஐ செய்கிறது. அது வெற்றியடைந்ததை உறுதிப்படுத்திக்கொள்ளவும்:

claude mcp list

ஒரு ஆரோக்கியமான சேவையகம் அதன் கட்டளையையும் பச்சை நிற உறுதிப்படுத்தல் குறியீட்டையும் அச்சிடுகிறது — filesystem: npx -y @modelcontextprotocol/server-filesystem ... - ✓ Connected. session க்குள், /mcp slash கட்டளை சேவையகம் வெளிப்படுத்தும் கருவிகளை பட்டியலிடுகிறது (read_file, write_file, list_directory), மேலும் agent இப்போது நீங்கள் அனுமதித்த பாதைகளில் அவற்றை அழைக்க முடியும். ஒரு database கருவும் இதே அமைப்பில் இருக்கும் — package ஐ மாற்றி, அதன் இறுதி argument ஆக ஒரு connection string ஐ அனுப்பவும் — ஆனால் தற்போதைய package பெயருக்காக சேவையகத்தின் சொந்த களஞ்சியத்தை சரிபார்க்கவும், ஏனெனில் reference Postgres சேவையகம் ஒன்றுக்கு மேற்பட்ட முறை கைமாறியுள்ளது.

agent ஐ VPS இல் இயக்குவதன் முக்கிய நோக்கம் இதுதான்: Claude Code session tmux க்குள் VPS இல் இயங்குகிறது, மேலும் அதன் stdio சேவையகங்கள் திட்ட கோப்புகள் மற்றும் உள்ளூர் சேவைகள் மீது நேரடி அணுகலுடன் அதற்கு அருகிலேயே இயங்குகின்றன, எந்த பிணைய சுற்றுப்பயணமும் இல்லை.

படி 2: ஒரு தொலை HTTP சேவையகத்தை உருவாக்கவும்

ஒரு stdio சேவையகம் அதை இயக்கும் பெற்றோர் செயல்முறையுடன் சேர்ந்து நிறுத்தப்படுகிறது. ஒவ்வொரு கிளையன்டுக்கும் தொடர்ந்து இயங்கிக்கொண்டிருக்கும் ஒரு கருவி தேவைப்படும்போது — ஒரு பகிரப்பட்ட செயல்பாட்டு கருவி, ஒரு தரவுதள நுழைவாயில், உங்கள் மடிக்கணினி மற்றும் 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 உடன் மட்டுமே இணைக்கப்படுகிறது — இந்த கணினிக்கு வெளியே இருப்பவை எதுவும் இதனை நேரடியாக அணுக முடியாது. அங்கீகாரம் இல்லாத நிலையில் இதுவே நீங்கள் விரும்பும் அமைப்பு. systemd க்கு ஒரு நிலையான மொழிபெயர்ப்பி பாதை கிடைக்க, இதனை அதனுடைய சொந்த virtualenv இல் நிறுவவும்:

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 பிளாக்கை எழுதவும். முக்கியமான பகுதி buffering-ஐ முடக்குவதாகும், ஏனெனில் 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 ரிவர்ஸ் ப்ராக்ஸி அதே வேலையை உங்களுக்காகச் செய்கிறது — இது சான்றிதழை வழங்கி hostname மூலம் வழிநடத்துகிறது, நீங்கள் MCP கொள்கலனுக்கு labels சேர்க்கிறீர்கள். எப்படியிருந்தாலும், ரிவர்ஸ் ப்ராக்ஸி இப்போது பொது port-இல் உள்ள ஒரே ஒரு பொருள், அது நீங்கள் இன்னும் பாதுகாப்பாக்காத ஒரு சேவையை சுட்டிக்காட்டுகிறது. URL-ஐ எங்கேனும் பதிவு செய்வதற்கு முன் அதை சரிசெய்யவும்.

படி 5: இந்த தலைப்பில் முதன்மையான பாதுகாப்பு விதி

அங்கீகரிக்கப்படாத MCP endpoint-ஐ ஒருபோதும் வெளிப்படுத்த வேண்டாம். MCP சர்வர் என்பது read-only API அல்ல. இது கருவி அணுகலை வழங்குகிறது — உங்கள் கோப்புகள், உங்கள் தரவுத்தளம், சில நேரங்களில் shell ஆகியவற்றை. பொது இணையத்தில் திறந்திருக்கும் /mcp என்பது உங்கள் AI agent-க்கு இருக்கும் அதே அணுகல் கொண்ட ஒரு அந்நியர்: அவர்கள் உங்கள் கருவிகளை பட்டியலிடுவார்கள், பிறகு அவற்றை அழைப்பார்கள். இதை அங்கீகரிக்கப்படாத admin socket-ஆகவே கருதுங்கள், ஏனெனில் அதுவே அது.

மூன்று பாதுகாப்பு முறைகள், விருப்பத்தேர்வின் வரிசையில்:

  1. இதை வெளியிட வேண்டாம். சர்வரை 127.0.0.1-ல் வைத்திருங்கள், உங்கள் மடிக்கணினியிலிருந்து SSH tunnel மூலம் அணுகுங்கள்: ssh -L 8000:127.0.0.1:8000 matt@vps, பிறகு client-ஐ http://127.0.0.1:8000/mcp-க்கு சுட்டிக்காட்டுங்கள். எதுவும் வெளிப்படுத்தப்படுவதில்லை.
  2. இதை தனியார் நெட்வொர்க்கில் வையுங்கள். ஒரு self-hosted WireGuard VPN-ன் tunnel முகவரியுடன் இணைத்து, VPN peer-கள் மட்டுமே அணுக அனுமதியுங்கள். பொது இணையம் ஒரு மூடிய போர்ட்டைக் காண்கிறது.
  3. இது பொதுவாக இருக்க வேண்டுமென்றால், ஒரு token-ஐ கட்டாயமாக்குங்கள். சரியான தீர்வு HTTP transport இயல்பாக ஆதரிக்கும் MCP OAuth flow ஆகும். நடைமுறைக்குரிய குறைந்தபட்சம் proxy-ல் சரிபார்க்கப்படும் ஒரு பகிரப்பட்ட 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 உடன் உருவாக்குங்கள், மேலும் இவற்றில் ஒன்று முன்னால் இல்லாமல் சர்வரை 0.0.0.0-க்கு ஒருபோதும் இணைக்க வேண்டாம். Client பிறகு token-ஐ ஒரு header-ஆக அனுப்புகிறது. Claude Code-ல்:

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

ரகசியம் ஒருபோதும் .mcp.json-ல் வெளிப்படையாக இல்லாமல் இருக்க MCP_TOKEN-ஐ உங்கள் shell-ல் அமைக்கவும் — 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 query string உடன் ஒரு URL ஐ அச்சிடுகின்றன — அந்த சரியான இணைப்பைப் பயன்படுத்தவும், இல்லையெனில் UI உங்களை நிராகரிக்கும்) மற்றும் 6277 இல் ஒரு proxy ஐத் தொடங்குகிறது. Connect ஐக் கிளிக் செய்யவும், பிறகு List Tools ஐக் கிளிக் செய்யவும், பிறகு உண்மையான arguments உடன் Call Tool ஐக் கிளிக் செய்யவும். இது Inspector இல் வேலை செய்து முகவருக்குள் தோல்வியடைந்தால், பிழை உங்கள் வாடிக்கையாளர் config இல் இருக்கிறது, சேவையகத்தில் இல்லை. தொலை HTTP சேவையகத்திற்கு, Streamable HTTP transport ஐத் தேர்ந்தெடுக்கவும், https://mcp.example.com/mcp ஐ உள்ளிடவும், Authorization header ஐச் சேர்க்கவும், பிறகு இணைக்கவும் — இது எந்த முகவரும் சம்பந்தப்படுவதற்கு முன்பு auth மற்றும் proxy சரியானவை என்பதை நிரூபிப்பதற்கான விரைவான வழியாகும்.

சர்வர்களைப் புதுப்பித்த வைத்தல்

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 குறிவைக்கும் spec திருத்தத்தைக் கவனிக்கவும். SSE-இலிருந்து Streamable-HTTP-க்கு எல்லை தாண்டும் ஒரு மாற்றம் உங்கள் கிளையன்ட்கள் கோர வேண்டிய போக்குவரத்து முறையை மாற்றக்கூடு.

பிழை நிலைகள், நீங்கள் காணும் சரங்களுடன்

முகவர் சேவையகம் தோல்வியடைந்ததைக் காட்டுகிறது. claude mcp list என்பதை ✗ Failed to connect அச்சிடுகிறது, மேலும் TUI ஆனது MCP server 'filesystem' failed to start என்பதைத் தெரிவிக்கிறது. claude --debug ஐ இயக்குங்கள்; பொதுவாக நீங்கள் Error: spawn npx ENOENT ஐக் காண்பீர்கள் — கட்டளை முகவரின் PATH இல் இல்லை. இயக்க நேரம் இல்லை அல்லது முகவர் தேடும் இடத்தில் இல்லை: Node நிறுவப்படவில்லை, npx இல்லை, அல்லது வெற்றுப் பெயரால் குறிப்பிடப்பட்ட virtualenv 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 உடன் தோல்வியடைகிறார், அல்லது Inspector Connect இல் சிக்கிக்கொண்டு கருவிகளை ஒருபோதும் பட்டியலிடுவதில்லை. nginx க்குப் பின்னால் இது தற்காலிக சேமிப்பு: ப்ராக்ஸி ஸ்ட்ரீமை வெளியேற்றாமல் SSE ஸ்ட்ரீமைத் தடுத்து வைக்கிறது, எனவே வாடிக்கையாளர் ஒருபோதும் வராத பதிலுக்காகக் காத்திருக்கிறார். proxy_buffering off; ஐ (மற்றும் படி 4 இல் உள்ள மீதமுள்ள தொகுதியை) location க்குச் சேர்க்கவும். பொது URL க்கு எதிராக curl -N உடன் உறுதிப்படுத்தவும் — நிகழ்வுத் தரவு ஒரே நேரத்தில் இறுதியில் வருவதை விட, படிப்படியாக வருவதை நீங்கள் காண வேண்டும்.

அங்கீகாரம் நிராகரிக்கப்படுகிறது. வாடிக்கையாளர் Error POSTing to endpoint (HTTP 401) அல்லது வெறுமனே 401 Unauthorized எனத் தெரிவிக்கிறார். தலைப்பு இல்லை, டோக்கன் தவறானது, அல்லது வாடிக்கையாளர் உள்ளமைவைப் படிக்கும்போது ஷெல் மாறி காலியாக இருந்தது — இது ஒரு பொதுவான சிக்கல், ஏனெனில் மாறி அமைக்கப்படாவிட்டால் ${MCP_TOKEN} எதற்கும் விரிவடையாது, பின்னர் nginx மதிப்பு இல்லாமல் Bearer ஐக் காண்கிறது. மாறியை அச்சிடவும், தலைப்பை மீண்டும் சேர்க்கவும், மேலும் 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 சர்வர் என்பது நிஜத்தில் என்ன?

இது JSON-RPC 2.0 வழியாக AI கிளையன்டுக்கு கருவிகளையும் வளங்களையும் வழங்கும் ஒரு நிரல். AI மாதிரி கருவியை நேரடியாக இயக்காது — அது தன் கிளையன்டிடம் கேட்கும், கிளையன்ட் MCP சர்வரை அழைக்கும், சர்வர் இயக்கி முடிவைத் திருப்பி அனுப்பும். இந்த நெறிமுறை தரப்படுத்தப்பட்டதாக இருப்பதால், ஒரே சர்வர் ஏதேனும் இணக்கமான கிளையன்டுடன் வேலை செய்யும்; அது Claude Code, Claude Desktop, அல்லது Gemini CLI என எதுவாக இருந்தாலும்.

stdio மற்றும் HTTP போக்குவரத்துக்கு இடையே என்ன வேறுபாடு?

stdio சர்வர் கிளையன்டால் ஒரு child process ஆகத் தொடங்கப்படுகிறது, stdin/stdout வழியாக தொடர்பு கொள்கிறது. எனவே அது ஒரே கணினியில் ஒரே கிளையன்டுடன் மட்டுமே இயங்கி முடிகிறது; இதற்கு பிணையமோ அங்கீகாரமோ தேவையில்லை. HTTP சர்வர் என்பது நீண்ட நேரம் இயங்கும் ஒரு பிணைய சேவை; பல கிளையன்ட்கள் ஒரே நேரத்தில் அணுகலாம். அதனால்தான் இதற்கு TLS மற்றும் அங்கீகாரம் தேவை. உள்ளக, ஒற்றை-பயனர் கருவிகளுக்கு stdio பயன்படுத்தவும்; பகிரப்பட்ட அல்லது நிலையான எதற்கும் HTTP (தற்போதைய சர்வர்களில் Streamable HTTP) பயன்படுத்தவும்.

தொலைநிலை MCP சர்வரை நான் எப்படிப் பாதுகாப்பேன்?

இது உங்கள் கோப்புகள், தரவுத்தளம், அல்லது shell ஆகியவற்றிற்கு கருவி அணுகலை வழங்குகிறது என்று கருதி, அங்கீகாரமின்றி ஒருபோதும் வெளிப்படுத்த வேண்டாம். சிறந்த வழி இதை localhost உடன் பிணைத்து SSH tunnel அல்லது தனியார் VPN வழியாக அணுகுவது; இது பொதுவாகவே இருக்க வேண்டுமென்றால், bearer token அல்லது MCP OAuth flow ஆகியவற்றைச் செயல்படுத்தும் reverse proxy க்குப் பின்னால் வைக்கவும். டோக்கனை openssl rand -hex 32 உடன் உருவாக்கவும்; இவற்றில் ஒன்று முன்னால் இல்லாமல் சர்வரை ஒருபோதும் 0.0.0.0 உடன் பிணைக்க வேண்டாம்.

தொடங்க மறுக்கும் சர்வரை நான் எப்படி வழுநீக்குவேன்?

முதலில் claude mcp list ஐ சரிபார்க்கவும் — ✗ Failed to connect உடன் spawn ... ENOENT என்பது கட்டளை அல்லது runtime காணவில்லை என்று பொருள்; எனவே பாதையைச் சரிசெய்யவும் அல்லது அதை நிறுவவும். இணைந்த பிறகு JSON parse பிழையுடன் துண்டிக்கப்பட்டால், சர்வர் stdout க்கு பதிவு செய்து JSON-RPC ஸ்ட்ரீமைச் சிதைக்கிறது; அனைத்து பதிவையும் stderr க்கு மாற்றவும். வேறெதற்கும், MCP Inspector கீழ் சரியான கட்டளையை இயக்கவும்; இது சர்வரை தனிமைப்படுத்தி இயக்குவதால், சர்வர் பிழையையும் கிளையன்ட்-கட்டமைப்பு பிழையையும் நீங்கள் வேறுபடுத்திப் பார்க்க முடியும்.

#mcp#claude-code#ai-agents#self-hosting#systemd