ஆல் Matt Connor 2026-07-15 · புதுப்பிக்கப்பட்டது 2026-08-30

VPS-ல் MCP servers இயக்குவது எப்படி?

Q: தொடங்காத server-ஐ எவ்வாறு debug செய்வது?

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

VPS-ல் stdio மற்றும் remote HTTP MCP servers அமைப்பதற்கான முழுமையான வழிகாட்டி. Systemd, TLS, மற்றும் பாதுகாப்பான அங்கீகார முறைகளை பயன்படுத்தி AI agents-க்கு கருவிகளை இணைக்கலாம்.

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

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

MCP என்றால் என்ன

Model Context Protocol என்பது AI client (Claude Code, Claude Desktop, VPS-ல் உள்ள Gemini CLI, அல்லது உங்கள் சொந்த script) வெளிப்புறக் கருவிகளை (tools) அழைக்கவும், வெளிப்புற வளங்களை (resources) வாசிக்கவும் உதவும் ஒரு தரநிலையாகும். AI model நேரடியாக எதையும் இயக்குவதில்லை. அது client-யிடம் கேட்கிறது, client JSON-RPC 2.0 மூலம் MCP server-உடன் பேசுகிறது, server அந்த கருவியை இயக்கி முடிவை மீண்டும் வழங்குகிறது. மக்கள் agent harness என்று குறிப்பிடுவது இந்த client-ஐத்தான்: இதுவே model-ஐச் சுற்றியுள்ள loop; இதுதான் கருவிப் பட்டியல், அனுமதிச் சோதனைகள் மற்றும் session நிலை ஆகியவற்றைக் கட்டுப்படுத்துகிறது. MCP என்பது அதன் கருவிப் பகுதியை நீட்டிக்கும் ஒரு வழியாகும். இது ஒரு பொதுவான protocol என்பதால், நீங்கள் ஒருமுறை எழுதும் server, MCP-ஐ ஆதரிக்கும் அனைத்து client-களுடனும் வேலை செய்யும். இந்த கட்டமைப்பு உங்களுக்குப் புதியது என்றால், குறிப்பாக ஒரு model எப்படி ஒரு கருவியைப் பயன்படுத்தத் தீர்மானிக்கிறது என்பதைப் புரிந்துகொள்ள, agent அடிப்படைகள் குறித்த இந்த வழிகாட்டியை ஒரு மணிநேரம் படித்துப் பார்ப்பது நல்லது. இதற்குப் பிறகுதான் இந்த server-களுக்கு உண்மையான credentials-ஐ வழங்க வேண்டும்.

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

stdio. Client, server-ஐ ஒரு child process-ஆக உருவாக்கி, அதன் standard input மற்றும் standard output வழியாக newline-delimited JSON-RPC செய்திகளைப் பரிமாறிக்கொள்ளும். இதில் network, port, அல்லது auth கிடையாது; process-ன் பாதுகாப்பே அதன் எல்லை. பெரும்பாலான உள்ளூர் கருவிகள் (local tools) இந்த முறையிலேயே செயல்படுகின்றன.
Streamable HTTP (மற்றும் அதன் பழைய வடிவமான HTTP+SSE). Server என்பது நீண்ட நேரம் இயங்கும் ஒரு web service ஆகும். Client HTTP வழியாக இணைகிறது, server தனது பதில்களை Server-Sent Events மூலம் அனுப்ப முடியும். பல client-களுடன் ஒரே server-ஐப் பகிர அல்லது ஒரு கருவியை நிரந்தரமாக ஒரு machine-ல் இயக்க இந்த முறை பயன்படுகிறது.

கருவி ஒரு machine மற்றும் ஒரு user-க்கு மட்டுமே சொந்தமானது என்றால் stdio-வைத் தேர்ந்தெடுக்கவும். அது ஒரு பகிரப்பட்ட service என்றால் HTTP-ஐத் தேர்ந்தெடுக்கவும்.

முன்நிபந்தனைகள் மற்றும் கவனிக்க வேண்டிய நடைமுறை சிக்கல்கள்

root அல்லது sudo வசதியுடன் கூடிய புதிய Ubuntu 24.04 KVM VPS இருப்பதாகக் கருதுவோம். அதைத் தாண்டி பின்வருவன அவசியம்:

Server இயங்கும் 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 server-க்கு மட்டுமே தேவை. TLS-க்கு இந்த VPS-ஐச் சுட்டிக்காட்டும் ஒரு பெயர் அவசியம். stdio உதாரணத்திற்கு DNS தேவையில்லை.
512 MB RAM போதுமானது. MCP servers என்பவை மெல்லிய JSON-RPC processes ஆகும். நினைவகத் தேவை என்பது protocol-ஐப் பொறுத்தது அல்ல, உங்கள் tool எதைப் பயன்படுத்துகிறதோ (database driver, file cache) அதைப் பொறுத்தது.
இந்த spec புதியது மற்றும் மாறிக்கொண்டே இருக்கிறது. 2025-03-26 திருத்தத்தில் HTTP+SSE நீக்கப்பட்டு, அதற்குப் பதிலாக Streamable HTTP கொண்டுவரப்பட்டது; SSE deprecated என அறிவிக்கப்பட்டது. SSE இன்னும் வேலை செய்கிறது மற்றும் பல servers அதை ஆதரிக்கின்றன. எனவே, எந்தவொரு transport அமைப்பையும் மாற்ற முடியாத விதியாகக் கருதாமல், server-ன் release notes-ஐ அவ்வப்போது சரிபார்க்கவும்.

படி 1: Claude Code-ல் stdio server-ஐ இணைத்தல்

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

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

-- பிரிப்பான் (separator) முக்கியமானது: இதற்குப் பிறகு வரும் அனைத்தும் Claude Code இயக்கும் கட்டளையாகும், Claude Code-க்கான flag அல்ல. இது project-ன் root-ல் ஒரு .mcp.json கோப்பை உருவாக்குகிறது:

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

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

claude mcp list

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

Agent-ஐ server-ல் இயக்குவதன் முக்கிய நோக்கமே இதுதான்: Claude Code session VPS-ல் tmux-க்குள் இயங்குகிறது, அதன் stdio server-கள் அதே இடத்தில் இயங்குவதால், project கோப்புகளையும் local service-களையும் நேரடியாக அணுக முடியும்; network தாமதம் இருக்காது. Agent-க்கு write_file மற்றும் read_file ஆகிய இரண்டு வசதிகளும் கிடைத்தவுடன், மிகச்சிறிய மாற்றத்தை மட்டும் செய்யும் திறனுடன் அதை இணைப்பது நல்லது. ஏனெனில், filesystem கருவி இருக்கும்போது, ஒரு பெரிய rewrite-ஐச் செய்வது இரண்டு வரி மாற்றத்தைச் செய்வது போலவே எளிதாகிவிடும். இந்த இணைப்பு local கோப்புகளைத் தாண்டிச் செயல்படும்: நீங்கள் ஏற்கனவே VPS-ல் search engine-ஐ இயக்குகிறீர்கள் என்றால், உங்கள் சொந்த SearXNG instance-ஐ search கருவியாக agent-க்கு வழங்கலாம். இது தேடல்களை உங்கள் server-லேயே வைத்திருக்கும், ஆனால் நம்பகத்தன்மையற்ற பக்கங்களின் உரையை நேரடியாக agent-ன் context-க்குள் கொண்டு வரும்.

படி 2: ஒரு remote HTTP server-ஐ உருவாக்குதல்

Stdio server அதன் parent process முடிவடையும் போது தானாகவே நின்றுவிடும். ஒவ்வொரு client-க்கும் ஒரு புதிய instance உருவாக்கப்படும். எனவே, நீங்கள் ஒரே கணினியில் இரண்டு Claude Code sessions-ஐ இயக்கி, அவற்றுக்கிடையே பணிகளைப் பகிர்ந்தால், ஒவ்வொன்றும் அந்த tool-ன் தனிப்பட்ட நகலைப் பயன்படுத்தும். ஒவ்வொரு client-க்கும் தொடர்ந்து இயங்கக்கூடிய ஒரு shared ops tool, database gateway, அல்லது உங்கள் laptop மற்றும் CI இரண்டிலிருந்தும் அணுகக்கூடிய ஒரு கருவி தேவைப்படும்போது, உங்களுக்கு HTTP transport மற்றும் ஒரு முறையான service தேவை. அதிகாரப்பூர்வ SDK-ஐப் பயன்படுத்தி, ஒரு tool-ஐ மட்டும் வெளிப்படுத்தும் மிகச்சிறிய Python server இதோ:

# /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". இந்த server localhost-ல் மட்டுமே இயங்கும். கணினிக்கு வெளியே இருந்து நேரடியாக இதை அணுக முடியாது. authentication இல்லாத நிலையில் இதுவே பாதுகாப்பானது. இதை ஒரு தனி virtualenv-ல் நிறுவவும், அப்போதுதான் systemd-க்கு நிலையான interpreter path கிடைக்கும்:

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 மூலம் சேவையைத் தொடர்ந்து இயங்க வைத்தல்

ஒரு கருவி தேவைப்படும்போது அது செயலிழந்திருந்தால், அது இல்லாததை விட மோசமானது. client ஒரு நீண்ட காலம் இயங்கும் process-ஆக இருக்கும்போது இது மிக முக்கியமானது: reboot-க்குப் பிறகும் தனது memory மற்றும் schedule-ஐத் தக்கவைத்துக் கொள்ளும் always-on agent, யாரும் கவனிக்காத நேரத்திலும் இக்கருவிகளைத் தானாகவே அழைக்கும். எனவே, server-ம் தானாகவே மீண்டும் இயங்க வேண்டும். /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-ஐ நோக்கிச் சுட்டிக்காட்டவும். அப்போதுதான் process 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 என்று வரும்போது, அதன் body-ல் JSON-RPC error இருக்கும். அந்த request-ல் session-ம் இல்லை, சரியான JSON payload-ம் இல்லை. இதுவே நீங்கள் எதிர்பார்ப்பது: port பதிலளிப்பதையும், protocol-ஐப் பின்பற்றுவதையும் இது உறுதிப்படுத்துகிறது. Connection refused அல்லது காலியான பதில் வந்தால், process நீங்கள் நினைக்கும் இடத்தில் bind ஆகவில்லை என்று அர்த்தம்; journalctl -u mcp-ops -n 50-ஐப் படிக்கவும்.

படி 4: TLS மற்றும் reverse proxy-ஐ முன்னால் அமைத்தல்

Server-ஆனது localhost-ல் மட்டுமே கேட்கிறது (listens). இதை எங்கிருந்து வேண்டுமானாலும் அணுக, nginx-ல் TLS termination செய்து உள்நோக்கி proxy செய்ய வேண்டும். Nginx-ஐ நிறுவி, Certbot மற்றும் Let's Encrypt on nginx மூலம் certificate பெற்று, பின் location block-ஐ எழுதவும். இதில் மிக முக்கியமான விஷயம் buffering-ஐ முடக்குவது (disabling) ஆகும். ஏனெனில், 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-ஐ எங்கும் பதிவு செய்வதற்கு முன்பே இதைச் சரிசெய்யவும்.

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

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

முன்னுரிமை அடிப்படையில் மூன்று பாதுகாப்பு முறைகள்:

இணையத்தில் வெளியிட வேண்டாம். Server-ஐ 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-க்குச் சுட்டிக்காட்டுங்கள். எதையும் பொதுவெளியில் வெளிப்படுத்த வேண்டாம்.
Private network-ல் வையுங்கள். ஒரு self-hosted WireGuard VPN-ன் tunnel முகவரியுடன் இணைத்து, VPN-ல் உள்ளவர்கள் மட்டும் அணுகுமாறு செய்யுங்கள். பொது இணையத்திற்கு அந்த port மூடப்பட்டிருக்கும்.
பொதுவெளியில் இருக்க வேண்டும் என்றால், token கட்டாயம். HTTP transport இயல்பாகவே ஆதரிக்கும் MCP OAuth flow என்பதே சரியான வழி. நடைமுறைக்கு ஏற்ற குறைந்தபட்ச பாதுகாப்பு, proxy-ல் சரிபார்க்கப்படும் ஒரு shared bearer token ஆகும். இது செலவு குறைவானது மற்றும் தேவையற்ற ஊடுருவல்களை முழுமையாகத் தடுக்கும்:

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 மூலம் token-ஐ உருவாக்குங்கள். மேலே உள்ளவற்றில் ஏதேனும் ஒன்று இல்லாமல், server-ஐ ஒருபோதும் 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-ஆனது .mcp.json-ல் plaintext-ஆகப் பதிவாகாது. Claude Code வாசிக்கும்போது ${MCP_TOKEN}-ஐ environment-லிருந்து விரிவுபடுத்திக் கொள்ளும்.

மேலே உள்ள ஒவ்வொரு பாதுகாப்பு முறையும் endpoint-ஐப் பாதுகாக்கிறது. ஆனால், ஏற்கனவே token-ஐ வைத்திருக்கும் agent-ஐப் பாதுகாப்பது சிக்கலின் மறுபாதி: உங்கள் client DeepSeek Harness ஆக இருந்தால், agent எந்தக் கருவிகளை இயக்கலாம் என்பதைக் கட்டுப்படுத்தும் மற்றும் கருவிகளின் வெளியீட்டில் ஊடுருவல் கட்டளைகள் உள்ளதா எனச் சரிபார்க்கும் plugins அந்தப் பக்கத்தைப் பாதுகாக்கும்.

படி 6: MCP Inspector மூலம் பிழைத்திருத்தம் செய்தல்

ஒரு server சரியாகச் செயல்படவில்லை என்றால், agent-க்குள் இருந்து யூகிக்க வேண்டாம். அதிகாரப்பூர்வ web-based test client ஆன Inspector-ஐப் பயன்படுத்தி நேரடியாகச் சோதிக்கவும். ஒரு stdio server-க்கு, agent இயக்கும் அதே கட்டளையை அதற்குக் கொடுக்கவும்:

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-ல் வேலை செய்து, agent-ல் வேலை செய்யவில்லை என்றால், பிழை உங்கள் client configuration-ல் உள்ளது, server-ல் இல்லை. Remote HTTP server-க்கு, Streamable HTTP transport-ஐத் தேர்வு செய்து, https://mcp.example.com/mcp-ஐ உள்ளிடவும், Authorization header-ஐச் சேர்த்து இணைக்கவும். எந்தவொரு agent-ம் ஈடுபடுவதற்கு முன்பே, auth மற்றும் proxy சரியாக உள்ளதா என்பதை உறுதிப்படுத்த இதுவே வேகமான வழியாகும்.

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

MCP மிக வேகமாக மேம்படுத்தப்படுவதால், குறிப்பிட்ட கால இடைவெளியில் patch செய்ய வேண்டும். npx -y மூலம் தொடங்கப்படும் Node சர்வர்கள் ஒவ்வொரு முறையும் புதிய பதிப்பைப் பதிவிறக்கம் செய்யும்; இது வசதியானது என்றாலும், மீண்டும் அதே சூழலை உருவாக்குவது கடினம். நீங்கள் சோதித்த சரியான பதிப்பை npm view @modelcontextprotocol/server-filesystem version-லிருந்து கண்டறிந்து, அதை .mcp.json-ல் உள்ள package பெயருடன் (@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 revision-ஐக் கவனிக்கவும். SSE-லிருந்து Streamable-HTTP எல்லைக்கு மாறுவது, உங்கள் clients கோர வேண்டிய transport முறையை மாற்றக்கூடும்.

தோல்வி முறைகள் மற்றும் நீங்கள் காணக்கூடிய செய்திகள்

Agent சர்வர் தோல்வியடைந்ததாகக் காட்டுகிறது. claude mcp list ஆனது ✗ Failed to connect-ஐ அச்சிடுகிறது, மேலும் TUI MCP server 'filesystem' failed to start-ஐத் தெரிவிக்கிறது. claude --debug-ஐ இயக்கினால், பொதுவாக Error: spawn npx ENOENT-ஐக் காண்பீர்கள்; அந்த command agent-ன் PATH-ல் இல்லை. Runtime விடுபட்டுள்ளது அல்லது agent தேடும் இடத்தில் இல்லை: Node நிறுவப்படவில்லை, npx இல்லை, அல்லது virtualenv Python வெறும் பெயரால் குறிப்பிடப்பட்டுள்ளது. Command-ஐ absolute path-க்கு மாற்றவும் அல்லது runtime-ஐ நிறுவவும், பின் மீண்டும் இணைக்கவும்.

stdio சர்வர் இணைகிறது, ஆனால் உடனடியாகத் துண்டிக்கப்படுகிறது. Client ஒரு JSON parse error-ஐப் பதிவு செய்கிறது, அது Unexpected token 'S', "Server sta"... is not valid JSON அல்லது Failed to parse message போன்றதாக இருக்கும். இதற்கான காரணம் எப்போதும் ஒன்றுதான்: சர்வர் stdout-ல் ஒரு log வரியை எழுதியுள்ளது. stdio-வில், stdout என்பது JSON-RPC channel ஆகும், எனவே ஏதேனும் தேவையற்ற உரை அந்த stream-ஐச் சிதைத்து, handshake-ஐ முறித்துவிடும். Node-ல், console.log stdout-க்குச் செல்லும், அதற்குப் பதிலாக console.error-ஐப் பயன்படுத்தவும். Python-ல், ஒரு சாதாரண print() stdout-க்குச் செல்லும், எனவே logs-ஐ logging மூலம் sys.stderr-க்கு configure செய்து எழுதவும், அல்லது file=sys.stderr-ஐ அனுப்பவும். விதி இதுதான்: stdio-வில், stdout-ல் JSON-RPC மட்டுமே இருக்க வேண்டும், மனிதர்கள் வாசிக்கும் தகவல்கள் அனைத்தும் stderr-ல் இருக்க வேண்டும்.

Remote சர்வர் காலாவதியாகிறது (timeout) அல்லது handshake-ன் பாதியில் துண்டிக்கப்படுகிறது. Client MCP error -32000: Connection closed-ஐக் காட்டி தோல்வியடைகிறது, அல்லது Inspector Connect என்பதில் நின்றுவிடுகிறது, கருவிகளைப் பட்டியலிடுவதில்லை. Nginx-க்கு பின்னால் இது நடப்பதற்கு buffering காரணம்: proxy ஆனது SSE stream-ஐ உடனுக்குடன் அனுப்பாமல் (flush) பிடித்து வைத்துக்கொள்கிறது, இதனால் client வராத ஒரு பதிலுக்காகக் காத்திருக்கிறது. proxy_buffering off;-ஐ (மற்றும் Step 4-ல் உள்ள மீதமுள்ள தொகுதியை) location-ல் சேர்க்கவும். பொது URL-க்கு எதிராக curl -N-ஐப் பயன்படுத்திச் சரிபார்க்கவும்; event தரவு முடிவில் மொத்தமாக வராமல், அவ்வப்போது வந்து சேர்வதை நீங்கள் காண வேண்டும்.

அங்கீகாரம் (Auth) நிராகரிக்கப்படுகிறது. Client Error POSTing to endpoint (HTTP 401) அல்லது நேரடியாக 401 Unauthorized-ஐத் தெரிவிக்கிறது. Header விடுபட்டிருக்கலாம், token தவறாக இருக்கலாம், அல்லது client configuration-ஐப் படிக்கும்போது shell variable காலியாக இருந்திருக்கலாம். இது ஒரு பொதுவான தவறு, ஏனெனில் variable unset செய்யப்பட்டிருந்தால் ${MCP_TOKEN} எதுவுமில்லாமல் விரிவடையும், அப்போது nginx Bearer -ஐ மதிப்பு எதுவுமின்றிப் பார்க்கும். Variable-ஐ echo செய்து சரிபார்க்கவும், header-ஐ மீண்டும் சேர்க்கவும், மேலும் nginx if-ல் உள்ள token-உடன் துல்லியமான bytes பொருந்துகிறதா என்பதை உறுதிப்படுத்தவும்.

Service systemd-ன் கீழ் தொடங்கவில்லை. journalctl -u mcp-ops ஆனது ModuleNotFoundError: No module named 'mcp'-ஐக் காட்டுகிறது, ExecStart venv interpreter-க்கு பதிலாக system Python-ஐக் குறிக்கிறது. அல்லது Address already in use, மற்றொரு process 8000 port-ஐப் பிடித்துள்ளது; அதை sudo ss -ltnp | grep 8000 மூலம் கண்டறியவும்.

FAQ

MCP server என்றால் என்ன?

இது Model Context Protocol மூலம் JSON-RPC 2.0-ஐப் பயன்படுத்தி, AI client-க்கு கருவிகளையும் (tools) வளங்களையும் (resources) வழங்கும் ஒரு நிரலாகும். AI model நேரடியாக அந்த கருவியை இயக்குவதில்லை; அது தனது client-க்கு கோரிக்கை விடுக்கிறது, client அந்த MCP server-ஐ அழைக்கிறது, server அதை இயக்கி முடிவை வழங்குகிறது. இந்த protocol தரப்படுத்தப்பட்டதால், Claude Code, Claude Desktop அல்லது Gemini CLI என எந்தவொரு இணக்கமான client-டனும் ஒரு server வேலை செய்யும்.

stdio மற்றும் HTTP transport-க்கு என்ன வித்தியாசம்?

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

தொலைதூர MCP server-ஐ எவ்வாறு பாதுகாப்பது?

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

தொடங்காத server-ஐ எவ்வாறு debug செய்வது?

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

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